← Back to branch summary

~ubuntu-branches/ubuntu/karmic/eric/karmic

« back to all changes in this revision

Viewing changes to eric/UI/UserInterface.py

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2008-01-28 18:02:25 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080128180225-6nrox6yrworh2c4v
Tags: 4.0.4-1ubuntu1
* Add python-qt3 to build-depends becuase that's where Ubuntu puts 
  pyqtconfig
* Change maintainer to MOTU

Show diffs side-by-side

added added

removed removed

Lines of Context:
eric/UI/UserInterface.py
9
9
 
10
10
import os
11
11
import sys
12
 
import string
13
12
 
14
 
from qt import *
15
 
from qtext import QSCINTILLA_VERSION_STR
 
13
from PyQt4.QtCore import *
 
14
from PyQt4.QtGui import *
 
15
from PyQt4.Qsci import QSCINTILLA_VERSION_STR
 
16
from PyQt4.QtNetwork import QHttp
16
17
 
17
18
from KdeQt import KQFileDialog, KQMessageBox
 
19
from KdeQt.KQProgressDialog import KQProgressDialog
 
20
from KdeQt.KQApplication import e4App
18
21
import KdeQt
19
22
 
20
 
from IconProvider import IconProvider
21
23
from Debugger.DebugUI import DebugUI
22
24
from Debugger.DebugServer import DebugServer
23
 
from DebugClients.Python.DebugClientCapabilities import HasUnittest
24
 
from SBVviewer import SBVviewer
 
25
from Debugger.DebugViewer import DebugViewer
 
26
from Debugger.DebugClientCapabilities import HasUnittest
 
27
 
25
28
from QScintilla.Shell import Shell
26
 
from Browser import Browser
27
 
from Info import *
28
 
from EmailDialog import EmailDialog
 
29
 
29
30
from PyUnit.UnittestDialog import UnittestDialog
 
31
 
30
32
from Helpviewer.HelpWindow import HelpWindow
 
33
 
31
34
from Preferences.ConfigurationDialog import ConfigurationDialog
32
35
from Preferences.ViewProfileDialog import ViewProfileDialog
33
36
from Preferences.ShortcutsDialog import ShortcutsDialog
34
 
from ToolConfigurationDialog import ToolConfigurationDialog
 
37
from Preferences.ToolConfigurationDialog import ToolConfigurationDialog
 
38
from Preferences.ToolGroupConfigurationDialog import ToolGroupConfigurationDialog
 
39
from Preferences.ProgramsDialog import ProgramsDialog
 
40
 
 
41
from Project.Project import Project
 
42
from Project.ProjectBrowser import ProjectBrowser
 
43
 
 
44
from Tasks.TaskViewer import TaskViewer
 
45
 
 
46
from Templates.TemplateViewer import TemplateViewer
 
47
 
 
48
from Browser import Browser
 
49
from Info import *
 
50
import Config
 
51
from EmailDialog import EmailDialog
35
52
from DiffDialog import DiffDialog
36
53
from CompareDialog import CompareDialog
37
 
from Project.Project import Project
38
 
from Project.ProjectBrowser import ProjectBrowser
39
 
from LogView import LogView
40
 
from TaskViewer import TaskViewer
41
 
from TemplateViewer import TemplateViewer
 
54
from LogView import LogViewer
42
55
from FindFileDialog import FindFileDialog
43
56
from FindFileNameDialog import FindFileNameDialog
 
57
from AboutDialog import AboutDialog
 
58
 
 
59
from E4Gui.E4IconProvider import E4IconProvider
 
60
from E4Gui.E4SingleApplication import E4SingleApplicationServer
 
61
from E4Gui.E4Action import E4Action, E4ActionGroup
 
62
 
 
63
from VCS.StatusMonitorLed import StatusMonitorLed
 
64
 
44
65
from Wizards.Wizard import Wizards
 
66
 
45
67
import Preferences
46
68
import ViewManager
47
69
import Utilities
 
70
 
48
71
import Scripting
49
72
from Scripting.LoadScriptDialog import LoadScriptDialog
50
73
from Scripting.ScriptManager import *
 
74
 
51
75
from Graphics.PixmapDiagram import PixmapDiagram
 
76
 
52
77
import UI.PixmapCache
53
 
from E3SingleApplication import E3SingleApplicationServer
54
 
from AboutDialog import AboutDialog
55
78
 
56
79
from XML.XMLUtilities import make_parser
57
80
from XML.XMLErrorHandler import XMLErrorHandler, XMLFatalParseError
61
84
from XML.TemplatesHandler import TemplatesHandler
62
85
from XML.TemplatesWriter import TemplatesWriter
63
86
 
64
 
from ThirdParty.compactpath import compactpath, pathlabelwrap_qt3
65
 
 
66
 
from E3Action import E3Action, E3ActionGroup
67
 
 
68
 
from eric3config import getConfig
 
87
from ThirdParty.compactpath import compactpath, pathlabelwrap_qt4
 
88
 
 
89
from eric4config import getConfig
69
90
 
70
91
from Refactoring.Refactoring import Refactoring, BRM_VERSION_STR
71
92
 
87
108
        self.stderr = stderr
88
109
        self.buffer = ''
89
110
        
90
 
    def nWrite(self, n):
 
111
    def __nWrite(self, n):
91
112
        """
92
113
        Private method used to write data.
93
114
        
94
115
        @param n max numebr of bytes to write
95
116
        """
96
117
        if n:
97
 
            if self.buffer[n-1] == '\n':
98
 
                line = self.buffer[:n-1]
99
 
            else:
100
 
                line = self.buffer[:n]
 
118
            line = self.buffer[:n]
101
119
            if self.stderr:
102
 
                qApp.mainWidget().showLogTab("stderr")
103
 
                self.emit(PYSIGNAL('appendStderr'), (line,))
 
120
                e4App().getObject("UserInterface").showLogTab("stderr")
 
121
                self.emit(SIGNAL('appendStderr'), line)
104
122
            else:
105
 
                qApp.mainWidget().showLogTab("stdout")
106
 
                self.emit(PYSIGNAL('appendStdout'), (line,))
 
123
                e4App().getObject("UserInterface").showLogTab("stdout")
 
124
                self.emit(SIGNAL('appendStdout'), line)
107
125
            self.buffer = self.buffer[n:]
108
126
            
109
 
    def bufferedWrite(self):
 
127
    def __bufferedWrite(self):
110
128
        """
111
129
        Private method returning number of characters to write.
112
130
        
118
136
        """
119
137
        Public method used to flush the buffered data.
120
138
        """
121
 
        self.nWrite(len(self.buffer))
 
139
        self.__nWrite(len(self.buffer))
122
140
        
123
141
    def write(self, s):
124
142
        """
127
145
        @param s data to be written (it must support the str-method)
128
146
        """
129
147
        self.buffer = self.buffer + unicode(s)
130
 
        self.nWrite(self.bufferedWrite())
 
148
        self.__nWrite(self.__bufferedWrite())
131
149
        
132
150
class UserInterface(QMainWindow):
133
151
    """
134
152
    Class implementing the main user interface.
135
153
    
136
 
    @signal appendStderr(string) emitted to write data to stderr logger
137
 
    @signal appendStdout(string) emitted to write data to stdout logger
 
154
    @signal appendStderr(QString) emitted to write data to stderr logger
 
155
    @signal appendStdout(QString) emitted to write data to stdout logger
138
156
    @signal preferencesChanged() emitted after the preferences were changed
139
157
    @signal reloadAPIs() emitted to reload the api information
140
158
    """
141
159
    maxFilePathLen = 100
 
160
    maxSbFilePathLen = 150
142
161
    maxMenuFilePathLen = 75
143
162
    
144
 
    def __init__(self, loc, splash):
 
163
    def __init__(self, locale, splash):
145
164
        """
146
165
        Constructor
147
166
        
148
 
        @param loc locale to be used by the UI (string)
 
167
        @param locale locale to be used by the UI (string)
149
168
        @param splash reference to the splashscreen (UI.SplashScreen.SplashScreen)
150
169
        """
151
170
        QMainWindow.__init__(self)
152
 
 
153
 
        self.loc = loc
 
171
        
 
172
        self.defaultStyleName = QApplication.style().objectName()
 
173
        self.__setStyle()
 
174
        
 
175
        self.maxEditorPathLen = Preferences.getUI("CaptionFilenameLength")
 
176
        self.locale = locale
154
177
        
155
178
        self.layout, self.embeddedShell, self.embeddedFileBrowser = \
156
179
            Preferences.getUILayout()
158
181
        self.passiveMode = Preferences.getDebugger("PassiveDbgEnabled")
159
182
        
160
183
        g = Preferences.getGeometry("MainGeometry")
161
 
        if g == [0,0,0,0]:
 
184
        if g.isEmpty():
162
185
            s = QSize(800, 600)
163
186
            self.resize(s)
164
187
        else:
165
 
            self.move(g[0], g[1])
166
 
            self.resize(g[2], g[3])
 
188
            self.restoreGeometry(g)
167
189
            
168
190
        self.capProject = ""
169
191
        self.capEditor = ""
170
192
        self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
171
193
        
172
 
        self.setIcon(UI.PixmapCache.getPixmap("eric.png"))
173
 
        self.setWindowCaption()
 
194
        QApplication.setWindowIcon(UI.PixmapCache.getIcon("eric.png"))
 
195
        self.__setWindowCaption()
174
196
        
175
197
        # load the view profiles
176
 
        self.profiles = Preferences.getUI("ViewProfiles").copy()
 
198
        self.profiles = Preferences.getUI("ViewProfiles")
177
199
        
178
 
        if self.layout == 0:    # splitters
179
 
            self.setCentralWidget(QWidget(self))
180
 
            self.appWindowLayout = QHBoxLayout(self.centralWidget(),0,6)
181
 
 
182
200
        self.qtdir = Preferences.getQtDir()
183
201
        self.qt4dir = Preferences.getQt4Dir()
184
202
 
185
 
        # Generate and set our icon provider for KQFileDialog
186
 
        self.iconProvider = IconProvider()
187
 
        KQFileDialog.setIconProvider(self.iconProvider)
 
203
        if Preferences.getUI("UseIconProvider"):
 
204
            # Generate and set our icon provider for KQFileDialog
 
205
            self.iconProvider = E4IconProvider()
 
206
            KQFileDialog.setIconProvider(self.iconProvider)
 
207
        else:
 
208
            self.iconProvider = None
 
209
            KQFileDialog.setIconProvider(None)
188
210
        
189
211
        # Generate the debug server object
190
 
        dbs = DebugServer()
 
212
        debugServer = DebugServer()
191
213
        
192
214
        # Generate an empty project object
193
215
        self.project = Project(self)
194
216
        
195
 
        splash.message(self.trUtf8("Generating Main User Interface..."))
 
217
        splash.showMessage(self.trUtf8("Generating Main User Interface..."))
196
218
        
197
219
        # Create the main window now so that we can connect QActions to it.
198
 
        self.createLayout(dbs)
199
 
        self.sizeLayout()
 
220
        self.__createLayout(debugServer)
200
221
        
201
222
        # Generate the debugger part of the ui
202
 
        self.dbg = DebugUI(self, self.viewmanager, dbs, self.sbv, self.project)
203
 
        self.sbv.setDebugger(self.dbg)
 
223
        self.debuggerUI = DebugUI(self, self.viewmanager, debugServer, 
 
224
                                  self.debugViewer, self.project)
 
225
        self.debugViewer.setDebugger(self.debuggerUI)
 
226
        self.shell.setDebuggerUI(self.debuggerUI)
204
227
        
205
228
        # Generate the redirection helpers
206
 
        self.stdout = Redirector(0)
207
 
        self.stderr = Redirector(1)
 
229
        self.stdout = Redirector(False)
 
230
        self.stderr = Redirector(True)
 
231
        
 
232
        # Genrae the programs dialog
 
233
        self.programsDialog = ProgramsDialog(self)
208
234
        
209
235
        # Generate the shortcuts configuration dialog
210
236
        self.shortcutsDialog = ShortcutsDialog(self, 'Shortcuts')
213
239
        self.refactoring = Refactoring(self)
214
240
            
215
241
        # now setup the connections
216
 
        splash.message(self.trUtf8("Setting up connections..."))
217
 
        self.connect(self.browser,PYSIGNAL('pythonFile'),
218
 
                     self.viewmanager.handlePythonFile)
219
 
        self.connect(self.browser,PYSIGNAL('designerFile'),
220
 
                     self.handleDesigner)
221
 
        self.connect(self.browser,PYSIGNAL('linguistFile'),
222
 
                     self.handleLinguist)
223
 
        self.connect(self.browser,PYSIGNAL('projectFile'),
 
242
        splash.showMessage(self.trUtf8("Setting up connections..."))
 
243
        self.connect(self.browser, SIGNAL('sourceFile'),
 
244
                     self.viewmanager.openSourceFile)
 
245
        self.connect(self.browser, SIGNAL('designerFile'),
 
246
                     self.__designer)
 
247
        self.connect(self.browser, SIGNAL('linguistFile'),
 
248
                     self.__linguist4)
 
249
        self.connect(self.browser, SIGNAL('projectFile'),
224
250
                     self.project.openProject)
225
 
        self.connect(self.browser,PYSIGNAL('pixmapFile'),
226
 
                     self.handlePixmap)
227
 
        self.connect(self.browser,PYSIGNAL('unittestOpen'),
228
 
                     self.handleUnittestScript)
229
 
        
230
 
        self.connect(self.sbv.exceptionLogger,PYSIGNAL('pythonFile'),
231
 
                     self.viewmanager.handlePythonFile)
232
 
        
233
 
        self.connect(self.sbv,PYSIGNAL('pythonFile'),
234
 
                     self.viewmanager.handlePythonFile)
235
 
        
236
 
        self.connect(self.taskViewer,PYSIGNAL('displayFile'),
237
 
                     self.viewmanager.handlePythonFile)
238
 
        
239
 
        self.connect(self.projectBrowser.psBrowser,PYSIGNAL('pythonFile'),
240
 
                     self.viewmanager.handlePythonFile)
241
 
        self.connect(self.projectBrowser.psBrowser,PYSIGNAL('closeSourceWindow'),
242
 
                     self.viewmanager.handleCloseWindow)
243
 
        self.connect(self.projectBrowser.psBrowser,PYSIGNAL('unittestOpen'),
244
 
                     self.handleUnittestScript)
245
 
        
246
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('designerFile'),
247
 
                     self.handleDesigner)
248
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('pythonFile'),
249
 
                     self.viewmanager.handlePythonFile)
250
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('uipreview'),
251
 
                     self.handleUIPreviewer)
252
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('trpreview'),
253
 
                     self.handleTRPreviewer)
254
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('closeSourceWindow'),
255
 
                     self.viewmanager.handleCloseWindow)
256
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('appendStdout'),
257
 
                     self.stdoutTab.append)
258
 
        self.connect(self.projectBrowser.pfBrowser,PYSIGNAL('appendStderr'),
259
 
                     self.stderrTab.append)
260
 
        
261
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('linguistFile'),
262
 
                     self.handleLinguist)
263
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('pythonFile'),
264
 
                     self.viewmanager.handlePythonFile)
265
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('trpreview'),
266
 
                     self.handleTRPreviewer)
267
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('closeSourceWindow'),
268
 
                     self.viewmanager.handleCloseWindow)
269
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('appendStdout'),
270
 
                     self.stdoutTab.append)
271
 
        self.connect(self.projectBrowser.ptBrowser,PYSIGNAL('appendStderr'),
272
 
                     self.stderrTab.append)
273
 
        
274
 
        self.connect(self.projectBrowser.piBrowser,PYSIGNAL('pythonFile'),
275
 
                     self.viewmanager.handlePythonFile)
276
 
        self.connect(self.projectBrowser.piBrowser,PYSIGNAL('closeSourceWindow'),
277
 
                     self.viewmanager.handleCloseWindow)
278
 
        self.connect(self.projectBrowser.piBrowser,PYSIGNAL('appendStdout'),
279
 
                     self.stdoutTab.append)
280
 
        self.connect(self.projectBrowser.piBrowser,PYSIGNAL('appendStderr'),
281
 
                     self.stderrTab.append)
282
 
        
283
 
        self.connect(self.projectBrowser.poBrowser,PYSIGNAL('pythonFile'),
284
 
                     self.viewmanager.handlePythonFile)
285
 
        self.connect(self.projectBrowser.poBrowser,PYSIGNAL('closeSourceWindow'),
286
 
                     self.viewmanager.handleCloseWindow)
287
 
        self.connect(self.projectBrowser.poBrowser,PYSIGNAL('pixmapFile'),
288
 
                     self.handlePixmap)
289
 
        
290
 
        self.connect(self.project,PYSIGNAL('pythonFile'),
291
 
                    self.viewmanager.handleOpen)
292
 
        self.connect(self.project,PYSIGNAL('newProject'),
293
 
                     self.viewmanager.handleNewProject)
294
 
        self.connect(self.project,PYSIGNAL('projectOpened'),
295
 
                     self.viewmanager.handleProjectOpened)
296
 
        self.connect(self.project,PYSIGNAL('projectClosed'),
297
 
                     self.viewmanager.handleProjectClosed)
298
 
        self.connect(self.project,PYSIGNAL('projectFileRenamed'),
299
 
                     self.viewmanager.handleProjectFileRenamed)
300
 
        self.connect(self.project,PYSIGNAL('newProject'),
301
 
                     self.handleNewProject)
302
 
        self.connect(self.project,PYSIGNAL('projectOpened'),
303
 
                     self.handleProjectOpened)
304
 
        self.connect(self.project,PYSIGNAL('projectClosed'),
305
 
                     self.handleProjectClosed)
306
 
        
307
 
        self.connect(self.dbg,PYSIGNAL('resetUI'),
 
251
        self.connect(self.browser, SIGNAL('pixmapFile'),
 
252
                     self.__showPixmap)
 
253
        self.connect(self.browser, SIGNAL('unittestOpen'),
 
254
                     self.__unittestScript)
 
255
        self.connect(self.browser, SIGNAL('trpreview'),
 
256
                     self.__TRPreviewer)
 
257
        
 
258
        self.connect(self.debugViewer.exceptionLogger, SIGNAL('sourceFile'),
 
259
                     self.viewmanager.openSourceFile)
 
260
        
 
261
        self.connect(self.debugViewer, SIGNAL('sourceFile'),
 
262
                     self.viewmanager.openSourceFile)
 
263
        
 
264
        self.connect(self.taskViewer, SIGNAL('displayFile'),
 
265
                     self.viewmanager.openSourceFile)
 
266
        
 
267
        self.connect(self.projectBrowser.psBrowser, SIGNAL('sourceFile'),
 
268
                     self.viewmanager.openSourceFile)
 
269
        self.connect(self.projectBrowser.psBrowser, SIGNAL('closeSourceWindow'),
 
270
                     self.viewmanager.closeWindow)
 
271
        self.connect(self.projectBrowser.psBrowser, SIGNAL('unittestOpen'),
 
272
                     self.__unittestScript)
 
273
        
 
274
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('designerFile'),
 
275
                     self.__designer)
 
276
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('sourceFile'),
 
277
                     self.viewmanager.openSourceFile)
 
278
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('uipreview'),
 
279
                     self.__UIPreviewer)
 
280
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('trpreview'),
 
281
                     self.__TRPreviewer)
 
282
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('closeSourceWindow'),
 
283
                     self.viewmanager.closeWindow)
 
284
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('appendStdout'),
 
285
                     self.logViewer.appendToStdout)
 
286
        self.connect(self.projectBrowser.pfBrowser, SIGNAL('appendStderr'),
 
287
                     self.logViewer.appendToStderr)
 
288
        
 
289
        self.connect(self.projectBrowser.prBrowser, SIGNAL('sourceFile'),
 
290
                     self.viewmanager.openSourceFile)
 
291
        self.connect(self.projectBrowser.prBrowser, SIGNAL('closeSourceWindow'),
 
292
                     self.viewmanager.closeWindow)
 
293
        self.connect(self.projectBrowser.prBrowser, SIGNAL('appendStdout'),
 
294
                     self.logViewer.appendToStdout)
 
295
        self.connect(self.projectBrowser.prBrowser, SIGNAL('appendStderr'),
 
296
                     self.logViewer.appendToStderr)
 
297
        
 
298
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('linguistFile'),
 
299
                     self.__linguist4)
 
300
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('sourceFile'),
 
301
                     self.viewmanager.openSourceFile)
 
302
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('trpreview'),
 
303
                     self.__TRPreviewer)
 
304
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('closeSourceWindow'),
 
305
                     self.viewmanager.closeWindow)
 
306
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('appendStdout'),
 
307
                     self.logViewer.appendToStdout)
 
308
        self.connect(self.projectBrowser.ptBrowser, SIGNAL('appendStderr'),
 
309
                     self.logViewer.appendToStderr)
 
310
        
 
311
        self.connect(self.projectBrowser.piBrowser, SIGNAL('sourceFile'),
 
312
                     self.viewmanager.openSourceFile)
 
313
        self.connect(self.projectBrowser.piBrowser, SIGNAL('closeSourceWindow'),
 
314
                     self.viewmanager.closeWindow)
 
315
        self.connect(self.projectBrowser.piBrowser, SIGNAL('appendStdout'),
 
316
                     self.logViewer.appendToStdout)
 
317
        self.connect(self.projectBrowser.piBrowser, SIGNAL('appendStderr'),
 
318
                     self.logViewer.appendToStderr)
 
319
        
 
320
        self.connect(self.projectBrowser.poBrowser, SIGNAL('sourceFile'),
 
321
                     self.viewmanager.openSourceFile)
 
322
        self.connect(self.projectBrowser.poBrowser, SIGNAL('closeSourceWindow'),
 
323
                     self.viewmanager.closeWindow)
 
324
        self.connect(self.projectBrowser.poBrowser, SIGNAL('pixmapFile'),
 
325
                     self.__showPixmap)
 
326
        
 
327
        self.connect(self.project, SIGNAL('sourceFile'),
 
328
                    self.viewmanager.openFiles)
 
329
        self.connect(self.project, SIGNAL('newProject'),
 
330
                     self.viewmanager.newProject)
 
331
        self.connect(self.project, SIGNAL('projectOpened'),
 
332
                     self.viewmanager.projectOpened)
 
333
        self.connect(self.project, SIGNAL('projectClosed'),
 
334
                     self.viewmanager.projectClosed)
 
335
        self.connect(self.project, SIGNAL('projectFileRenamed'),
 
336
                     self.viewmanager.projectFileRenamed)
 
337
        self.connect(self.project, SIGNAL('newProject'),
 
338
                     self.__newProject)
 
339
        self.connect(self.project, SIGNAL('projectOpened'),
 
340
                     self.__projectOpened)
 
341
        self.connect(self.project, SIGNAL('projectClosed'),
 
342
                     self.__projectClosed)
 
343
        
 
344
        self.connect(self.debuggerUI, SIGNAL('resetUI'),
308
345
                     self.viewmanager.handleResetUI)
309
 
        self.connect(self.dbg,PYSIGNAL('resetUI'),
310
 
                     self.sbv.handleResetUI)
311
 
        self.connect(self.dbg,PYSIGNAL('resetUI'),
312
 
                     self.handleSetEditProfile)
313
 
        self.connect(self.dbg,PYSIGNAL('clientStack'),
314
 
                     self.sbv.handleClientStack)
315
 
        self.connect(self.dbg,PYSIGNAL('debuggingStarted'),
 
346
        self.connect(self.debuggerUI, SIGNAL('resetUI'),
 
347
                     self.debugViewer.handleResetUI)
 
348
        self.connect(self.debuggerUI, SIGNAL('resetUI'),
 
349
                     self.__setEditProfile)
 
350
        self.connect(self.debuggerUI, SIGNAL('clientStack'),
 
351
                     self.debugViewer.handleClientStack)
 
352
        self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
316
353
                     self.browser.handleProgramChange)
317
 
        self.connect(self.dbg,PYSIGNAL('debuggingStarted'),
318
 
                     self.sbv.exceptionLogger.debuggingStarted)
319
 
        self.connect(self.dbg,PYSIGNAL('debuggingStarted'),
320
 
                     self.sbv.handleDebuggingStarted)
321
 
        self.connect(self.dbg,PYSIGNAL('debuggingStarted'),
322
 
                     self.handleProgramChange)
323
 
        self.connect(self.dbg,PYSIGNAL('debuggingStarted'),
324
 
                     self.handleSetDebugProfile)
325
 
        self.connect(self.dbg,PYSIGNAL('compileForms'),
326
 
                     self.projectBrowser.pfBrowser.handleCompileChangedForms)
327
 
        
328
 
        self.connect(dbs,PYSIGNAL('clientStack'),
329
 
                     self.sbv.handleClientStack)
330
 
        self.connect(dbs,PYSIGNAL('passiveDebugStarted'),
331
 
                     self.sbv.exceptionLogger.debuggingStarted)
332
 
        self.connect(dbs,PYSIGNAL('passiveDebugStarted'),
333
 
                     self.sbv.handleDebuggingStarted)
334
 
        self.connect(dbs,PYSIGNAL('clientException'),
335
 
                     self.sbv.exceptionLogger.addException)
336
 
        self.connect(dbs,PYSIGNAL('clientClearWatch'),
337
 
                     self.sbv.watchpointViewer.clearWatchpoint)
338
 
        self.connect(dbs,PYSIGNAL('clientWatchConditionError'),
339
 
                     self.sbv.watchpointViewer.handleClientWatchConditionError)
340
 
        self.connect(dbs,PYSIGNAL('clientClearBreak'),
341
 
                     self.sbv.breakpointViewer.clearBreakpoint)
342
 
        self.connect(dbs,PYSIGNAL('clientLine'),
343
 
                     self.sbv.breakpointViewer.highlightBreakpoint)
344
 
        
345
 
        self.connect(self.stdout,PYSIGNAL('appendStdout'),
346
 
                     self.stdoutTab.append)
347
 
        
348
 
        self.connect(self.stderr,PYSIGNAL('appendStderr'),
349
 
                     self.stderrTab.append)
350
 
        
351
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
352
 
                     self.viewmanager.handlePreferencesChanged)
353
 
        self.connect(self,PYSIGNAL('reloadAPIs'),
354
 
                     self.viewmanager.handleReloadAPIs)
355
 
        self.connect(self,PYSIGNAL('appendStdout'),
356
 
                     self.stdoutTab.append)
357
 
        self.connect(self,PYSIGNAL('appendStderr'),
358
 
                     self.stderrTab.append)
359
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
 
354
        self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
 
355
                     self.debugViewer.exceptionLogger.debuggingStarted)
 
356
        self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
 
357
                     self.debugViewer.handleDebuggingStarted)
 
358
        self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
 
359
                     self.__programChange)
 
360
        self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
 
361
                     self.setDebugProfile)
 
362
        self.connect(self.debuggerUI, SIGNAL('compileForms'),
 
363
                     self.projectBrowser.pfBrowser.compileChangedForms)
 
364
        self.connect(self.debuggerUI, SIGNAL('compileResources'),
 
365
                     self.projectBrowser.prBrowser.compileChangedResources)
 
366
        
 
367
        self.connect(debugServer, SIGNAL('clientStack'),
 
368
                     self.debugViewer.handleClientStack)
 
369
        self.connect(debugServer, SIGNAL('passiveDebugStarted'),
 
370
                     self.debugViewer.exceptionLogger.debuggingStarted)
 
371
        self.connect(debugServer, SIGNAL('passiveDebugStarted'),
 
372
                     self.debugViewer.handleDebuggingStarted)
 
373
        self.connect(debugServer, SIGNAL('clientException'),
 
374
                     self.debugViewer.exceptionLogger.addException)
 
375
        self.connect(debugServer, SIGNAL('clientLine'),
 
376
                     self.debugViewer.breakpointViewer.highlightBreakpoint)
 
377
        
 
378
        self.connect(self.stdout, SIGNAL('appendStdout'),
 
379
                     self.logViewer.appendToStdout)
 
380
        
 
381
        self.connect(self.stderr, SIGNAL('appendStderr'),
 
382
                     self.logViewer.appendToStderr)
 
383
        
 
384
        self.connect(self, SIGNAL('preferencesChanged'),
 
385
                     self.viewmanager.preferencesChanged)
 
386
        self.connect(self, SIGNAL('reloadAPIs'),
 
387
                     self.viewmanager.getAPIsManager().reloadAPIs)
 
388
        self.connect(self, SIGNAL('appendStdout'),
 
389
                     self.logViewer.appendToStdout)
 
390
        self.connect(self, SIGNAL('appendStderr'),
 
391
                     self.logViewer.appendToStderr)
 
392
        self.connect(self, SIGNAL('preferencesChanged'),
360
393
                     self.shell.handlePreferencesChanged)
361
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
 
394
        self.connect(self, SIGNAL('preferencesChanged'),
 
395
                     self.project.handlePreferencesChanged)
 
396
        self.connect(self, SIGNAL('preferencesChanged'),
362
397
                     self.projectBrowser.psBrowser.handlePreferencesChanged)
363
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
 
398
        self.connect(self, SIGNAL('preferencesChanged'),
 
399
                     self.projectBrowser.pfBrowser.handlePreferencesChanged)
 
400
        self.connect(self, SIGNAL('preferencesChanged'),
 
401
                     self.projectBrowser.prBrowser.handlePreferencesChanged)
 
402
        self.connect(self, SIGNAL('preferencesChanged'),
 
403
                     self.projectBrowser.ptBrowser.handlePreferencesChanged)
 
404
        self.connect(self, SIGNAL('preferencesChanged'),
 
405
                     self.projectBrowser.piBrowser.handlePreferencesChanged)
 
406
        self.connect(self, SIGNAL('preferencesChanged'),
 
407
                     self.projectBrowser.poBrowser.handlePreferencesChanged)
 
408
        self.connect(self, SIGNAL('preferencesChanged'),
364
409
                     self.browser.handlePreferencesChanged)
365
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
 
410
        self.connect(self, SIGNAL('preferencesChanged'),
366
411
                     self.taskViewer.handlePreferencesChanged)
367
412
        
368
 
        self.connect(self.viewmanager,PYSIGNAL('editorSaved'),
369
 
                     self.projectBrowser.psBrowser.handleEditorSaved)
370
 
        self.connect(self.viewmanager,PYSIGNAL('lastEditorClosed'),
371
 
                     self.handleLastEditorClosed)
372
 
        self.connect(self.viewmanager,PYSIGNAL('editorOpened'),
373
 
                     self.handleEditorOpened)
374
 
        self.connect(self.viewmanager,PYSIGNAL('changeCaption'),
375
 
                     self.setWindowCaption)
376
 
        self.connect(self.viewmanager,PYSIGNAL('checkActions'),
377
 
                     self.checkActions)
378
 
        self.connect(self.viewmanager,PYSIGNAL('breakpointToggled'),
379
 
                     self.sbv.breakpointViewer.refresh)
380
 
        self.connect(self.viewmanager,PYSIGNAL('breakpointEnabledToggled'),
381
 
                     self.sbv.breakpointViewer.refresh)
382
 
        self.connect(self.viewmanager,PYSIGNAL('editorClosed'),
383
 
                     self.sbv.breakpointViewer.editorClosed)
384
 
        self.connect(self.viewmanager,PYSIGNAL('editorChanged'),
 
413
        self.connect(self.viewmanager, SIGNAL('editorSaved'),
 
414
                     self.project.repopulateItem)
 
415
        self.connect(self.viewmanager, SIGNAL('lastEditorClosed'),
 
416
                     self.__lastEditorClosed)
 
417
        self.connect(self.viewmanager, SIGNAL('editorOpened'),
 
418
                     self.__editorOpened)
 
419
        self.connect(self.viewmanager, SIGNAL('changeCaption'),
 
420
                     self.__setWindowCaption)
 
421
        self.connect(self.viewmanager, SIGNAL('checkActions'),
 
422
                     self.__checkActions)
 
423
        self.connect(self.viewmanager, SIGNAL('editorChanged'),
385
424
                     self.projectBrowser.handleEditorChanged)
386
425
        
387
 
        self.connect(self,PYSIGNAL('preferencesChanged'),
 
426
        self.connect(self, SIGNAL('preferencesChanged'),
388
427
                     self.refactoring.handlePreferencesChanged)
389
 
        self.connect(self.project,PYSIGNAL('projectOpened'),
 
428
        self.connect(self.project, SIGNAL('projectOpened'),
390
429
                     self.refactoring.handleProjectOpened)
391
 
        self.connect(self.project,PYSIGNAL('projectClosed'),
 
430
        self.connect(self.project, SIGNAL('projectClosed'),
392
431
                     self.refactoring.handleProjectClosed)
393
 
        self.connect(self.project,PYSIGNAL('newProject'),
 
432
        self.connect(self.project, SIGNAL('newProject'),
394
433
                     self.refactoring.handleProjectOpened)
395
434
        
396
435
        # Generate the unittest dialog
397
 
        self.unittestDialog = UnittestDialog(None, self.dbg.dbs, self)
398
 
        self.connect(self.unittestDialog,PYSIGNAL('unittestFile'),
 
436
        self.unittestDialog = UnittestDialog(None, self.debuggerUI.debugServer, self)
 
437
        self.connect(self.unittestDialog, SIGNAL('unittestFile'),
399
438
                     self.viewmanager.setFileLine)
400
439
        
401
440
        # Generate the find in project files dialog
402
441
        self.findFilesDialog = FindFileDialog(self.project)
403
 
        self.connect(self.findFilesDialog, PYSIGNAL('pythonFile'),
404
 
                     self.viewmanager.handlePythonFile)
405
 
        self.connect(self.findFilesDialog,PYSIGNAL('designerFile'),
406
 
                     self.handleDesigner)
 
442
        self.connect(self.findFilesDialog, SIGNAL('sourceFile'),
 
443
                     self.viewmanager.openSourceFile)
 
444
        self.connect(self.findFilesDialog, SIGNAL('designerFile'),
 
445
                     self.__designer)
407
446
        
408
447
        # generate the find file dialog
409
448
        self.findFileNameDialog = FindFileNameDialog(self.project)
410
 
        self.connect(self.findFileNameDialog, PYSIGNAL('pythonFile'),
411
 
                     self.viewmanager.handlePythonFile)
412
 
        self.connect(self.findFileNameDialog,PYSIGNAL('designerFile'),
413
 
                     self.handleDesigner)
 
449
        self.connect(self.findFileNameDialog, SIGNAL('sourceFile'),
 
450
                     self.viewmanager.openSourceFile)
 
451
        self.connect(self.findFileNameDialog, SIGNAL('designerFile'),
 
452
                     self.__designer)
414
453
        
415
454
        # generate the diff dialogs
416
455
        self.diffDlg = DiffDialog()
417
456
        self.compareDlg = CompareDialog()
418
457
        
419
458
        # generate the wizards
420
 
        splash.message(self.trUtf8("Loading Wizards..."))
421
 
        self.wizards = Wizards(self.loc, self)
 
459
        splash.showMessage(self.trUtf8("Loading Wizards..."))
 
460
        self.wizards = Wizards(self.locale, self)
 
461
        
 
462
        # Initialize the tool groups and list of started tools
 
463
        splash.showMessage(self.trUtf8("Initializing Tools..."))
 
464
        self.toolGroups, self.currentToolGroup = Preferences.readToolGroups()
 
465
        self.toolProcs = []
 
466
        
 
467
        # create a dummy help window for shortcuts handling
 
468
        self.dummyHelpViewer = HelpWindow(None, '.', None, 'help viewer', True)
 
469
        
 
470
        # register all relevant objects
 
471
        splash.showMessage(self.trUtf8("Registering Objects..."))
 
472
        e4App().registerObject("UserInterface", self)
 
473
        e4App().registerObject("DebugUI", self.debuggerUI)
 
474
        e4App().registerObject("DebugServer", debugServer)
 
475
        e4App().registerObject("ViewManager", self.viewmanager)
 
476
        e4App().registerObject("Project", self.project)
 
477
        e4App().registerObject("ProjectBrowser", self.projectBrowser)
 
478
        e4App().registerObject("Wizards", self.wizards)
 
479
        e4App().registerObject("Refactoring", self.refactoring)
 
480
        e4App().registerObject("TaskViewer", self.taskViewer)
 
481
        e4App().registerObject("TemplateViewer", self.templateViewer)
 
482
        e4App().registerObject("Shell", self.shell)
 
483
        e4App().registerObject("FindFilesDialog", self.findFilesDialog)
 
484
        e4App().registerObject("DummyHelpViewer", self.dummyHelpViewer)
 
485
        
 
486
        # initialize the character tables dialog attribute
 
487
        self.chartablesDlg = None
422
488
        
423
489
        # Initialize the actions, menues, toolbar and statusbar
424
 
        splash.message(self.trUtf8("Initializing Actions..."))
425
 
        self.initActions()
426
 
        splash.message(self.trUtf8("Initializing Menus..."))
427
 
        self.initMenus()
428
 
        splash.message(self.trUtf8("Initializing Toolbars..."))
429
 
        self.initToolbars()
430
 
        splash.message(self.trUtf8("Initializing Statusbar..."))
431
 
        self.initStatusbar()
432
 
 
 
490
        splash.showMessage(self.trUtf8("Initializing Actions..."))
 
491
        self.__initActions()
 
492
        splash.showMessage(self.trUtf8("Initializing Menus..."))
 
493
        self.__initMenus()
 
494
        splash.showMessage(self.trUtf8("Initializing Toolbars..."))
 
495
        self.__initToolbars()
 
496
        splash.showMessage(self.trUtf8("Initializing Statusbar..."))
 
497
        self.__initStatusbar()
 
498
        
433
499
        # Initialise the instance variables.
434
500
        self.currentProg = None
435
 
        self.isProg = 0
436
 
        self.utEditorOpen = 0
437
 
        self.utProjectOpen = 0
 
501
        self.isProg = False
 
502
        self.utEditorOpen = False
 
503
        self.utProjectOpen = False
438
504
        
439
 
        self.inDragDrop = 0
440
 
        self.setAcceptDrops(1)
 
505
        self.inDragDrop = False
 
506
        self.setAcceptDrops(True)
441
507
        
442
508
        self.currentProfile = None
443
509
        
444
 
        self.shutdownCalled = 0
 
510
        self.shutdownCalled = False
 
511
        self.inCloseEevent = False
445
512
 
446
 
        # Initialize the toollist and list of started tools
447
 
        splash.message(self.trUtf8("Initializing Tools..."))
448
 
        self.toollist = Preferences.readToolsMenu()
449
 
        self.toolProcs = []
450
 
        
451
513
        # now redirect stdout and stderr
452
514
        sys.stdout = self.stdout
453
515
        sys.stderr = self.stderr
454
516
 
455
517
        # now fire up the single application server
456
518
        if Preferences.getUI("SingleApplicationMode"):
457
 
            splash.message(self.trUtf8("Initializing Single Application Server..."))
458
 
            self.SAServer = E3SingleApplicationServer()
 
519
            splash.showMessage(self.trUtf8("Initializing Single Application Server..."))
 
520
            self.SAServer = E4SingleApplicationServer()
459
521
        else:
460
522
            self.SAServer = None
461
523
            
462
524
        # now fire up the scripting stuff
463
 
        splash.message(self.trUtf8("Initializing Scripting..."))
 
525
        splash.showMessage(self.trUtf8("Initializing Scripting..."))
464
526
        self.scriptManager = Scripting.init(self)
465
 
        self.connect(self.scriptManager, PYSIGNAL("firstScriptAdded"),
466
 
            self.handleFirstScriptAdded)
467
 
        self.connect(self.scriptManager, PYSIGNAL("lastScriptDeleted"),
468
 
            self.handleLastScriptDeleted)
 
527
        self.connect(self.scriptManager, SIGNAL("firstScriptAdded"),
 
528
            self.__firstScriptAdded)
 
529
        self.connect(self.scriptManager, SIGNAL("lastScriptDeleted"),
 
530
            self.__lastScriptDeleted)
469
531
        Scripting.runStartupScripts(self)
470
532
        
471
533
        # now activate the initial view profile
472
 
        self.handleSetEditProfile()
 
534
        self.__setEditProfile()
473
535
        
474
536
        # now read the saved tasks
475
 
        self.readTasks()
 
537
        self.__readTasks()
476
538
        
477
539
        # now read the saved templates
478
 
        self.readTemplates()
 
540
        self.templateViewer.readTemplates()
479
541
        
480
542
        # now start the debug client
481
 
        dbs.startRemote()
482
 
        
483
 
    def createLayout(self, dbs):
 
543
        debugServer.startClient(False)
 
544
        
 
545
        # attribute for the http client object
 
546
        self.http = None
 
547
        
 
548
        # attribute for the help window
 
549
        self.helpWindow = None
 
550
        
 
551
        # list of web addresses serving the versions file
 
552
        self.__httpAlternatives = [
 
553
            {"host" : "die-offenbachs.homelinux.org", 
 
554
             "port" : 80, 
 
555
             "url"  : "/eric/snapshots4/versions", 
 
556
            }, 
 
557
            
 
558
            {"host" : "www.die-offenbachs.de", 
 
559
             "port" : 80, 
 
560
             "url"  : "/eric/snapshots4/versions", 
 
561
            }, 
 
562
        ]
 
563
        self.__inVersionCheck = False
 
564
        self.__versionCheckProgress = None
 
565
        
 
566
    def __setStyle(self):
 
567
        """
 
568
        Private slot to set the style of the interface.
 
569
        """
 
570
        # step 1: set the style
 
571
        style = None
 
572
        styleName = Preferences.getUI("Style")
 
573
        if styleName != "System" and styleName in QStyleFactory.keys():
 
574
            style = QStyleFactory.create(styleName)
 
575
        if style is None:
 
576
            style = QStyleFactory.create(self.defaultStyleName)
 
577
        if style is not None:
 
578
            QApplication.setStyle(style)
 
579
        
 
580
        # step 2: set a style sheet
 
581
        styleSheetFile = unicode(Preferences.getUI("StyleSheet"))
 
582
        if styleSheetFile:
 
583
            try:
 
584
                f = open(styleSheetFile, "rb")
 
585
                styleSheet = f.read()
 
586
                f.close()
 
587
            except IOError, msg:
 
588
                KQMessageBox.warning(None,
 
589
                    self.trUtf8("Loading Style Sheet"),
 
590
                    self.trUtf8("""<p>The Qt Style Sheet file <b>%1</b> could"""
 
591
                                """ not be read.<br>Reason: %2</p>"""),
 
592
                    QMessageBox.StandardButtons(\
 
593
                        QMessageBox.Ok))
 
594
                return
 
595
        else:
 
596
            styleSheet = ""
 
597
            
 
598
        e4App().setStyleSheet(styleSheet)
 
599
        
 
600
    def __createLayout(self, debugServer):
484
601
        """
485
602
        Private method to create the layout of the various windows.
486
603
        
487
 
        @param dbs reference to the debug server object
 
604
        @param debugServer reference to the debug server object
488
605
        """
489
 
        # Create the main layout type 0 (splitters)
490
 
        if self.layout == 0:
491
 
            if self.embeddedShell:
492
 
                # A layout like the appearence of Qt Designer.
493
 
                self.hSplitter = QSplitter(self.centralWidget(),"hSplitter")
494
 
                self.hSplitter.setOrientation(QSplitter.Horizontal)
495
 
                
496
 
                # Create the project browser
497
 
                self.projectBrowser = ProjectBrowser(self.project, 
498
 
                    self.qtdir, self.qt4dir, self.hSplitter,
499
 
                    embeddedBrowser=(self.embeddedFileBrowser != 1))
500
 
                self.projectBrowser.show()
501
 
                
502
 
                # Create the view manager depending on the configuration setting
503
 
                self.viewmanager = ViewManager.factory(self.hSplitter, self, dbs)
504
 
                
505
 
                # Create a splitter for the right hand side
506
 
                self.vSplitter = QSplitter(self.hSplitter,"vSplitter")
507
 
                self.vSplitter.setOrientation(QSplitter.Vertical)
508
 
                
509
 
                # Create the shell, browser, variables part of the user interface
510
 
                self.sbv = SBVviewer(dbs, 0, self.viewmanager, self.vSplitter,
511
 
                    embeddedBrowser=(self.embeddedFileBrowser == 1))
512
 
                self.shell = self.sbv.shell
513
 
                
514
 
                # Create the log viewer part of the user interface
515
 
                self.logViewer = LogView(self.vSplitter)
516
 
                self.logViewer.setMinimumSize(100,100)
517
 
                
518
 
                # Create the task viewer part of the user interface
519
 
                self.taskViewer = TaskViewer(self.vSplitter, self.project)
520
 
                self.taskViewer.setMinimumSize(100,150)
521
 
                
522
 
                # Create the template viewer part of the user interface
523
 
                self.templateViewer = TemplateViewer(self.vSplitter, self.viewmanager)
524
 
                self.templateViewer.setMinimumSize(100,150)
525
 
                
526
 
                # Add the splitter to the main windows layout
527
 
                self.appWindowLayout.addWidget(self.hSplitter)
528
 
                
529
 
                self.windows = [self.projectBrowser, None, self.sbv, 
530
 
                    None, self.logViewer, self.taskViewer, self.templateViewer]
531
 
            else:
532
 
                # A layout like the appearance of KDevelop
533
 
                self.vSplitter = QSplitter(self.centralWidget(),"vSplitter")
534
 
                self.vSplitter.setOrientation(QSplitter.Vertical)
535
 
                
536
 
                # Create the top part
537
 
                self.hSplitter1 = QSplitter(self.vSplitter,"hSplitter1")
538
 
                self.hSplitter1.setOrientation(QSplitter.Horizontal)
539
 
            
540
 
                # Create the project browser
541
 
                self.projectBrowser = ProjectBrowser(self.project, 
542
 
                    self.qtdir, self.qt4dir, self.hSplitter1,
543
 
                    embeddedBrowser=(self.embeddedFileBrowser != 1))
544
 
                self.projectBrowser.show()
545
 
                
546
 
                # Create the view manager depending on the configuration setting
547
 
                self.viewmanager = ViewManager.factory(self.hSplitter1, self, dbs)
548
 
                
549
 
                # Create the shell, browser, variables part of the user interface
550
 
                # but without the shell. The shell gets a separate part of the UI
551
 
                self.sbv = SBVviewer(dbs, 0, self.viewmanager, self.hSplitter1,
552
 
                    embeddedShell=0,
553
 
                    embeddedBrowser=(self.embeddedFileBrowser == 1))
554
 
                
555
 
                # Create the bottom part
556
 
                self.hSplitter2 = QSplitter(self.vSplitter,"hSplitter2")
557
 
                self.hSplitter2.setOrientation(QSplitter.Horizontal)
558
 
                
559
 
                # Create the shell
560
 
                self.shell = Shell(dbs, self.viewmanager, self.hSplitter2)
561
 
            
562
 
                # Create the log viewer part of the user interface
563
 
                self.logViewer = LogView(self.hSplitter2)
564
 
                self.logViewer.setMinimumSize(100,100)
565
 
                
566
 
                # Create the task viewer part of the user interface
567
 
                self.taskViewer = TaskViewer(self.hSplitter2, self.project)
568
 
                self.taskViewer.setMinimumSize(100,150)
569
 
                
570
 
                # Create the template viewer part of the user interface
571
 
                self.templateViewer = TemplateViewer(self.hSplitter2, self.viewmanager)
572
 
                self.templateViewer.setMinimumSize(100,150)
573
 
                
574
 
                # Add the splitter to the main windows layout
575
 
                self.appWindowLayout.addWidget(self.vSplitter)
576
 
            
577
 
                self.windows = [self.projectBrowser, None, self.sbv, 
578
 
                    self.shell, self.logViewer, self.taskViewer, self.templateViewer]
579
 
                
580
 
            if self.embeddedFileBrowser == 1:   # embedded in debug browser
581
 
                self.browser = self.sbv.browser
582
 
            else:                               # embedded in project browser
583
 
                self.browser = self.projectBrowser.fileBrowser
584
 
                
585
 
        # Create the main layout type 1 (movable dock windows)
586
 
        elif self.layout == 1:
 
606
        # Create layout with movable dock windows
 
607
        if self.layout == "DockWindows":
587
608
            # Create the view manager depending on the configuration setting
588
 
            self.viewmanager = ViewManager.factory(self, self, dbs)
 
609
            self.viewmanager = ViewManager.factory(self, self, debugServer)
589
610
            self.setCentralWidget(self.viewmanager)
590
611
 
591
612
            # Create the project browser
592
 
            self.projectBrowserDock = self.createDockWindow()
 
613
            self.projectBrowserDock = self.__createDockWindow("ProjectBrowserDock")
593
614
            self.projectBrowser = ProjectBrowser(self.project, 
594
615
                self.qtdir, self.qt4dir, self.projectBrowserDock,
595
616
                embeddedBrowser=(self.embeddedFileBrowser == 2))
596
 
            self.setupDockWindow(self.projectBrowserDock, Qt.DockLeft,
597
 
                                 self.projectBrowser, self.trUtf8("Project-Browser"))
 
617
            self.__setupDockWindow(self.projectBrowserDock, Qt.LeftDockWidgetArea,
 
618
                                 self.projectBrowser, self.trUtf8("Project-Viewer"))
598
619
 
599
 
            # Create the shell, browser, variables part of the user interface,
600
 
            # maybe without the embedded shell
601
 
            self.sbvDock = self.createDockWindow()
602
 
            self.sbv = SBVviewer(dbs, 1, self.viewmanager, self.sbvDock,
 
620
            # Create the debug viewer maybe without the embedded shell
 
621
            self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
 
622
            self.debugViewer = DebugViewer(debugServer, True, self.viewmanager, 
 
623
                self.debugViewerDock,
603
624
                embeddedShell=self.embeddedShell, 
604
625
                embeddedBrowser=(self.embeddedFileBrowser == 1))
605
 
            self.setupDockWindow(self.sbvDock, Qt.DockRight,
606
 
                                 self.sbv, self.trUtf8("Debug-Browser"))
 
626
            self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
 
627
                                 self.debugViewer, self.trUtf8("Debug-Viewer"))
607
628
 
608
629
            # Create the log viewer part of the user interface
609
 
            self.logViewerDock = self.createDockWindow()
610
 
            self.logViewer = LogView(self.logViewerDock)
611
 
            self.setupDockWindow(self.logViewerDock, Qt.DockBottom,
 
630
            self.logViewerDock = self.__createDockWindow("LogViewerDock")
 
631
            self.logViewer = LogViewer(self.logViewerDock)
 
632
            self.__setupDockWindow(self.logViewerDock, Qt.BottomDockWidgetArea,
612
633
                                 self.logViewer, self.trUtf8("Log-Viewer"))
613
634
 
614
635
            # Create the task viewer part of the user interface
615
 
            self.taskViewerDock = self.createDockWindow()
 
636
            self.taskViewerDock = self.__createDockWindow("TaskViewerDock")
616
637
            self.taskViewer = TaskViewer(self.taskViewerDock, self.project)
617
 
            self.setupDockWindow(self.taskViewerDock, Qt.DockBottom,
 
638
            self.__setupDockWindow(self.taskViewerDock, Qt.BottomDockWidgetArea,
618
639
                                 self.taskViewer, self.trUtf8("Task-Viewer"))
619
640
            
620
641
            # Create the template viewer part of the user interface
621
 
            self.templateViewerDock = self.createDockWindow()
622
 
            self.templateViewer = TemplateViewer(self.templateViewerDock, self.viewmanager)
623
 
            self.setupDockWindow(self.templateViewerDock, Qt.DockRight,
 
642
            self.templateViewerDock = self.__createDockWindow("TemplateViewerDock")
 
643
            self.templateViewer = TemplateViewer(self.templateViewerDock, 
 
644
                                                 self.viewmanager)
 
645
            self.__setupDockWindow(self.templateViewerDock, Qt.RightDockWidgetArea,
624
646
                                 self.templateViewer, self.trUtf8("Template-Viewer"))
625
647
            
626
648
            self.dockwindows = {}
627
 
            self.dockwindows[0] = (self.trUtf8('Project-Browser'), self.projectBrowserDock)
628
 
            self.dockwindows[1] = (self.trUtf8('Debug-Browser'), self.sbvDock)
629
 
            self.dockwindows[2] = (self.trUtf8('Log-Viewer'), self.logViewerDock)
630
 
            self.dockwindows[3] = (self.trUtf8('Task-Viewer'), self.taskViewerDock)
631
 
            self.dockwindows[4] = (self.trUtf8('Template-Viewer'), self.templateViewerDock)
 
649
            self.dockwindows[0] = \
 
650
                (self.trUtf8('Project-Viewer'), self.projectBrowserDock)
 
651
            self.dockwindows[1] = \
 
652
                (self.trUtf8('Debug-Viewer'), self.debugViewerDock)
 
653
            self.dockwindows[2] = \
 
654
                (self.trUtf8('Log-Viewer'), self.logViewerDock)
 
655
            self.dockwindows[3] = \
 
656
                (self.trUtf8('Task-Viewer'), self.taskViewerDock)
 
657
            self.dockwindows[4] = \
 
658
                (self.trUtf8('Template-Viewer'), self.templateViewerDock)
632
659
            nextDockIndex = 5
633
 
    
634
 
            self.windows = [self.projectBrowserDock, None, self.sbvDock, 
 
660
            
 
661
            self.windows = [self.projectBrowserDock, None, self.debugViewerDock, 
635
662
                None, self.logViewerDock, self.taskViewerDock, self.templateViewerDock]
636
 
                
 
663
            
637
664
            if self.embeddedShell:
638
 
                self.shell = self.sbv.shell
 
665
                self.shell = self.debugViewer.shell
639
666
            else:
640
667
                # Create the shell
641
 
                self.shellDock = self.createDockWindow()
642
 
                self.shell = Shell(dbs, self.viewmanager, self.shellDock)
643
 
                self.setupDockWindow(self.shellDock, Qt.DockBottom,
 
668
                self.shellDock = self.__createDockWindow("ShellDock")
 
669
                self.shell = Shell(debugServer, self.viewmanager, self.shellDock)
 
670
                self.__setupDockWindow(self.shellDock, Qt.BottomDockWidgetArea,
644
671
                                     self.shell, self.trUtf8("Shell"))
645
672
                self.dockwindows[nextDockIndex] = \
646
673
                    (self.trUtf8('Shell'), self.shellDock)
647
674
                nextDockIndex += 1
648
675
                self.windows[3] = self.shellDock
649
 
                
 
676
            
650
677
            if self.embeddedFileBrowser == 0:   # separate window
651
678
                # Create the file browser
652
 
                self.browserDock = self.createDockWindow()
 
679
                self.browserDock = self.__createDockWindow("BrowserDock")
653
680
                self.browser = Browser(self.browserDock)
654
 
                self.setupDockWindow(self.browserDock, Qt.DockRight,
 
681
                self.__setupDockWindow(self.browserDock, Qt.RightDockWidgetArea,
655
682
                                     self.browser, self.trUtf8("File-Browser"))
656
683
                self.dockwindows[nextDockIndex] = \
657
684
                    (self.trUtf8('File-Browser'), self.browserDock)
658
685
                nextDockIndex += 1
659
686
                self.windows[1] = self.browserDock
660
687
            elif self.embeddedFileBrowser == 1: # embedded in debug browser
661
 
                self.browser = self.sbv.browser
 
688
                self.browser = self.debugViewer.browser
662
689
            else:                               # embedded in project browser
663
690
                self.browser = self.projectBrowser.fileBrowser
664
691
 
665
 
        # Create main layout type 2 (floating windows)
666
 
        elif self.layout == 2:
 
692
        # Create layout with floating windows
 
693
        elif self.layout == "FloatingWindows":
667
694
            # Create the view manager depending on the configuration setting
668
 
            self.viewmanager = ViewManager.factory(self, self, dbs)
 
695
            self.viewmanager = ViewManager.factory(self, self, debugServer)
669
696
            self.setCentralWidget(self.viewmanager)
670
697
 
671
698
            # Create the project browser
672
699
            self.projectBrowser = ProjectBrowser(self.project, 
673
700
                self.qtdir, self.qt4dir, None,
674
701
                embeddedBrowser=(self.embeddedFileBrowser == 2))
675
 
            self.projectBrowser.setCaption(self.trUtf8("Project-Browser"))
 
702
            self.projectBrowser.setWindowTitle(self.trUtf8("Project-Viewer"))
676
703
 
677
 
            # Create the shell, browser, variables part of the user interface,
678
 
            # maybe without the embedded shell
679
 
            self.sbv = SBVviewer(dbs, 0, self.viewmanager, None,
 
704
            # Create the debug viewer maybe without the embedded shell
 
705
            self.debugViewer = DebugViewer(debugServer, False, self.viewmanager, None,
680
706
                embeddedShell=self.embeddedShell, 
681
707
                embeddedBrowser=(self.embeddedFileBrowser == 1))
682
 
            self.sbv.setCaption(self.trUtf8("Debug-Browser"))
 
708
            self.debugViewer.setWindowTitle(self.trUtf8("Debug-Viewer"))
683
709
 
684
710
            # Create the log viewer part of the user interface
685
 
            self.logViewer = LogView(None)
686
 
            self.logViewer.setCaption(self.trUtf8("Log-Viewer"))
 
711
            self.logViewer = LogViewer(None)
 
712
            self.logViewer.setWindowTitle(self.trUtf8("Log-Viewer"))
687
713
    
688
714
            # Create the task viewer part of the user interface
689
715
            self.taskViewer = TaskViewer(None, self.project)
690
 
            self.taskViewer.setCaption(self.trUtf8("Task-Viewer"))
 
716
            self.taskViewer.setWindowTitle(self.trUtf8("Task-Viewer"))
691
717
            
692
718
            # Create the template viewer part of the user interface
693
719
            self.templateViewer = TemplateViewer(None, self.viewmanager)
694
 
            self.templateViewer.setCaption(self.trUtf8("Template-Viewer"))
 
720
            self.templateViewer.setWindowTitle(self.trUtf8("Template-Viewer"))
695
721
            
696
 
            self.windows = [self.projectBrowser, None, self.sbv, 
 
722
            self.windows = [self.projectBrowser, None, self.debugViewer, 
697
723
                None, self.logViewer, self.taskViewer, self.templateViewer]
698
 
                
 
724
            
699
725
            if self.embeddedShell:
700
 
                self.shell = self.sbv.shell
 
726
                self.shell = self.debugViewer.shell
701
727
            else:
702
728
                # Create the shell
703
 
                self.shell = Shell(dbs, self.viewmanager, None)
 
729
                self.shell = Shell(debugServer, self.viewmanager, None)
704
730
                self.windows[3] = self.shell
705
 
 
 
731
            
706
732
            if self.embeddedFileBrowser == 0:   # separate window
707
733
                # Create the file browser
708
734
                self.browser = Browser(None)
709
 
                self.browser.setCaption(self.trUtf8("File-Browser"))
 
735
                self.browser.setWindowTitle(self.trUtf8("File-Browser"))
710
736
                self.windows[1] = self.browser
711
737
            elif self.embeddedFileBrowser == 1: # embedded in debug browser
712
 
                self.browser = self.sbv.browser
 
738
                self.browser = self.debugViewer.browser
713
739
            else:                               # embedded in project browser
714
740
                self.browser = self.projectBrowser.fileBrowser
715
 
            
716
 
        # Create and add the log viewer tabs
717
 
        self.logTabs = {}
718
 
        (self.logTabs["stdout"], self.stdoutTab) = self.logViewer.addTab(self.trUtf8("stdout"))
719
 
 
720
 
        (self.logTabs["stderr"], self.stderrTab) = self.logViewer.addTab(self.trUtf8("stderr"))
721
 
        
722
 
    def sizeLayout(self):
723
 
        """
724
 
        Private method to setup the layout of the various windows.
725
 
        """
726
 
        # Set the sizes of the splitters
727
 
        width = self.width()
728
 
        height = self.height()
729
 
        if self.layout == 0:            # splitters
730
 
            if self.embeddedShell:
731
 
                g = Preferences.getGeometry("MainSplitter0")
732
 
                if g == [0,0,0,0,0]:
733
 
                    hSizes = [int(0.21*width), int(0.49*width), int(0.3*width)]
734
 
                    vSizes = [int(0.8*height), int(0.2*height)]
735
 
                else:
736
 
                    hSizes = g[:3]
737
 
                    vSizes = g[3:]
738
 
                self.hSplitter.setSizes(hSizes)
739
 
                self.vSplitter.setSizes(vSizes)
740
 
            else:
741
 
                g = Preferences.getGeometry("MainSplitter1")
742
 
                if g == [0,0,0,0,0,0,0]:
743
 
                    vSizes = [int(0.9*height), int(0.1*height)]
744
 
                    hSizes1 = [int(0.23*width), int(0.52*width), int(0.25*width)]
745
 
                    hSizes2 = [int(0.5*width), int(0.5*width)]
746
 
                else:
747
 
                    vSizes = g[:2]
748
 
                    hSizes1 = g[2:5]
749
 
                    hSizes2 = g[5:]
750
 
                self.vSplitter.setSizes(vSizes)
751
 
                self.hSplitter1.setSizes(hSizes1)
752
 
                self.hSplitter2.setSizes(hSizes2)
753
 
        elif self.layout == 1:      # dockable windows
754
 
            if self.embeddedShell and self.embeddedFileBrowser:
755
 
                # shell and browser are embedded
756
 
                if not Preferences.getMainDockLayout(self, 0):
757
 
                    self.projectBrowserDock.setFixedExtentWidth(int(0.2*width))
758
 
                    self.sbvDock.setFixedExtentWidth(int(0.3*width))
759
 
                    self.logViewerDock.setFixedExtentHeight(int(0.1*height))
760
 
            elif not self.embeddedFileBrowser and not self.embeddedShell:
761
 
                # shell and browser are separate
762
 
                if not Preferences.getMainDockLayout(self, 3):
763
 
                    self.projectBrowserDock.setFixedExtentWidth(int(0.23*width))
764
 
                    self.sbvDock.setFixedExtentWidth(int(0.3*width))
765
 
                    self.shellDock.setFixedExtentHeight(int(0.15*height))
766
 
                    self.logViewerDock.setFixedExtentHeight(int(0.15*height))
767
 
                    self.logViewerDock.setFixedExtentWidth(int(0.4*width))
768
 
                    self.browserDock.setFixedExtentWidth(int(0.3*width))
769
 
            elif not self.embeddedShell:
770
 
                # only shell is separate
771
 
                if not Preferences.getMainDockLayout(self, 1):
772
 
                    self.projectBrowserDock.setFixedExtentWidth(int(0.23*width))
773
 
                    self.sbvDock.setFixedExtentWidth(int(0.3*width))
774
 
                    self.shellDock.setFixedExtentHeight(int(0.15*height))
775
 
                    self.logViewerDock.setFixedExtentHeight(int(0.15*height))
776
 
                    self.logViewerDock.setFixedExtentWidth(int(0.4*width))
777
 
            else:
778
 
                # only browser is separate
779
 
                if not Preferences.getMainDockLayout(self, 2):
780
 
                    self.projectBrowserDock.setFixedExtentWidth(int(0.2*width))
781
 
                    self.sbvDock.setFixedExtentWidth(int(0.3*width))
782
 
                    self.logViewerDock.setFixedExtentHeight(int(0.1*height))
783
 
                    self.browserDock.setFixedExtentWidth(int(0.3*width))
784
 
        elif self.layout == 2:      # floating windows
785
 
            # Project Browser
786
 
            g = Preferences.getGeometry("ProjectBrowser")
787
 
            self.projectBrowser.resize(g[2], g[3])
788
 
            self.projectBrowser.move(g[0], g[1])
789
 
            self.projectBrowser.setShown(g[4])
790
 
            
791
 
            # SBV Viewer
792
 
            g = Preferences.getGeometry("SBV")
793
 
            self.sbv.resize(g[2], g[3])
794
 
            self.sbv.move(g[0], g[1])
795
 
            self.sbv.setShown(g[4])
796
 
            
797
 
            # Log Viewer
798
 
            g = Preferences.getGeometry("LogViewer")
799
 
            self.logViewer.resize(g[2], g[3])
800
 
            self.logViewer.move(g[0], g[1])
801
 
            self.logViewer.setShown(g[4])
802
 
           
803
 
            # Shell (only for separate shell)
804
 
            if not self.embeddedShell:
805
 
                g = Preferences.getGeometry("Shell")
806
 
                self.shell.resize(g[2], g[3])
807
 
                self.shell.move(g[0], g[1])
808
 
                self.shell.setShown(g[4])
809
 
           
810
 
            # Browser (only for separate browser)
811
 
            if not self.embeddedFileBrowser:
812
 
                g = Preferences.getGeometry("FileBrowser")
813
 
                self.browser.resize(g[2], g[3])
814
 
                self.browser.move(g[0], g[1])
815
 
                self.browser.setShown(g[4])
816
 
            
817
 
            # Task Viewer
818
 
            g = Preferences.getGeometry("TaskViewer")
819
 
            self.taskViewer.resize(g[2], g[3])
820
 
            self.taskViewer.move(g[0], g[1])
821
 
            self.taskViewer.setShown(g[4])
822
 
            
823
 
            # Template Viewer
824
 
            g = Preferences.getGeometry("TemplateViewer")
825
 
            self.templateViewer.resize(g[2], g[3])
826
 
            self.templateViewer.move(g[0], g[1])
827
 
            self.templateViewer.setShown(g[4])
 
741
        else:
 
742
            raise RuntimeError("wrong layout type given (%s)" % self.layout)
828
743
        
829
744
    def showLogTab(self, tabname):
830
745
        """
832
747
        
833
748
        @param tabname string naming the tab to be shown (string)
834
749
        """
835
 
        if tabname in self.logTabs.keys():
836
 
            self.logViewer.setCurrentPage(self.logTabs[tabname])
 
750
        self.logViewer.showLogTab(tabname)
837
751
        
838
752
    def processArgs(self, args):
839
753
        """
844
758
                '--' option are considered debug arguments to the program 
845
759
                for the debugger. All files named before the '--' option
846
760
                are opened in a text editor, unless the argument ends in 
847
 
                .e3p or .e3pz, then it is opened as a project file.
 
761
                .e3p, .e3pz, .e4p or .e4pz, then it is opened as a project file.
848
762
        """
849
763
        # no args, return
850
764
        if args is None:
853
767
        # holds space delimited list of command args, if any
854
768
        argsStr = None
855
769
        # flag indicating '--' options was found
856
 
        ddseen = 0
 
770
        ddseen = False
857
771
        
858
772
        if sys.platform == 'win32':
859
773
            argChars = ['-', '/']
862
776
 
863
777
        for arg in args:
864
778
            if arg == '--' and not ddseen:
865
 
                ddseen = 1
 
779
                ddseen = True
866
780
                continue
867
781
                
868
782
            if arg[0] in argChars or ddseen:
875
789
            ext = os.path.splitext(arg)[1]
876
790
            ext = os.path.normcase(ext)
877
791
 
878
 
            if ext in ['.e3p', '.e3pz']:
 
792
            if ext in ['.e4p', '.e4pz', '.e3p', '.e3pz']:
879
793
                self.project.openProject(arg)
880
794
            else:
881
 
                self.viewmanager.handleOpen(arg)
 
795
                self.viewmanager.openFiles(arg)
882
796
 
883
797
        # store away any args we had
884
798
        if argsStr is not None:
885
 
            self.dbg.setArgvHistory(argsStr)
 
799
            self.debuggerUI.setArgvHistory(argsStr)
886
800
        
887
 
    def createDockWindow(self):
 
801
    def __createDockWindow(self, name):
888
802
        """
889
803
        Private method to create a dock window with common properties.
890
804
        
 
805
        @param name object name of the new dock window (string or QString)
891
806
        @return the generated dock window (QDockWindow)
892
807
        """
893
 
        dock = QDockWindow()
894
 
        dock.setResizeEnabled(1)
895
 
        dock.setCloseMode(QDockWindow.Always)
 
808
        dock = QDockWidget()
 
809
        dock.setObjectName(name)
 
810
        dock.setFeatures(\
 
811
            QDockWidget.DockWidgetFeatures(QDockWidget.AllDockWidgetFeatures))
896
812
        return dock
897
813
 
898
 
    def setupDockWindow(self, dock, where, widget, caption):
 
814
    def __setupDockWindow(self, dock, where, widget, caption):
899
815
        """
900
 
        Private method to configure the dock window created with createDockWindow().
 
816
        Private method to configure the dock window created with __createDockWindow().
901
817
        
902
818
        @param dock the dock window (QDockWindow)
903
 
        @param where dock area to be docked to (QDockArea)
 
819
        @param where dock area to be docked to (Qt.DockWidgetArea)
904
820
        @param widget widget to be shown in the dock window (QWidget)
905
821
        @param caption caption of the dock window (string or QString)
906
822
        """
907
823
        if caption is None:
908
 
            caption = QString.null
909
 
        self.addDockWindow(dock, where)
 
824
            caption = QString()
 
825
        self.addDockWidget(where, dock)
910
826
        dock.setWidget(widget)
911
 
        dock.setCaption(caption)
 
827
        dock.setWindowTitle(caption)
912
828
        dock.show()
913
 
        self.setAppropriate(dock, 1)
914
829
 
915
 
    def setWindowCaption(self, editor=None, project=None):
 
830
    def __setWindowCaption(self, editor = None, project = None):
916
831
        """
917
832
        Private method to set the caption of the Main Window.
918
833
        
927
842
        
928
843
        if self.passiveMode:
929
844
            if not self.capProject and not self.capEditor:
930
 
                self.setCaption(self.trUtf8("%1 - Passive Mode").arg(Program))
 
845
                self.setWindowTitle(self.trUtf8("%1 - Passive Mode").arg(Program))
931
846
            elif self.capProject and not self.capEditor:
932
 
                self.setCaption(self.trUtf8("%1 - %2 - Passive Mode")\
 
847
                self.setWindowTitle(self.trUtf8("%1 - %2 - Passive Mode")\
933
848
                    .arg(self.capProject)\
934
849
                    .arg(Program))
935
850
            elif not self.capProject and self.capEditor:
936
 
                self.setCaption(self.trUtf8("%1 - %2 - Passive Mode")\
 
851
                self.setWindowTitle(self.trUtf8("%1 - %2 - Passive Mode")\
937
852
                    .arg(self.capEditor)\
938
853
                    .arg(Program))
939
854
            else:
940
 
                self.setCaption(self.trUtf8("%1 - %2 - %3 - Passive Mode")\
 
855
                self.setWindowTitle(self.trUtf8("%1 - %2 - %3 - Passive Mode")\
941
856
                    .arg(self.capProject)\
942
857
                    .arg(self.capEditor)\
943
858
                    .arg(Program))
944
859
        else:
945
860
            if not self.capProject and not self.capEditor:
946
 
                self.setCaption(Program)
 
861
                self.setWindowTitle(Program)
947
862
            elif self.capProject and not self.capEditor:
948
 
                self.setCaption("%s - %s" % (self.capProject, Program))
 
863
                self.setWindowTitle("%s - %s" % (self.capProject, Program))
949
864
            elif not self.capProject and self.capEditor:
950
 
                self.setCaption("%s - %s" % (self.capEditor, Program))
 
865
                self.setWindowTitle("%s - %s" % (self.capEditor, Program))
951
866
            else:
952
 
                self.setCaption("%s - %s - %s" % \
 
867
                self.setWindowTitle("%s - %s - %s" % \
953
868
                    (self.capProject, self.capEditor, Program))
954
869
        
955
 
    def initActions(self):
 
870
    def __initActions(self):
956
871
        """
957
872
        Private method to define the user interface actions.
958
873
        """
959
874
        self.actions = []
960
875
        
961
 
        self.exitAct = E3Action(self.trUtf8('Quit'),
962
 
                QIconSet(UI.PixmapCache.getPixmap("exit.png")),
 
876
        self.exitAct = E4Action(self.trUtf8('Quit'),
 
877
                UI.PixmapCache.getIcon("exit.png"),
963
878
                self.trUtf8('&Quit'),
964
 
                QKeySequence(self.trUtf8("CTRL+Q","File|Quit")),
965
 
                0,self,'quit')
 
879
                QKeySequence(self.trUtf8("Ctrl+Q","File|Quit")),
 
880
                0, self, 'quit')
966
881
        self.exitAct.setStatusTip(self.trUtf8('Quit the IDE'))
967
882
        self.exitAct.setWhatsThis(self.trUtf8(
968
883
            """<b>Quit the IDE</b>"""
970
885
            """ Any Python program being debugged will be stopped and the"""
971
886
            """ preferences will be written to disc.</p>"""
972
887
        ))
973
 
        self.exitAct.connectIt(SIGNAL('activated()'), self.handleQuit)
 
888
        self.exitAct.connectIt(SIGNAL('triggered()'), self.__quit)
974
889
        self.actions.append(self.exitAct)
975
890
 
976
 
        self.viewProfileActGrp = E3ActionGroup(self, "viewprofiles", 1)
 
891
        self.viewProfileActGrp = E4ActionGroup(self, "viewprofiles", True)
977
892
        
978
 
        self.setEditProfileAct = E3Action(self.trUtf8('Edit Profile'),
979
 
                QIconSet(UI.PixmapCache.getPixmap("viewProfileEdit.png")),
 
893
        self.setEditProfileAct = E4Action(self.trUtf8('Edit Profile'),
 
894
                UI.PixmapCache.getIcon("viewProfileEdit.png"),
980
895
                self.trUtf8('Edit Profile'),
981
896
                0, 0,
982
 
                self.viewProfileActGrp, 'edit_profile', 1)
 
897
                self.viewProfileActGrp, 'edit_profile', True)
983
898
        self.setEditProfileAct.setStatusTip(self.trUtf8('Activate the edit view profile'))
984
899
        self.setEditProfileAct.setWhatsThis(self.trUtf8(
985
900
            """<b>Edit Profile</b>"""
987
902
            """ if this profile is active, may be configured with the"""
988
903
            """ "View Profile Configuration" dialog.</p>"""
989
904
        ))
990
 
        self.setEditProfileAct.connectIt(SIGNAL('activated()'),self.handleSetEditProfile)
 
905
        self.setEditProfileAct.connectIt(SIGNAL('triggered()'), self.__setEditProfile)
991
906
        self.actions.append(self.setEditProfileAct)
992
907
        
993
 
        self.setDebugProfileAct = E3Action(self.trUtf8('Debug Profile'),
994
 
                QIconSet(UI.PixmapCache.getPixmap("viewProfileDebug.png")),
 
908
        self.setDebugProfileAct = E4Action(self.trUtf8('Debug Profile'),
 
909
                UI.PixmapCache.getIcon("viewProfileDebug.png"),
995
910
                self.trUtf8('Debug Profile'),
996
911
                0, 0,
997
 
                self.viewProfileActGrp, 'debug_profile', 1)
998
 
        self.setDebugProfileAct.setStatusTip(self.trUtf8('Activate the debug view profile'))
 
912
                self.viewProfileActGrp, 'debug_profile', True)
 
913
        self.setDebugProfileAct.setStatusTip(\
 
914
            self.trUtf8('Activate the debug view profile'))
999
915
        self.setDebugProfileAct.setWhatsThis(self.trUtf8(
1000
916
            """<b>Debug Profile</b>"""
1001
917
            """<p>Activate the "Debug View Profile". Windows being shown,"""
1002
918
            """ if this profile is active, may be configured with the"""
1003
919
            """ "View Profile Configuration" dialog.</p>"""
1004
920
        ))
1005
 
        self.setDebugProfileAct.connectIt(SIGNAL('activated()'),self.handleSetDebugProfile)
 
921
        self.setDebugProfileAct.connectIt(SIGNAL('triggered()'),
 
922
            self.setDebugProfile)
1006
923
        self.actions.append(self.setDebugProfileAct)
1007
924
        
1008
 
        self.pbAct = E3Action(self.trUtf8('Project-Browser'),
1009
 
                self.trUtf8('&Project-Browser'),0,0,self,'project_browser',1)
1010
 
        self.pbAct.setStatusTip(self.trUtf8('Toggle the Project-Browser window'))
 
925
        self.pbAct = E4Action(self.trUtf8('Project-Viewer'),
 
926
                self.trUtf8('&Project-Viewer'), 0, 0, self, 'project_viewer', True)
 
927
        self.pbAct.setStatusTip(self.trUtf8('Toggle the Project-Viewer window'))
1011
928
        self.pbAct.setWhatsThis(self.trUtf8(
1012
 
            """<b>Toggle the Project-Browser window</b>"""
1013
 
            """<p>If the Project-Browser window is hidden then display it. It is displayed"""
1014
 
            """ then close it.</p>"""
 
929
            """<b>Toggle the Project-Viewer window</b>"""
 
930
            """<p>If the Project-Viewer window is hidden then display it."""
 
931
            """ If it is displayed then close it.</p>"""
1015
932
        ))
1016
 
        self.pbAct.connectIt(SIGNAL('activated()'),self.handleProjectBrowser)
 
933
        self.pbAct.connectIt(SIGNAL('triggered()'), self.__toggleProjectBrowser)
1017
934
        self.actions.append(self.pbAct)
1018
935
        
1019
 
        self.pbActivateAct = E3Action(self.trUtf8('Activate Project-Browser'),
1020
 
                self.trUtf8('Activate Project-Browser'),
 
936
        self.pbActivateAct = E4Action(self.trUtf8('Activate Project-Viewer'),
 
937
                self.trUtf8('Activate Project-Viewer'),
1021
938
                QKeySequence(self.trUtf8("Alt+Shift+P")),
1022
 
                0,self,
1023
 
                'project_browser_activate',1)
1024
 
        self.pbActivateAct.connectIt(SIGNAL('activated()'),
1025
 
            self.handleProjectBrowserActivate)
 
939
                0, self,
 
940
                'project_viewer_activate', True)
 
941
        self.pbActivateAct.connectIt(SIGNAL('triggered()'),
 
942
            self.__activateProjectBrowser)
1026
943
        self.actions.append(self.pbActivateAct)
 
944
        self.pbActivateAct.addTo(self)
1027
945
 
1028
 
        self.sbvAct = E3Action(self.trUtf8('Debug-Browser'),
1029
 
                self.trUtf8('&Debug-Browser'),0,0,self,'debug_browser',1)
1030
 
        self.sbvAct.setStatusTip(self.trUtf8('Toggle the Debug-Browser window'))
1031
 
        self.sbvAct.setWhatsThis(self.trUtf8(
 
946
        self.debugViewerAct = E4Action(self.trUtf8('Debug-Browser'),
 
947
                self.trUtf8('&Debug-Browser'), 0, 0, self, 'debug_viewer', True)
 
948
        self.debugViewerAct.setStatusTip(self.trUtf8('Toggle the Debug-Browser window'))
 
949
        self.debugViewerAct.setWhatsThis(self.trUtf8(
1032
950
            """<b>Toggle the Debug-Browser window</b>"""
1033
951
            """<p>If the Debug-Browser window is hidden then display it."""
1034
952
            """ If it is displayed then close it.</p>"""
1035
953
        ))
1036
 
        self.sbvAct.connectIt(SIGNAL('activated()'),self.handleSBV)
1037
 
        self.actions.append(self.sbvAct)
 
954
        self.debugViewerAct.connectIt(SIGNAL('triggered()'), self.__toggleDebugViewer)
 
955
        self.actions.append(self.debugViewerAct)
1038
956
        
1039
 
        self.sbvActivateAct = E3Action(self.trUtf8('Activate Debug-Browser'),
 
957
        self.debugViewerActivateAct = E4Action(self.trUtf8('Activate Debug-Browser'),
1040
958
                self.trUtf8('Activate Debug-Browser'),
1041
959
                QKeySequence(self.trUtf8("Alt+Shift+D")),
1042
 
                0,self,
1043
 
                'debug_browser_activate',1)
1044
 
        self.sbvActivateAct.connectIt(SIGNAL('activated()'),
1045
 
            self.handleSBVActivate)
1046
 
        self.actions.append(self.sbvActivateAct)
 
960
                0, self,
 
961
                'debug_viewer_activate', True)
 
962
        self.debugViewerActivateAct.connectIt(SIGNAL('triggered()'),
 
963
            self.__activateDebugViewer)
 
964
        self.actions.append(self.debugViewerActivateAct)
 
965
        self.debugViewerActivateAct.addTo(self)
1047
966
 
1048
 
        self.shellAct = E3Action(self.trUtf8('Shell'),
1049
 
                self.trUtf8('&Shell'),0,0,self,'python_shell',1)
 
967
        self.shellAct = E4Action(self.trUtf8('Shell'),
 
968
                self.trUtf8('&Shell'), 0, 0, self, 'interprter_shell', True)
1050
969
        self.shellAct.setStatusTip(self.trUtf8('Toggle the Shell window'))
1051
970
        self.shellAct.setWhatsThis(self.trUtf8(
1052
971
            """<b>Toggle the Shell window</b>"""
1054
973
            """ If it is displayed then close it.</p>"""
1055
974
        ))
1056
975
        if not self.embeddedShell:
1057
 
            self.shellAct.connectIt(SIGNAL('activated()'),self.handleShell)
 
976
            self.shellAct.connectIt(SIGNAL('triggered()'), self.__toggleShell)
1058
977
        self.actions.append(self.shellAct)
1059
978
 
1060
 
        self.shellActivateAct = E3Action(self.trUtf8('Activate Shell'),
 
979
        self.shellActivateAct = E4Action(self.trUtf8('Activate Shell'),
1061
980
                self.trUtf8('Activate Shell'),
1062
981
                QKeySequence(self.trUtf8("Alt+Shift+S")),
1063
 
                0,self,
1064
 
                'python_shell_activate',1)
1065
 
        self.shellActivateAct.connectIt(SIGNAL('activated()'),
1066
 
            self.handleShellActivate)
 
982
                0, self,
 
983
                'interprter_shell_activate', True)
 
984
        self.shellActivateAct.connectIt(SIGNAL('triggered()'),
 
985
            self.__activateShell)
1067
986
        self.actions.append(self.shellActivateAct)
 
987
        self.shellActivateAct.addTo(self)
1068
988
 
1069
 
        self.browserAct = E3Action(self.trUtf8('File-Browser'),
1070
 
                self.trUtf8('File-&Browser'),0,0,self,'file_browser',1)
 
989
        self.browserAct = E4Action(self.trUtf8('File-Browser'),
 
990
                self.trUtf8('File-&Browser'), 0, 0, self, 'file_browser', True)
1071
991
        self.browserAct.setStatusTip(self.trUtf8('Toggle the File-Browser window'))
1072
992
        self.browserAct.setWhatsThis(self.trUtf8(
1073
993
            """<b>Toggle the File-Browser window</b>"""
1075
995
            """ If it is displayed then close it.</p>"""
1076
996
        ))
1077
997
        if not self.embeddedFileBrowser:
1078
 
            self.browserAct.connectIt(SIGNAL('activated()'),self.handleBrowser)
 
998
            self.browserAct.connectIt(SIGNAL('triggered()'), self.__toggleBrowser)
1079
999
        self.actions.append(self.browserAct)
1080
1000
 
1081
 
        self.browserActivateAct = E3Action(self.trUtf8('Activate File-Browser'),
 
1001
        self.browserActivateAct = E4Action(self.trUtf8('Activate File-Browser'),
1082
1002
                self.trUtf8('Activate File-Browser'),
1083
1003
                QKeySequence(self.trUtf8("Alt+Shift+F")),
1084
 
                0,self,
1085
 
                'file_browser_activate',1)
1086
 
        self.browserActivateAct.connectIt(SIGNAL('activated()'),
1087
 
            self.handleBrowserActivate)
 
1004
                0, self,
 
1005
                'file_browser_activate', True)
 
1006
        self.browserActivateAct.connectIt(SIGNAL('triggered()'),
 
1007
            self.__activateBrowser)
1088
1008
        self.actions.append(self.browserActivateAct)
 
1009
        self.browserActivateAct.addTo(self)
1089
1010
 
1090
 
        self.lvAct = E3Action(self.trUtf8('Log-Viewer'),
1091
 
                self.trUtf8('&Log-Viewer'),0,0,self,'log_viewer',1)
1092
 
        self.lvAct.setStatusTip(self.trUtf8('Toggle the Log-Viewer window'))
1093
 
        self.lvAct.setWhatsThis(self.trUtf8(
 
1011
        self.logViewerAct = E4Action(self.trUtf8('Log-Viewer'),
 
1012
                self.trUtf8('&Log-Viewer'), 0, 0, self, 'log_viewer', True)
 
1013
        self.logViewerAct.setStatusTip(self.trUtf8('Toggle the Log-Viewer window'))
 
1014
        self.logViewerAct.setWhatsThis(self.trUtf8(
1094
1015
            """<b>Toggle the Log-Viewer window</b>"""
1095
1016
            """<p>If the Log-Viewer window is hidden then display it."""
1096
1017
            """ If it is displayed then close it.</p>"""
1097
1018
        ))
1098
 
        self.lvAct.connectIt(SIGNAL('activated()'),self.handleLogViewer)
1099
 
        self.actions.append(self.lvAct)
 
1019
        self.logViewerAct.connectIt(SIGNAL('triggered()'), self.__toggleLogViewer)
 
1020
        self.actions.append(self.logViewerAct)
1100
1021
 
1101
 
        self.lvActivateAct = E3Action(self.trUtf8('Activate Log-Viewer'),
 
1022
        self.logViewerActivateAct = E4Action(self.trUtf8('Activate Log-Viewer'),
1102
1023
                self.trUtf8('Activate Log-Viewer'),
1103
1024
                QKeySequence(self.trUtf8("Alt+Shift+G")),
1104
 
                0,self,
1105
 
                'log_viewer_activate',1)
1106
 
        self.lvActivateAct.connectIt(SIGNAL('activated()'),
1107
 
            self.handleLogViewerActivate)
1108
 
        self.actions.append(self.lvActivateAct)
 
1025
                0, self,
 
1026
                'log_viewer_activate', True)
 
1027
        self.logViewerActivateAct.connectIt(SIGNAL('triggered()'),
 
1028
            self.__activateLogViewer)
 
1029
        self.actions.append(self.logViewerActivateAct)
 
1030
        self.logViewerActivateAct.addTo(self)
1109
1031
 
1110
 
        self.tvAct = E3Action(self.trUtf8('Task-Viewer'),
1111
 
                self.trUtf8('T&ask-Viewer'),0,0,self,'task_viewer',1)
1112
 
        self.tvAct.setStatusTip(self.trUtf8('Toggle the Task-Viewer window'))
1113
 
        self.tvAct.setWhatsThis(self.trUtf8(
 
1032
        self.taskViewerAct = E4Action(self.trUtf8('Task-Viewer'),
 
1033
                self.trUtf8('T&ask-Viewer'), 0, 0, self, 'task_viewer', True)
 
1034
        self.taskViewerAct.setStatusTip(self.trUtf8('Toggle the Task-Viewer window'))
 
1035
        self.taskViewerAct.setWhatsThis(self.trUtf8(
1114
1036
            """<b>Toggle the Task-Viewer window</b>"""
1115
1037
            """<p>If the Task-Viewer window is hidden then display it."""
1116
1038
            """ If it is displayed then close it.</p>"""
1117
1039
        ))
1118
 
        self.tvAct.connectIt(SIGNAL('activated()'),self.handleTaskViewer)
1119
 
        self.actions.append(self.tvAct)
 
1040
        self.taskViewerAct.connectIt(SIGNAL('triggered()'), self.__toggleTaskViewer)
 
1041
        self.actions.append(self.taskViewerAct)
1120
1042
 
1121
 
        self.tvActivateAct = E3Action(self.trUtf8('Activate Task-Viewer'),
 
1043
        self.taskViewerActivateAct = E4Action(self.trUtf8('Activate Task-Viewer'),
1122
1044
                self.trUtf8('Activate Task-Viewer'),
1123
1045
                QKeySequence(self.trUtf8("Alt+Shift+T")),
1124
 
                0,self,
 
1046
                0, self,
1125
1047
                'task_viewer_activate',1)
1126
 
        self.tvActivateAct.connectIt(SIGNAL('activated()'),
1127
 
            self.handleTaskViewerActivate)
1128
 
        self.actions.append(self.tvActivateAct)
 
1048
        self.taskViewerActivateAct.connectIt(SIGNAL('triggered()'),
 
1049
            self.__activateTaskViewer)
 
1050
        self.actions.append(self.taskViewerActivateAct)
 
1051
        self.taskViewerActivateAct.addTo(self)
1129
1052
 
1130
 
        self.tevAct = E3Action(self.trUtf8('Template-Viewer'),
1131
 
                self.trUtf8('Te&mplate-Viewer'),0,0,self,'template_viewer',1)
1132
 
        self.tevAct.setStatusTip(self.trUtf8('Toggle the Template-Viewer window'))
1133
 
        self.tevAct.setWhatsThis(self.trUtf8(
 
1053
        self.templateViewerAct = E4Action(self.trUtf8('Template-Viewer'),
 
1054
                self.trUtf8('Te&mplate-Viewer'), 0, 0, self, 'template_viewer', True)
 
1055
        self.templateViewerAct.setStatusTip(\
 
1056
            self.trUtf8('Toggle the Template-Viewer window'))
 
1057
        self.templateViewerAct.setWhatsThis(self.trUtf8(
1134
1058
            """<b>Toggle the Template-Viewer window</b>"""
1135
1059
            """<p>If the Template-Viewer window is hidden then display it."""
1136
1060
            """ If it is displayed then close it.</p>"""
1137
1061
        ))
1138
 
        self.tevAct.connectIt(SIGNAL('activated()'),self.handleTemplateViewer)
1139
 
        self.actions.append(self.tevAct)
 
1062
        self.templateViewerAct.connectIt(SIGNAL('triggered()'), 
 
1063
            self.__toggleTemplateViewer)
 
1064
        self.actions.append(self.templateViewerAct)
1140
1065
 
1141
 
        self.tevActivateAct = E3Action(self.trUtf8('Activate Template-Viewer'),
 
1066
        self.templateViewerActivateAct = E4Action(self.trUtf8('Activate Template-Viewer'),
1142
1067
                self.trUtf8('Activate Template-Viewer'),
1143
1068
                QKeySequence(self.trUtf8("Alt+Shift+M")),
1144
 
                0,self,
 
1069
                0, self,
1145
1070
                'template_viewer_activate',1)
1146
 
        self.tevActivateAct.connectIt(SIGNAL('activated()'),
1147
 
            self.handleTemplateViewerActivate)
1148
 
        self.actions.append(self.tevActivateAct)
 
1071
        self.templateViewerActivateAct.connectIt(SIGNAL('triggered()'),
 
1072
            self.__activateTemplateViewer)
 
1073
        self.actions.append(self.templateViewerActivateAct)
 
1074
        self.templateViewerActivateAct.addTo(self)
1149
1075
 
1150
 
        self.whatsThisAct = E3Action(self.trUtf8('What\'s This?'),
1151
 
                QIconSet(UI.PixmapCache.getPixmap("whatsThis.png")),
1152
 
                self.trUtf8('&What\'s This?'), Qt.SHIFT+Qt.Key_F1,0,self,'whatsThis')
 
1076
        self.whatsThisAct = E4Action(self.trUtf8('What\'s This?'),
 
1077
                UI.PixmapCache.getIcon("whatsThis.png"),
 
1078
                self.trUtf8('&What\'s This?'), 
 
1079
                QKeySequence(self.trUtf8("Shift+F1")),
 
1080
                0, self, 'whatsThis')
1153
1081
        self.whatsThisAct.setStatusTip(self.trUtf8('Context sensitive help'))
1154
1082
        self.whatsThisAct.setWhatsThis(self.trUtf8(
1155
1083
            """<b>Display context sensitive help</b>"""
1159
1087
            """ feature can be accessed using the context help button in the"""
1160
1088
            """ titlebar.</p>"""
1161
1089
        ))
1162
 
        self.whatsThisAct.connectIt(SIGNAL('activated()'),self.whatsThis)
 
1090
        self.whatsThisAct.connectIt(SIGNAL('triggered()'), self.__whatsThis)
1163
1091
        self.actions.append(self.whatsThisAct)
1164
1092
 
1165
 
        self.helpviewerAct = E3Action(self.trUtf8('Helpviewer'),
1166
 
                self.trUtf8('&Helpviewer...'), Qt.Key_F1,0,self,'helpviewer')
 
1093
        self.helpviewerAct = E4Action(self.trUtf8('Helpviewer'),
 
1094
                UI.PixmapCache.getIcon("help.png"),
 
1095
                self.trUtf8('&Helpviewer...'), 
 
1096
                QKeySequence(self.trUtf8("F1")),
 
1097
                0, self, 'helpviewer')
1167
1098
        self.helpviewerAct.setStatusTip(self.trUtf8('Open the helpviewer window'))
1168
1099
        self.helpviewerAct.setWhatsThis(self.trUtf8(
1169
1100
            """<b>Helpviewer</b>"""
1172
1103
            """ links, set bookmarks, print the displayed help and some"""
1173
1104
            """ more features.</p>"""
1174
1105
        ))
1175
 
        self.helpviewerAct.connectIt(SIGNAL('activated()'),self.handleHelpViewer)
 
1106
        self.helpviewerAct.connectIt(SIGNAL('triggered()'), self.__helpViewer)
1176
1107
        self.actions.append(self.helpviewerAct)
1177
1108
        
1178
 
        self.initQtDocActions()
1179
 
        self.initPythonDocAction()
1180
 
        self.initEricDocAction()
 
1109
        self.__initQtDocActions()
 
1110
        self.__initPythonDocAction()
 
1111
        self.__initEricDocAction()
1181
1112
      
1182
 
              
1183
 
        self.aboutAct = E3Action(self.trUtf8('About %1').arg(Program),
 
1113
        self.aboutAct = E4Action(self.trUtf8('About %1').arg(Program),
1184
1114
                self.trUtf8('&About %1').arg(Program),
1185
 
                0,0,self,'about_eric')
 
1115
                0, 0, self, 'about_eric')
1186
1116
        self.aboutAct.setStatusTip(self.trUtf8('Display information about this software'))
1187
1117
        self.aboutAct.setWhatsThis(self.trUtf8(
1188
1118
            """<b>About %1</b>"""
1189
1119
            """<p>Display some information about this software.</p>"""
1190
1120
                             ).arg(Program))
1191
 
        self.aboutAct.connectIt(SIGNAL('activated()'),self.handleAbout)
 
1121
        self.aboutAct.connectIt(SIGNAL('triggered()'), self.__about)
1192
1122
        self.actions.append(self.aboutAct)
1193
1123
 
1194
 
        self.aboutQtAct = E3Action(self.trUtf8('About Qt'),
1195
 
                self.trUtf8('About &Qt'),0,0,self,'about_qt')
1196
 
        self.aboutQtAct.setStatusTip(self.trUtf8('Display information about the Qt toolkit'))
 
1124
        self.aboutQtAct = E4Action(self.trUtf8('About Qt'),
 
1125
                self.trUtf8('About &Qt'), 0, 0, self, 'about_qt')
 
1126
        self.aboutQtAct.setStatusTip(\
 
1127
            self.trUtf8('Display information about the Qt toolkit'))
1197
1128
        self.aboutQtAct.setWhatsThis(self.trUtf8(
1198
1129
            """<b>About Qt</b>"""
1199
1130
            """<p>Display some information about the Qt toolkit.</p>"""
1200
1131
        ))
1201
 
        self.aboutQtAct.connectIt(SIGNAL('activated()'),self.handleAboutQt)
 
1132
        self.aboutQtAct.connectIt(SIGNAL('triggered()'), self.__aboutQt)
1202
1133
        self.actions.append(self.aboutQtAct)
1203
1134
        
1204
1135
        if KdeQt.isKDE():
1205
 
            self.aboutKdeAct = E3Action(self.trUtf8('About KDE'),
1206
 
                    self.trUtf8('About &KDE'),0,0,self,'about_kde')
 
1136
            self.aboutKdeAct = E4Action(self.trUtf8('About KDE'),
 
1137
                    self.trUtf8('About &KDE'), 0, 0, self, 'about_kde')
1207
1138
            self.aboutKdeAct.setStatusTip(self.trUtf8('Display information about KDE'))
1208
1139
            self.aboutKdeAct.setWhatsThis(self.trUtf8(
1209
1140
                """<b>About KDE</b>"""
1210
1141
                """<p>Display some information about KDE.</p>"""
1211
1142
            ))
1212
 
            self.aboutKdeAct.connectIt(SIGNAL('activated()'),self.handleAboutKde)
 
1143
            self.aboutKdeAct.connectIt(SIGNAL('triggered()'), self.__aboutKde)
1213
1144
            self.actions.append(self.aboutKdeAct)
1214
1145
        else:
1215
1146
            self.aboutKdeAct = None
1216
1147
 
1217
 
        self.versionAct = E3Action(self.trUtf8('Show Versions'),
1218
 
                self.trUtf8('Show &Versions'),0,0,self,'show_versions')
 
1148
        self.versionAct = E4Action(self.trUtf8('Show Versions'),
 
1149
                self.trUtf8('Show &Versions'), 0, 0, self, 'show_versions')
1219
1150
        self.versionAct.setStatusTip(self.trUtf8('Display version information'))
1220
1151
        self.versionAct.setWhatsThis(self.trUtf8(
1221
1152
            """<b>Show Versions</b>"""
1222
1153
            """<p>Display version information.</p>"""
1223
1154
                             ))
1224
 
        self.versionAct.connectIt(SIGNAL('activated()'),self.handleVersions)
 
1155
        self.versionAct.connectIt(SIGNAL('triggered()'), self.__showVersions)
1225
1156
        self.actions.append(self.versionAct)
1226
1157
 
1227
 
        self.reportBugAct = E3Action(self.trUtf8('Report Bug'),
1228
 
                self.trUtf8('Report &Bug...'),0,0,self,'report_bug')
 
1158
        self.checkUpdateAct = E4Action(self.trUtf8('Check for Updates'),
 
1159
                self.trUtf8('Check for &Updates...'), 0, 0, self, 'check_updates')
 
1160
        self.checkUpdateAct.setStatusTip(self.trUtf8('Check for Updates'))
 
1161
        self.checkUpdateAct.setWhatsThis(self.trUtf8(
 
1162
            """<b>Check for Updates...</b>"""
 
1163
            """<p>Checks the internet for updates of eric4.</p>"""
 
1164
                             ))
 
1165
        self.checkUpdateAct.connectIt(SIGNAL('triggered()'), self.performVersionCheck)
 
1166
        self.actions.append(self.checkUpdateAct)
 
1167
 
 
1168
        self.reportBugAct = E4Action(self.trUtf8('Report Bug'),
 
1169
                self.trUtf8('Report &Bug...'), 0, 0, self, 'report_bug')
1229
1170
        self.reportBugAct.setStatusTip(self.trUtf8('Report a bug'))
1230
1171
        self.reportBugAct.setWhatsThis(self.trUtf8(
1231
1172
            """<b>Report Bug...</b>"""
1232
1173
            """<p>Opens a dialog to report a bug.</p>"""
1233
1174
                             ))
1234
 
        self.reportBugAct.connectIt(SIGNAL('activated()'),self.handleReportBug)
 
1175
        self.reportBugAct.connectIt(SIGNAL('triggered()'), self.__reportBug)
1235
1176
        self.actions.append(self.reportBugAct)
1236
1177
 
1237
 
        self.utActGrp = E3ActionGroup(self)
 
1178
        self.utActGrp = E4ActionGroup(self)
1238
1179
        
1239
 
        self.utDialogAct = E3Action(self.trUtf8('Unittest'), 
1240
 
                QIconSet(UI.PixmapCache.getPixmap("unittest.png")),
 
1180
        self.utDialogAct = E4Action(self.trUtf8('Unittest'), 
 
1181
                UI.PixmapCache.getIcon("unittest.png"),
1241
1182
                self.trUtf8('&Unittest...'),
1242
1183
                0, 0, self.utActGrp, 'unittest')
1243
1184
        self.utDialogAct.setStatusTip(self.trUtf8('Start unittest dialog'))
1246
1187
            """<p>Perform unit tests. The dialog gives you the"""
1247
1188
            """ ability to select and run a unittest suite.</p>"""
1248
1189
        ))
1249
 
        self.utDialogAct.connectIt(SIGNAL('activated()'), self.handleUnittest)
 
1190
        self.utDialogAct.connectIt(SIGNAL('triggered()'), self.__unittest)
1250
1191
        self.actions.append(self.utDialogAct)
1251
1192
 
1252
 
        self.utRestartAct = E3Action(self.trUtf8('Unittest Restart'),
1253
 
            QIconSet(UI.PixmapCache.getPixmap("unittestRestart.png")),
 
1193
        self.utRestartAct = E4Action(self.trUtf8('Unittest Restart'),
 
1194
            UI.PixmapCache.getIcon("unittestRestart.png"),
1254
1195
            self.trUtf8('&Restart Unittest...'),
1255
1196
            0, 0, self.utActGrp, 'unittest_restart')
1256
1197
        self.utRestartAct.setStatusTip(self.trUtf8('Restart last unittest'))
1258
1199
            """<b>Restart Unittest</b>"""
1259
1200
            """<p>Restart the unittest performed last.</p>"""
1260
1201
        ))
1261
 
        self.utRestartAct.connectIt(SIGNAL('activated()'), self.handleUnittestRestart)
1262
 
        self.utRestartAct.setEnabled(0)
 
1202
        self.utRestartAct.connectIt(SIGNAL('triggered()'), self.__unittestRestart)
 
1203
        self.utRestartAct.setEnabled(False)
1263
1204
        self.actions.append(self.utRestartAct)
1264
1205
        
1265
 
        self.utScriptAct = E3Action(self.trUtf8('Unittest Script'),
1266
 
            QIconSet(UI.PixmapCache.getPixmap("unittestScript.png")),
 
1206
        self.utScriptAct = E4Action(self.trUtf8('Unittest Script'),
 
1207
            UI.PixmapCache.getIcon("unittestScript.png"),
1267
1208
            self.trUtf8('Unittest &Script...'),
1268
1209
            0, 0, self.utActGrp, 'unittest_script')
1269
1210
        self.utScriptAct.setStatusTip(self.trUtf8('Run unittest with current script'))
1271
1212
            """<b>Unittest Script</b>"""
1272
1213
            """<p>Run unittest with current script.</p>"""
1273
1214
        ))
1274
 
        self.utScriptAct.connectIt(SIGNAL('activated()'), self.handleUnittestScript)
1275
 
        self.utScriptAct.setEnabled(0)
 
1215
        self.utScriptAct.connectIt(SIGNAL('triggered()'), self.__unittestScript)
 
1216
        self.utScriptAct.setEnabled(False)
1276
1217
        self.actions.append(self.utScriptAct)
1277
1218
        
1278
 
        self.utProjectAct = E3Action(self.trUtf8('Unittest Project'),
1279
 
            QIconSet(UI.PixmapCache.getPixmap("unittestProject.png")),
 
1219
        self.utProjectAct = E4Action(self.trUtf8('Unittest Project'),
 
1220
            UI.PixmapCache.getIcon("unittestProject.png"),
1280
1221
            self.trUtf8('Unittest &Project...'),
1281
1222
            0, 0, self.utActGrp, 'unittest_project')
1282
1223
        self.utProjectAct.setStatusTip(self.trUtf8('Run unittest with current project'))
1284
1225
            """<b>Unittest Project</b>"""
1285
1226
            """<p>Run unittest with current project.</p>"""
1286
1227
        ))
1287
 
        self.utProjectAct.connectIt(SIGNAL('activated()'), self.handleUnittestProject)
1288
 
        self.utProjectAct.setEnabled(0)
 
1228
        self.utProjectAct.connectIt(SIGNAL('triggered()'), self.__unittestProject)
 
1229
        self.utProjectAct.setEnabled(False)
1289
1230
        self.actions.append(self.utProjectAct)
1290
1231
        
1291
1232
        if self.qtdir is None:
1292
1233
            self.qtActGrp = None
1293
1234
        else:
1294
 
            self.qtActGrp = E3ActionGroup(self)
 
1235
            self.qtActGrp = E4ActionGroup(self)
1295
1236
            
1296
 
            act = E3Action(self.trUtf8('Qt-Designer'), 
1297
 
                    QIconSet(UI.PixmapCache.getPixmap("designer.png")),
 
1237
            act = E4Action(self.trUtf8('Qt-Designer'), 
 
1238
                    UI.PixmapCache.getIcon("designer.png"),
1298
1239
                    self.trUtf8('&Designer...'), 0, 0, self.qtActGrp, 'qt_designer')
1299
1240
            act.setStatusTip(self.trUtf8('Start the Qt-Designer'))
1300
1241
            act.setWhatsThis(self.trUtf8(
1301
1242
                """<b>Qt-Designer</b>"""
1302
1243
                """<p>Start the Qt-Designer.</p>"""
1303
1244
            ))
1304
 
            act.connectIt(SIGNAL('activated()'), self.handleDesigner)
 
1245
            act.connectIt(SIGNAL('triggered()'), self.__designer)
1305
1246
            self.actions.append(act)
1306
1247
            
1307
 
            act = E3Action(self.trUtf8('Qt-Linguist'), 
1308
 
                    QIconSet(UI.PixmapCache.getPixmap("linguist.png")),
 
1248
            act = E4Action(self.trUtf8('Qt-Linguist'), 
 
1249
                    UI.PixmapCache.getIcon("linguist.png"),
1309
1250
                    self.trUtf8('&Linguist...'), 0, 0, self.qtActGrp, 'qt_linguist')
1310
1251
            act.setStatusTip(self.trUtf8('Start the Qt-Linguist'))
1311
1252
            act.setWhatsThis(self.trUtf8(
1312
1253
                """<b>Qt-Linguist</b>"""
1313
1254
                """<p>Start the Qt-Linguist.</p>"""
1314
1255
            ))
1315
 
            act.connectIt(SIGNAL('activated()'), self.handleLinguist)
 
1256
            act.connectIt(SIGNAL('triggered()'), self.__linguist)
1316
1257
            self.actions.append(act)
1317
1258
            
1318
1259
        # check for Qt4 designer and linguist
1319
 
        if self.qt4dir:
1320
 
            designerExe = sys.platform == 'win32' and "designer.exe" or "designer"
1321
 
            if Utilities.isExecutable(os.path.join(self.qt4dir, "bin", designerExe)):
1322
 
                if not self.qtActGrp:
1323
 
                    self.qtActGrp = E3ActionGroup(self)
1324
 
                act = E3Action(self.trUtf8('Qt-Designer 4'), 
1325
 
                        QIconSet(UI.PixmapCache.getPixmap("designer4.png")),
1326
 
                        self.trUtf8('Designer 4...'), 0, 0, self.qtActGrp, 'qt_designer4')
1327
 
                act.setStatusTip(self.trUtf8('Start Qt-Designer 4'))
1328
 
                act.setWhatsThis(self.trUtf8(
1329
 
                    """<b>Qt-Designer 4</b>"""
1330
 
                    """<p>Start Qt-Designer 4.</p>"""
1331
 
                ))
1332
 
                act.connectIt(SIGNAL('activated()'), self.handleDesigner4)
1333
 
                self.actions.append(act)
1334
 
            
1335
 
            linguistExe = sys.platform == 'win32' and "linguist.exe" or "linguist"
1336
 
            if Utilities.isExecutable(os.path.join(self.qt4dir, "bin", linguistExe)):
1337
 
                if not self.qtActGrp:
1338
 
                    self.qtActGrp = E3ActionGroup(self)
1339
 
                act = E3Action(self.trUtf8('Qt-Linguist 4'), 
1340
 
                        QIconSet(UI.PixmapCache.getPixmap("linguist4.png")),
1341
 
                        self.trUtf8('Linguist 4...'), 0, 0, self.qtActGrp, 'qt_linguist4')
1342
 
                act.setStatusTip(self.trUtf8('Start Qt-Linguist 4'))
1343
 
                act.setWhatsThis(self.trUtf8(
1344
 
                    """<b>Qt-Linguist 4</b>"""
1345
 
                    """<p>Start Qt-Linguist 4.</p>"""
1346
 
                ))
1347
 
                act.connectIt(SIGNAL('activated()'), self.handleLinguist4)
1348
 
                self.actions.append(act)
1349
 
        
1350
 
        self.uipreviewerAct = E3Action(self.trUtf8('UI Previewer'), 
1351
 
                QIconSet(UI.PixmapCache.getPixmap("uiPreviewer.png")),
 
1260
        designerExe = sys.platform == 'win32' and \
 
1261
            "%s.exe" % Utilities.generateQtToolName("designer") or \
 
1262
            Utilities.generateQtToolName("designer")
 
1263
        if Utilities.isinpath(designerExe):
 
1264
            if not self.qtActGrp:
 
1265
                self.qtActGrp = E4ActionGroup(self)
 
1266
            act = E4Action(self.trUtf8('Qt-Designer 4'), 
 
1267
                    UI.PixmapCache.getIcon("designer4.png"),
 
1268
                    self.trUtf8('Designer 4...'), 0, 0, self.qtActGrp, 'qt_designer4')
 
1269
            act.setStatusTip(self.trUtf8('Start Qt-Designer 4'))
 
1270
            act.setWhatsThis(self.trUtf8(
 
1271
                """<b>Qt-Designer 4</b>"""
 
1272
                """<p>Start Qt-Designer 4.</p>"""
 
1273
            ))
 
1274
            act.connectIt(SIGNAL('triggered()'), self.__designer4)
 
1275
            self.actions.append(act)
 
1276
        
 
1277
        linguistExe = sys.platform == 'win32' and \
 
1278
            "%s.exe" % Utilities.generateQtToolName("linguist") or \
 
1279
            Utilities.generateQtToolName("linguist")
 
1280
        if Utilities.isinpath(linguistExe):
 
1281
            if not self.qtActGrp:
 
1282
                self.qtActGrp = E4ActionGroup(self)
 
1283
            act = E4Action(self.trUtf8('Qt-Linguist 4'), 
 
1284
                    UI.PixmapCache.getIcon("linguist4.png"),
 
1285
                    self.trUtf8('Linguist 4...'), 0, 0, self.qtActGrp, 'qt_linguist4')
 
1286
            act.setStatusTip(self.trUtf8('Start Qt-Linguist 4'))
 
1287
            act.setWhatsThis(self.trUtf8(
 
1288
                """<b>Qt-Linguist 4</b>"""
 
1289
                """<p>Start Qt-Linguist 4.</p>"""
 
1290
            ))
 
1291
            act.connectIt(SIGNAL('triggered()'), self.__linguist4)
 
1292
            self.actions.append(act)
 
1293
        
 
1294
        self.uipreviewerAct = E4Action(self.trUtf8('UI Previewer'), 
 
1295
                UI.PixmapCache.getIcon("uiPreviewer.png"),
1352
1296
                self.trUtf8('&UI Previewer...'), 0, 0, self, 'ui_previewer')
1353
1297
        self.uipreviewerAct.setStatusTip(self.trUtf8('Start the UI Previewer'))
1354
1298
        self.uipreviewerAct.setWhatsThis(self.trUtf8(
1355
1299
            """<b>UI Previewer</b>"""
1356
1300
            """<p>Start the UI Previewer.</p>"""
1357
1301
        ))
1358
 
        self.uipreviewerAct.connectIt(SIGNAL('activated()'), self.handleUIPreviewer)
 
1302
        self.uipreviewerAct.connectIt(SIGNAL('triggered()'), self.__UIPreviewer)
1359
1303
        self.actions.append(self.uipreviewerAct)
1360
 
        if not getConfig('qtui'):
1361
 
            self.uipreviewerAct.setEnabled(False)
1362
1304
        
1363
 
        self.trpreviewerAct = E3Action(self.trUtf8('Translations Previewer'), 
1364
 
                QIconSet(UI.PixmapCache.getPixmap("trPreviewer.png")),
 
1305
        self.trpreviewerAct = E4Action(self.trUtf8('Translations Previewer'), 
 
1306
                UI.PixmapCache.getIcon("trPreviewer.png"),
1365
1307
                self.trUtf8('&Translations Previewer...'), 0, 0, self, 'tr_previewer')
1366
1308
        self.trpreviewerAct.setStatusTip(self.trUtf8('Start the Translations Previewer'))
1367
1309
        self.trpreviewerAct.setWhatsThis(self.trUtf8(
1368
1310
            """<b>Translations Previewer</b>"""
1369
1311
            """<p>Start the Translations Previewer.</p>"""
1370
1312
        ))
1371
 
        self.trpreviewerAct.connectIt(SIGNAL('activated()'), self.handleTRPreviewer)
 
1313
        self.trpreviewerAct.connectIt(SIGNAL('triggered()'), self.__TRPreviewer)
1372
1314
        self.actions.append(self.trpreviewerAct)
1373
 
        if not getConfig('qtui'):
1374
 
            self.trpreviewerAct.setEnabled(False)
1375
1315
        
1376
 
        self.diffAct = E3Action(self.trUtf8('Compare Files'),
1377
 
                QIconSet(UI.PixmapCache.getPixmap("diffFiles.png")),
 
1316
        self.diffAct = E4Action(self.trUtf8('Compare Files'),
 
1317
                UI.PixmapCache.getIcon("diffFiles.png"),
1378
1318
                self.trUtf8('&Compare Files...'), 0, 0, self, 'diff_files')
1379
1319
        self.diffAct.setStatusTip(self.trUtf8('Compare two files'))
1380
1320
        self.diffAct.setWhatsThis(self.trUtf8(
1381
1321
            """<b>Compare Files</b>"""
1382
1322
            """<p>Open a dialog to compare two files.</p>"""
1383
1323
        ))
1384
 
        self.diffAct.connectIt(SIGNAL('activated()'), self.handleCompareFiles)
 
1324
        self.diffAct.connectIt(SIGNAL('triggered()'), self.__compareFiles)
1385
1325
        self.actions.append(self.diffAct)
1386
1326
 
1387
 
        self.compareAct = E3Action(self.trUtf8('Compare Files side by side'),
1388
 
                QIconSet(UI.PixmapCache.getPixmap("compareFiles.png")),
1389
 
                self.trUtf8('Compare Files &side by side...'), 0, 0, self, 'compare_files')
 
1327
        self.compareAct = E4Action(self.trUtf8('Compare Files side by side'),
 
1328
                UI.PixmapCache.getIcon("compareFiles.png"),
 
1329
                self.trUtf8('Compare Files &side by side...'), 
 
1330
                0, 0, self, 'compare_files')
1390
1331
        self.compareAct.setStatusTip(self.trUtf8('Compare two files'))
1391
1332
        self.compareAct.setWhatsThis(self.trUtf8(
1392
1333
            """<b>Compare Files side by side</b>"""
1393
1334
            """<p>Open a dialog to compare two files and show the result"""
1394
1335
            """ side by side.</p>"""
1395
1336
        ))
1396
 
        self.compareAct.connectIt(SIGNAL('activated()'), self.handleCompareFilesSbs)
 
1337
        self.compareAct.connectIt(SIGNAL('triggered()'), self.__compareFilesSbs)
1397
1338
        self.actions.append(self.compareAct)
1398
1339
 
1399
 
        self.prefAct = E3Action(self.trUtf8('Preferences'),
1400
 
                QIconSet(UI.PixmapCache.getPixmap("configure.png")),
 
1340
        self.chartablesAct = E4Action(self.trUtf8('Character Tables'),
 
1341
                UI.PixmapCache.getIcon("chartables.png"),
 
1342
                self.trUtf8('Character &Tables...'), 0, 0, self, 'chartables')
 
1343
        self.chartablesAct.setStatusTip(self.trUtf8('Show character tables dialog'))
 
1344
        self.chartablesAct.setWhatsThis(self.trUtf8(
 
1345
            """<b>Character Tables</b>"""
 
1346
            """<p>Open a dialog to show and insert special characters.</p>"""
 
1347
        ))
 
1348
        self.chartablesAct.connectIt(SIGNAL('triggered()'), self.__showChartables)
 
1349
        self.actions.append(self.chartablesAct)
 
1350
 
 
1351
        self.prefAct = E4Action(self.trUtf8('Preferences'),
 
1352
                UI.PixmapCache.getIcon("configure.png"),
1401
1353
                self.trUtf8('&Preferences...'), 0, 0, self, 'preferences')
1402
1354
        self.prefAct.setStatusTip(self.trUtf8('Set the prefered configuration'))
1403
1355
        self.prefAct.setWhatsThis(self.trUtf8(
1405
1357
            """<p>Set the configuration items of the application"""
1406
1358
            """ with your prefered values.</p>"""
1407
1359
        ))
1408
 
        self.prefAct.connectIt(SIGNAL('activated()'), self.handlePreferences)
 
1360
        self.prefAct.connectIt(SIGNAL('triggered()'), self.__preferences)
1409
1361
        self.actions.append(self.prefAct)
1410
1362
 
1411
 
        self.reloadAPIsAct = E3Action(self.trUtf8('Reload APIs'),
 
1363
        self.reloadAPIsAct = E4Action(self.trUtf8('Reload APIs'),
1412
1364
                self.trUtf8('Reload &APIs'), 0, 0, self, 'reload_apis')
1413
1365
        self.reloadAPIsAct.setStatusTip(self.trUtf8('Reload the API information'))
1414
1366
        self.reloadAPIsAct.setWhatsThis(self.trUtf8(
1415
1367
            """<b>Reload APIs</b>"""
1416
1368
            """<p>Reload the API information.</p>"""
1417
1369
        ))
1418
 
        self.reloadAPIsAct.connectIt(SIGNAL('activated()'), self.handleReloadAPIs)
 
1370
        self.reloadAPIsAct.connectIt(SIGNAL('triggered()'), self.__reloadAPIs)
1419
1371
        self.actions.append(self.reloadAPIsAct)
1420
1372
 
1421
 
        self.configViewProfilesAct = E3Action(self.trUtf8('View Profiles'),
1422
 
                QIconSet(UI.PixmapCache.getPixmap("configureViewProfiles.png")),
 
1373
        self.showExternalToolsAct = E4Action(self.trUtf8('Show external tools'),
 
1374
                UI.PixmapCache.getIcon("showPrograms.png"),
 
1375
                self.trUtf8('Show external &tools'), 0, 0, self, 'show_external_tools')
 
1376
        self.showExternalToolsAct.setStatusTip(self.trUtf8('Reload the API information'))
 
1377
        self.showExternalToolsAct.setWhatsThis(self.trUtf8(
 
1378
            """<b>Show external tools</b>"""
 
1379
            """<p>Opens a dialog to show the path and versions of all"""
 
1380
            """ extenal tools used by eric4.</p>"""
 
1381
        ))
 
1382
        self.showExternalToolsAct.connectIt(SIGNAL('triggered()'), 
 
1383
            self.__showExternalTools)
 
1384
        self.actions.append(self.showExternalToolsAct)
 
1385
 
 
1386
        self.configViewProfilesAct = E4Action(self.trUtf8('View Profiles'),
 
1387
                UI.PixmapCache.getIcon("configureViewProfiles.png"),
1423
1388
                self.trUtf8('&View Profiles...'), 0, 0, self, 'view_profiles')
1424
1389
        self.configViewProfilesAct.setStatusTip(self.trUtf8('Configure view profiles'))
1425
1390
        self.configViewProfilesAct.setWhatsThis(self.trUtf8(
1428
1393
            """ set the visibility of the various windows for the predetermined"""
1429
1394
            """ view profiles.</p>"""
1430
1395
        ))
1431
 
        self.configViewProfilesAct.connectIt(SIGNAL('activated()'), self.handleConfigViewProfiles)
 
1396
        self.configViewProfilesAct.connectIt(SIGNAL('triggered()'), 
 
1397
            self.__configViewProfiles)
1432
1398
        self.actions.append(self.configViewProfilesAct)
1433
1399
 
1434
 
        self.shortcutsAct = E3Action(self.trUtf8('Keyboard Shortcuts'),
1435
 
                QIconSet(UI.PixmapCache.getPixmap("configureShortcuts.png")),
 
1400
        self.shortcutsAct = E4Action(self.trUtf8('Keyboard Shortcuts'),
 
1401
                UI.PixmapCache.getIcon("configureShortcuts.png"),
1436
1402
                self.trUtf8('Keyboard &Shortcuts...'), 0, 0, self, 'keyboard_shortcuts')
1437
1403
        self.shortcutsAct.setStatusTip(self.trUtf8('Set the keyboard shortcuts'))
1438
1404
        self.shortcutsAct.setWhatsThis(self.trUtf8(
1440
1406
            """<p>Set the keyboard shortcuts of the application"""
1441
1407
            """ with your prefered values.</p>"""
1442
1408
        ))
1443
 
        self.shortcutsAct.connectIt(SIGNAL('activated()'), self.handleConfigShortcuts)
 
1409
        self.shortcutsAct.connectIt(SIGNAL('triggered()'), self.__configShortcuts)
1444
1410
        self.actions.append(self.shortcutsAct)
1445
1411
 
1446
 
        self.exportShortcutsAct = E3Action(self.trUtf8('Export Keyboard Shortcuts'),
1447
 
                QIconSet(UI.PixmapCache.getPixmap("exportShortcuts.png")),
 
1412
        self.exportShortcutsAct = E4Action(self.trUtf8('Export Keyboard Shortcuts'),
 
1413
                UI.PixmapCache.getIcon("exportShortcuts.png"),
1448
1414
                self.trUtf8('&Export Keyboard Shortcuts...'), 0, 0, self,
1449
1415
                'export_keyboard_shortcuts')
1450
1416
        self.exportShortcutsAct.setStatusTip(self.trUtf8('Export the keyboard shortcuts'))
1452
1418
            """<b>Export Keyboard Shortcuts</b>"""
1453
1419
            """<p>Export the keyboard shortcuts of the application.</p>"""
1454
1420
        ))
1455
 
        self.exportShortcutsAct.connectIt(SIGNAL('activated()'), self.handleExportShortcuts)
 
1421
        self.exportShortcutsAct.connectIt(SIGNAL('triggered()'), 
 
1422
            self.__exportShortcuts)
1456
1423
        self.actions.append(self.exportShortcutsAct)
1457
1424
 
1458
 
        self.importShortcutsAct = E3Action(self.trUtf8('Import Keyboard Shortcuts'),
1459
 
                QIconSet(UI.PixmapCache.getPixmap("importShortcuts.png")),
 
1425
        self.importShortcutsAct = E4Action(self.trUtf8('Import Keyboard Shortcuts'),
 
1426
                UI.PixmapCache.getIcon("importShortcuts.png"),
1460
1427
                self.trUtf8('&Import Keyboard Shortcuts...'), 0, 0, self,
1461
1428
                'import_keyboard_shortcuts')
1462
1429
        self.importShortcutsAct.setStatusTip(self.trUtf8('Import the keyboard shortcuts'))
1464
1431
            """<b>Import Keyboard Shortcuts</b>"""
1465
1432
            """<p>Import the keyboard shortcuts of the application.</p>"""
1466
1433
        ))
1467
 
        self.importShortcutsAct.connectIt(SIGNAL('activated()'), self.handleImportShortcuts)
 
1434
        self.importShortcutsAct.connectIt(SIGNAL('triggered()'), 
 
1435
            self.__importShortcuts)
1468
1436
        self.actions.append(self.importShortcutsAct)
1469
1437
 
1470
 
        self.toolsConfAct = E3Action(self.trUtf8('Configure Tools'),
1471
 
                QIconSet(UI.PixmapCache.getPixmap("toolsConfigure.png")),
1472
 
                self.trUtf8('&Configure Tools...'), 0, 0, self, 'configure_tools')
1473
 
        self.toolsConfAct.setStatusTip(self.trUtf8('Configure the entries for the tools menu'))
1474
 
        self.toolsConfAct.setWhatsThis(self.trUtf8(
1475
 
            """<b>Configure Tools</b>"""
1476
 
            """<p>Configure the entries for the tools menu.</p>"""
1477
 
        ))
1478
 
        self.toolsConfAct.connectIt(SIGNAL('activated()'), self.handleToolsConfiguration)
1479
 
        self.actions.append(self.toolsConfAct)
1480
 
 
1481
 
        self.scriptsActGrp = E3ActionGroup(self)
 
1438
        self.scriptsActGrp = E4ActionGroup(self)
1482
1439
        
1483
 
        act = E3Action(self.trUtf8('Load Script'),
 
1440
        act = E4Action(self.trUtf8('Load Script'),
1484
1441
                self.trUtf8('&Load Script...'), 0, 0, self.scriptsActGrp, 'load_script')
1485
 
        act.setStatusTip(self.trUtf8('Load an eric3 script'))
 
1442
        act.setStatusTip(self.trUtf8('Load an eric4 script'))
1486
1443
        act.setWhatsThis(self.trUtf8(
1487
1444
            """<b>Load Script</b>"""
1488
 
            """<p>Load an eric3 script for later use.</p>"""
 
1445
            """<p>Load an eric4 script for later use.</p>"""
1489
1446
        ))
1490
 
        act.connectIt(SIGNAL('activated()'), self.handleLoadScript)
 
1447
        act.connectIt(SIGNAL('triggered()'), self.__loadScript)
1491
1448
        self.actions.append(act)
1492
1449
 
1493
 
        self.scriptsExecAct = E3Action(self.trUtf8('Execute Script'),
1494
 
                self.trUtf8('&Execute Script...'), 0, 0, self.scriptsActGrp, 'execute_script')
1495
 
        self.scriptsExecAct.setStatusTip(self.trUtf8('Execute an eric3 script'))
 
1450
        self.scriptsExecAct = E4Action(self.trUtf8('Execute Script'),
 
1451
                self.trUtf8('&Execute Script...'), 
 
1452
                0, 0, self.scriptsActGrp, 'execute_script')
 
1453
        self.scriptsExecAct.setStatusTip(self.trUtf8('Execute an eric4 script'))
1496
1454
        self.scriptsExecAct.setWhatsThis(self.trUtf8(
1497
1455
            """<b>Execute Script</b>"""
1498
 
            """<p>Execute an eric3 script.</p>"""
 
1456
            """<p>Execute an eric4 script.</p>"""
1499
1457
        ))
1500
 
        self.scriptsExecAct.connectIt(SIGNAL('activated()'), self.handleExecuteScript)
1501
 
        self.scriptsExecAct.setEnabled(0)
 
1458
        self.scriptsExecAct.connectIt(SIGNAL('triggered()'), self.__executeScript)
 
1459
        self.scriptsExecAct.setEnabled(False)
1502
1460
        self.actions.append(self.scriptsExecAct)
1503
1461
        
1504
 
        self.scriptsDeleteAct = E3Action(self.trUtf8('Delete Script'),
1505
 
                self.trUtf8('&Delete Script...'), 0, 0, self.scriptsActGrp, 'delete_script')
1506
 
        self.scriptsDeleteAct.setStatusTip(self.trUtf8('Delete an eric3 script'))
 
1462
        self.scriptsDeleteAct = E4Action(self.trUtf8('Delete Script'),
 
1463
                self.trUtf8('&Delete Script...'), 
 
1464
                0, 0, self.scriptsActGrp, 'delete_script')
 
1465
        self.scriptsDeleteAct.setStatusTip(self.trUtf8('Delete an eric4 script'))
1507
1466
        self.scriptsDeleteAct.setWhatsThis(self.trUtf8(
1508
1467
            """<b>Delete Script</b>"""
1509
 
            """<p>Delete an eric3 script.</p>"""
 
1468
            """<p>Delete an eric4 script.</p>"""
1510
1469
        ))
1511
 
        self.scriptsDeleteAct.connectIt(SIGNAL('activated()'), self.handleDeleteScript)
1512
 
        self.scriptsDeleteAct.setEnabled(0)
 
1470
        self.scriptsDeleteAct.connectIt(SIGNAL('triggered()'), self.__deleteScript)
 
1471
        self.scriptsDeleteAct.setEnabled(False)
1513
1472
        self.actions.append(self.scriptsDeleteAct)
1514
1473
        
1515
 
        self.scriptsExecDocAct = E3Action(self.trUtf8('Execute Document as Script'),
 
1474
        self.scriptsExecDocAct = E4Action(self.trUtf8('Execute Document as Script'),
1516
1475
                self.trUtf8('E&xecute Document as Script'), 0, 0, self,
1517
1476
                'execute_document_as_script')
1518
 
        self.scriptsExecDocAct.setStatusTip(self.trUtf8('Execute current document as an eric3 script'))
 
1477
        self.scriptsExecDocAct.setStatusTip(\
 
1478
            self.trUtf8('Execute current document as an eric4 script'))
1519
1479
        self.scriptsExecDocAct.setWhatsThis(self.trUtf8(
1520
1480
            """<b>Execute Document as Script</b>"""
1521
 
            """<p>Execute the current document as an eric3 script.</p>"""
 
1481
            """<p>Execute the current document as an eric4 script.</p>"""
1522
1482
        ))
1523
 
        self.scriptsExecDocAct.connectIt(SIGNAL('activated()'), self.handleExecuteDocumentAsScript)
1524
 
        self.scriptsExecDocAct.setEnabled(0)
 
1483
        self.scriptsExecDocAct.connectIt(SIGNAL('triggered()'), 
 
1484
            self.__executeDocumentAsScript)
 
1485
        self.scriptsExecDocAct.setEnabled(False)
1525
1486
        self.actions.append(self.scriptsExecDocAct)
1526
1487
        
1527
 
        self.viewmanagerActivateAct = E3Action(self.trUtf8('Activate current editor'),
 
1488
        self.viewmanagerActivateAct = E4Action(self.trUtf8('Activate current editor'),
1528
1489
                self.trUtf8('Activate current editor'),
1529
1490
                QKeySequence(self.trUtf8("Alt+Shift+E")),
1530
 
                0,self,
 
1491
                0, self,
1531
1492
                'viewmanager_activate',1)
1532
 
        self.viewmanagerActivateAct.connectIt(SIGNAL('activated()'),
1533
 
            self.handleViewmanagerActivate)
 
1493
        self.viewmanagerActivateAct.connectIt(SIGNAL('triggered()'),
 
1494
            self.__activateViewmanager)
1534
1495
        self.actions.append(self.viewmanagerActivateAct)
 
1496
        self.viewmanagerActivateAct.addTo(self)
1535
1497
 
1536
 
        self.nextTabAct = E3Action(self.trUtf8('Show next tab'), 
 
1498
        self.nextTabAct = E4Action(self.trUtf8('Show next tab'), 
1537
1499
                      self.trUtf8('Show next tab'), 
1538
1500
                      QKeySequence(self.trUtf8('Ctrl+Alt+Tab')), 0,
1539
1501
                      self, 'view_next_tab')
1540
 
        self.nextTabAct.connectIt( SIGNAL('activated()'), self.__nextTab)
 
1502
        self.nextTabAct.connectIt( SIGNAL('triggered()'), self.__nextTab)
1541
1503
        self.actions.append(self.nextTabAct)
 
1504
        self.nextTabAct.addTo(self)
1542
1505
        
1543
 
        self.prevTabAct = E3Action(self.trUtf8('Show previous tab'), 
 
1506
        self.prevTabAct = E4Action(self.trUtf8('Show previous tab'), 
1544
1507
                      self.trUtf8('Show previous tab'), 
1545
1508
                      QKeySequence(self.trUtf8('Shift+Ctrl+Alt+Tab')), 0,
1546
1509
                      self, 'view_previous_tab')
1547
 
        self.prevTabAct.connectIt( SIGNAL('activated()'), self.__prevTab)
 
1510
        self.prevTabAct.connectIt( SIGNAL('triggered()'), self.__prevTab)
1548
1511
        self.actions.append(self.prevTabAct)
 
1512
        self.prevTabAct.addTo(self)
1549
1513
        
1550
1514
        # initialize viewmanager actions
1551
1515
        self.viewmanager.initActions()
1552
1516
        
1553
1517
        # initialize debugger actions
1554
 
        self.dbg.initActions()
 
1518
        self.debuggerUI.initActions()
1555
1519
        
1556
1520
        # initialize project actions
1557
1521
        self.project.initActions()
1560
1524
        self.refactoring.initActions()
1561
1525
        
1562
1526
        # now read the keyboard shortcuts for the actions
1563
 
        Preferences.readShortcuts(self)
 
1527
        Preferences.readShortcuts()
1564
1528
    
1565
 
    def initQtDocActions(self):
 
1529
    def __initQtDocActions(self):
1566
1530
        """
1567
1531
        Private slot to initilize the action to show the Qt documentation.
1568
1532
        """
1569
 
        self.qtDocAct = E3Action(self.trUtf8('Qt Documentation'),
 
1533
        self.qtDocAct = E4Action(self.trUtf8('Qt Documentation'),
1570
1534
                self.trUtf8('Q&t Documentation'), 0, 0, self, 'qt_documentation')
1571
1535
        self.qtDocAct.setStatusTip(self.trUtf8('Open Qt Documentation'))
1572
1536
        self.qtDocAct.setWhatsThis(self.trUtf8(
1573
1537
            """<b>Qt Documentation</b>"""
1574
1538
            """<p>Display the Qt Documentation. Dependant upon your settings, this"""
1575
1539
            """ will either show the help in Eric's internal help viewer, or execute"""
1576
 
            """ Qt Assistant. </p>"""
 
1540
            """ a web browser or Qt Assistant. </p>"""
1577
1541
        ))
1578
 
        self.qtDocAct.connectIt(SIGNAL('activated()'),self.handleQtDoc)
 
1542
        self.qtDocAct.connectIt(SIGNAL('triggered()'), self.__showQtDoc)
1579
1543
        self.actions.append(self.qtDocAct)
1580
1544
      
1581
 
        self.qt4DocAct = E3Action(self.trUtf8('Qt4 Documentation'),
 
1545
        self.qt4DocAct = E4Action(self.trUtf8('Qt4 Documentation'),
1582
1546
                self.trUtf8('Qt&4 Documentation'), 0, 0, self, 'qt4_documentation')
1583
1547
        self.qt4DocAct.setStatusTip(self.trUtf8('Open Qt4 Documentation'))
1584
1548
        self.qt4DocAct.setWhatsThis(self.trUtf8(
1585
1549
            """<b>Qt4 Documentation</b>"""
1586
 
            """<p>Display the Qt4 Documentation with Qt Assistant. </p>"""
 
1550
            """<p>Display the Qt4 Documentation. Dependant upon your settings, this"""
 
1551
            """ will either show the help in Eric's internal help viewer, or execute"""
 
1552
            """ a web browser or Qt Assistant. </p>"""
1587
1553
        ))
1588
 
        self.qt4DocAct.connectIt(SIGNAL('activated()'),self.handleQt4Doc)
 
1554
        self.qt4DocAct.connectIt(SIGNAL('triggered()'), self.__showQt4Doc)
1589
1555
        self.actions.append(self.qt4DocAct)
1590
1556
      
1591
 
    def initPythonDocAction(self):
 
1557
        self.pyqt4DocAct = E4Action(self.trUtf8('PyQt4 Documentation'),
 
1558
                self.trUtf8('P&yQt4 Documentation'), 0, 0, self, 'pyqt4_documentation')
 
1559
        self.pyqt4DocAct.setStatusTip(self.trUtf8('Open PyQt4 Documentation'))
 
1560
        self.pyqt4DocAct.setWhatsThis(self.trUtf8(
 
1561
            """<b>PyQt4 Documentation</b>"""
 
1562
            """<p>Display the PyQt4 Documentation. Dependant upon your settings, this"""
 
1563
            """ will either show the help in Eric's internal help viewer, or execute"""
 
1564
            """ a web browser or Qt Assistant. </p>"""
 
1565
        ))
 
1566
        self.pyqt4DocAct.connectIt(SIGNAL('triggered()'), self.__showPyQt4Doc)
 
1567
        self.actions.append(self.pyqt4DocAct)
 
1568
      
 
1569
    def __initPythonDocAction(self):
1592
1570
        """
1593
1571
        Private slot to initilize the action to show the Python documentation.
1594
1572
        """
1595
 
        self.pythonDocAct = E3Action(self.trUtf8('Python Documentation'),
 
1573
        self.pythonDocAct = E4Action(self.trUtf8('Python Documentation'),
1596
1574
            self.trUtf8('&Python Documentation'), 0, 0, self, 'python_documentation')
1597
1575
        self.pythonDocAct.setStatusTip(self.trUtf8('Open Python Documentation'))
1598
1576
        self.pythonDocAct.setWhatsThis(self.trUtf8(
1604
1582
                """ Windows and <i>/usr/share/doc/packages/python/html</i> on Unix."""
1605
1583
                """ Set PYTHONDOCDIR in your environment to override this. </p>"""
1606
1584
        ))
1607
 
        self.pythonDocAct.connectIt(SIGNAL('activated()'),self.handlePythonDoc)
 
1585
        self.pythonDocAct.connectIt(SIGNAL('triggered()'),self.__showPythonDoc)
1608
1586
        self.actions.append(self.pythonDocAct)
1609
1587
        
1610
 
    def initEricDocAction(self):
1611
 
        """
1612
 
        Private slot to initialize the action to show the eric3 documentation.
1613
 
        """
1614
 
        self.ericDocAct = E3Action(self.trUtf8("Eric API Documentation"),
 
1588
    def __initEricDocAction(self):
 
1589
        """
 
1590
        Private slot to initialize the action to show the eric4 documentation.
 
1591
        """
 
1592
        self.ericDocAct = E4Action(self.trUtf8("Eric API Documentation"),
1615
1593
            self.trUtf8('&Eric API Documentation'), 0, 0, self, 'eric_documentation')
1616
1594
        self.ericDocAct.setStatusTip(self.trUtf8("Open Eric API Documentation"))
1617
1595
        self.ericDocAct.setWhatsThis(self.trUtf8(
1618
1596
            """<b>Eric API Documentation</b>"""
1619
 
            """<p>Display the Eric API documantation."""
 
1597
            """<p>Display the Eric API documentation."""
1620
1598
            """ The location for the documentation is the Documentation/Source"""
1621
 
            """ subdirectory of the eric3 installation directory.</p>"""
 
1599
            """ subdirectory of the eric4 installation directory.</p>"""
1622
1600
        ))
1623
 
        self.ericDocAct.connectIt(SIGNAL('activated()'),self.handleEricDoc)
 
1601
        self.ericDocAct.connectIt(SIGNAL('triggered()'),self.__showEricDoc)
1624
1602
        self.actions.append(self.ericDocAct)
1625
1603
        
1626
 
    def initMenus(self):
 
1604
    def __initMenus(self):
1627
1605
        """
1628
1606
        Private slot to create the menus.
1629
1607
        """
1630
1608
        mb = self.menuBar()
1631
1609
 
1632
1610
        self.fileMenu = self.viewmanager.initFileMenu()
1633
 
        mb.insertItem(self.trUtf8('&File'), self.fileMenu)
1634
 
        self.fileMenu.insertSeparator()
 
1611
        mb.addMenu(self.fileMenu)
 
1612
        self.fileMenu.addSeparator()
1635
1613
        self.exitAct.addTo(self.fileMenu)
1636
1614
        
1637
1615
        self.editMenu = self.viewmanager.initEditMenu()
1638
 
        mb.insertItem(self.trUtf8('&Edit'), self.editMenu)
 
1616
        mb.addMenu(self.editMenu)
1639
1617
        
1640
1618
        self.viewMenu = self.viewmanager.initViewMenu()
1641
 
        mb.insertItem(self.trUtf8('&View'), self.viewMenu)
1642
 
        
1643
 
        self.debugMenu = self.dbg.initMenu()
1644
 
        mb.insertItem(self.trUtf8('&Debug'), self.debugMenu)
1645
 
        
1646
 
        self.unittestMenu = QPopupMenu(self)
1647
 
        self.unittestMenu.insertTearOffHandle()
1648
 
        mb.insertItem(self.trUtf8('&Unittest'), self.unittestMenu)
 
1619
        mb.addMenu(self.viewMenu)
 
1620
        
 
1621
        self.startMenu, self.debugMenu = self.debuggerUI.initMenus()
 
1622
        mb.addMenu(self.startMenu)
 
1623
        mb.addMenu(self.debugMenu)
 
1624
        
 
1625
        self.unittestMenu = QMenu(self.trUtf8('&Unittest'), self)
 
1626
        self.unittestMenu.setTearOffEnabled(True)
 
1627
        mb.addMenu(self.unittestMenu)
1649
1628
        self.utDialogAct.addTo(self.unittestMenu)
1650
 
        self.unittestMenu.insertSeparator()
 
1629
        self.unittestMenu.addSeparator()
1651
1630
        self.utRestartAct.addTo(self.unittestMenu)
1652
1631
        self.utScriptAct.addTo(self.unittestMenu)
1653
1632
        self.utProjectAct.addTo(self.unittestMenu)
1654
1633
        
1655
1634
        self.projectMenu = self.project.initMenu()
1656
 
        mb.insertItem(self.trUtf8('&Project'), self.projectMenu)
 
1635
        mb.addMenu(self.projectMenu)
1657
1636
        
1658
1637
        self.refactoringMenu = self.refactoring.initMenu()
1659
 
        self.refactoringMenuItem = \
1660
 
            mb.insertItem(self.trUtf8('&Refactoring'), self.refactoringMenu)
1661
 
        mb.setItemEnabled(self.refactoringMenuItem, 0)
 
1638
        self.refactoringMenuAct = mb.addMenu(self.refactoringMenu)
 
1639
        self.refactoringMenuAct.setEnabled(False)
1662
1640
        
1663
 
        self.extrasMenu = QPopupMenu(self)
1664
 
        self.extrasMenu.insertTearOffHandle()
1665
 
        mb.insertItem(self.trUtf8('E&xtras'), self.extrasMenu)
 
1641
        self.extrasMenu = QMenu(self.trUtf8('E&xtras'), self)
 
1642
        self.extrasMenu.setTearOffEnabled(True)
 
1643
        mb.addMenu(self.extrasMenu)
 
1644
        self.wizardsMenu = self.wizards.initMenu()
 
1645
        self.wizardsMenuAct = self.extrasMenu.addMenu(self.wizardsMenu)
 
1646
        self.wizardsMenuAct.setEnabled(False)
1666
1647
        self.macrosMenu = self.viewmanager.initMacroMenu()
1667
 
        self.extrasMenu.insertItem(self.trUtf8("&Macros"), self.macrosMenu)
1668
 
        self.scriptsMenu = QPopupMenu(self)
1669
 
        self.scriptsMenu.insertTearOffHandle()
 
1648
        self.extrasMenu.addMenu(self.macrosMenu)
 
1649
        self.scriptsMenu = QMenu(self.trUtf8("&Scripts"), self)
 
1650
        self.scriptsMenu.setTearOffEnabled(True)
1670
1651
        self.scriptsActGrp.addTo(self.scriptsMenu)
1671
 
        self.scriptsMenu.insertSeparator()
 
1652
        self.scriptsMenu.addSeparator()
1672
1653
        self.scriptsExecDocAct.addTo(self.scriptsMenu)
1673
 
        self.scriptsMenu.insertSeparator()
1674
 
        self.extrasMenu.insertItem(self.trUtf8("&Scripts"), self.scriptsMenu)
1675
 
        self.wizardsMenu = self.wizards.initMenu()
1676
 
        self.wizardsMenuItem = \
1677
 
            self.extrasMenu.insertItem(self.trUtf8('Wi&zards'), self.wizardsMenu)
1678
 
        self.extrasMenu.setItemEnabled(self.wizardsMenuItem, 0)
1679
 
        self.toolsMenu = QPopupMenu(self)
1680
 
        self.extrasMenu.insertItem(self.trUtf8('&Tools'), self.toolsMenu)
1681
 
        self.connect(self.toolsMenu, SIGNAL('aboutToShow()'), self.handleShowToolsMenu)
 
1654
        self.scriptsMenu.addSeparator()
 
1655
        self.extrasMenu.addMenu(self.scriptsMenu)
 
1656
        self.toolsMenu = QMenu(self.trUtf8('&Tools'), self)
 
1657
        self.connect(self.toolsMenu, SIGNAL('aboutToShow()'), 
 
1658
            self.__showToolsMenu)
 
1659
        self.connect(self.toolsMenu, SIGNAL('triggered(QAction *)'),
 
1660
            self.__toolExecute)
 
1661
        self.toolGroupsMenu = QMenu(self.trUtf8("Select Tool Group"), self)
 
1662
        self.connect(self.toolGroupsMenu, SIGNAL('aboutToShow()'), 
 
1663
            self.__showToolGroupsMenu)
 
1664
        self.connect(self.toolGroupsMenu, SIGNAL('triggered(QAction *)'),
 
1665
            self.__toolGroupSelected)
 
1666
        self.toolGroupsMenuTriggered = False
 
1667
        self.extrasMenu.addMenu(self.toolsMenu)
1682
1668
        
1683
 
        self.settingsMenu = QPopupMenu(self)
1684
 
        mb.insertItem(self.trUtf8('&Settings'), self.settingsMenu)
1685
 
        self.settingsMenu.insertTearOffHandle()
 
1669
        self.settingsMenu = QMenu(self.trUtf8('Se&ttings'), self)
 
1670
        mb.addMenu(self.settingsMenu)
 
1671
        self.settingsMenu.setTearOffEnabled(True)
1686
1672
        self.prefAct.addTo(self.settingsMenu)
1687
1673
        self.reloadAPIsAct.addTo(self.settingsMenu)
1688
 
        self.settingsMenu.insertSeparator()
 
1674
        self.settingsMenu.addSeparator()
1689
1675
        self.configViewProfilesAct.addTo(self.settingsMenu)
1690
 
        self.settingsMenu.insertSeparator()
 
1676
        self.settingsMenu.addSeparator()
1691
1677
        self.shortcutsAct.addTo(self.settingsMenu)
1692
1678
        self.exportShortcutsAct.addTo(self.settingsMenu)
1693
1679
        self.importShortcutsAct.addTo(self.settingsMenu)
1694
 
        self.settingsMenu.insertSeparator()
1695
 
        self.toolsConfAct.addTo(self.settingsMenu)
1696
 
        
1697
 
        self.windowMenu = QPopupMenu(self)
1698
 
        mb.insertItem(self.trUtf8('&Window'), self.windowMenu)
1699
 
        self.connect(self.windowMenu, SIGNAL('aboutToShow()'), self.handleShowWindowMenu)
1700
 
        
1701
 
        self.toolbarsMenu = QPopupMenu(self.windowMenu)
1702
 
        self.connect(self.toolbarsMenu, SIGNAL('aboutToShow()'), self.handleShowToolbarsMenu)
1703
 
        
 
1680
        self.settingsMenu.addSeparator()
 
1681
        self.showExternalToolsAct.addTo(self.settingsMenu)
 
1682
        
 
1683
        self.windowMenu = QMenu(self.trUtf8('&Window'), self)
 
1684
        mb.addMenu(self.windowMenu)
 
1685
        self.windowMenu.setTearOffEnabled(True)
 
1686
        self.connect(self.windowMenu, SIGNAL('aboutToShow()'), self.__showWindowMenu)
 
1687
        
 
1688
        self.toolbarsMenu = QMenu(self.trUtf8("&Toolbars"), self.windowMenu)
 
1689
        self.connect(self.toolbarsMenu, SIGNAL('aboutToShow()'), 
 
1690
            self.__showToolbarsMenu)
 
1691
        self.connect(self.toolbarsMenu, SIGNAL('triggered(QAction *)'),
 
1692
            self.__TBMenuTriggered)
 
1693
        
 
1694
        self.__showWindowMenu() # to initialize these actions
 
1695
 
1704
1696
        self.bookmarkMenu = self.viewmanager.initBookmarkMenu()
1705
 
        mb.insertItem(self.trUtf8('&Bookmarks'), self.bookmarkMenu)
1706
 
 
1707
 
        mb.insertSeparator()
1708
 
 
1709
 
        self.helpMenu = QPopupMenu(self)
1710
 
        mb.insertItem(self.trUtf8('&Help'), self.helpMenu)
1711
 
        self.helpMenu.insertTearOffHandle()
 
1697
        mb.addMenu(self.bookmarkMenu)
 
1698
        self.bookmarkMenu.setTearOffEnabled(True)
 
1699
 
 
1700
        mb.addSeparator()
 
1701
 
 
1702
        self.helpMenu = QMenu(self.trUtf8('&Help'), self)
 
1703
        mb.addMenu(self.helpMenu)
 
1704
        self.helpMenu.setTearOffEnabled(True)
1712
1705
        self.helpviewerAct.addTo(self.helpMenu)
1713
 
        self.helpMenu.insertSeparator()
 
1706
        self.helpMenu.addSeparator()
1714
1707
        self.ericDocAct.addTo(self.helpMenu)
1715
1708
        self.pythonDocAct.addTo(self.helpMenu)
1716
1709
        self.qtDocAct.addTo(self.helpMenu)
1717
1710
        self.qt4DocAct.addTo(self.helpMenu)
1718
 
        self.helpMenu.insertSeparator()
 
1711
        self.pyqt4DocAct.addTo(self.helpMenu)
 
1712
        self.helpMenu.addSeparator()
1719
1713
        self.aboutAct.addTo(self.helpMenu)
1720
1714
        self.aboutQtAct.addTo(self.helpMenu)
1721
1715
        if self.aboutKdeAct is not None:
1722
1716
            self.aboutKdeAct.addTo(self.helpMenu)
1723
1717
        self.versionAct.addTo(self.helpMenu)
1724
 
        self.helpMenu.insertSeparator()
 
1718
        self.helpMenu.addSeparator()
 
1719
        self.checkUpdateAct.addTo(self.helpMenu)
1725
1720
        self.reportBugAct.addTo(self.helpMenu)
1726
 
        self.helpMenu.insertSeparator()
 
1721
        self.helpMenu.addSeparator()
1727
1722
        self.whatsThisAct.addTo(self.helpMenu)
 
1723
        self.connect(self.helpMenu, SIGNAL('aboutToShow()'), 
 
1724
            self.__showHelpMenu)
1728
1725
 
1729
 
    def initToolbars(self):
 
1726
    def __initToolbars(self):
1730
1727
        """
1731
1728
        Private slot to create the toolbars.
1732
1729
        """
1734
1731
        edittb = self.viewmanager.initEditToolbar()
1735
1732
        searchtb = self.viewmanager.initSearchToolbar()
1736
1733
        viewtb = self.viewmanager.initViewToolbar()
1737
 
        debugtb = self.dbg.initToolbar()
 
1734
        starttb, debugtb = self.debuggerUI.initToolbars()
1738
1735
        projecttb = self.project.initToolbar()
1739
 
        toolstb = QToolBar(self)
1740
 
        unittesttb = QToolBar(self)
 
1736
        toolstb = QToolBar(self.trUtf8("Tools"), self)
 
1737
        unittesttb = QToolBar(self.trUtf8("Unittest"), self)
1741
1738
        bookmarktb = self.viewmanager.initBookmarkToolbar()
1742
 
        settingstb = QToolBar(self)
1743
 
        helptb = QToolBar(self)
1744
 
        self.scriptsToolBar = QToolBar(self)
1745
 
        profilestb = QToolBar(self)
1746
 
 
 
1739
        settingstb = QToolBar(self.trUtf8("Settings"), self)
 
1740
        helptb = QToolBar(self.trUtf8("Help"), self)
 
1741
        self.scriptsToolBar = QToolBar(self.trUtf8("Scripts"), self)
 
1742
        profilestb = QToolBar(self.trUtf8("Profiles"), self)
 
1743
        
 
1744
        toolstb.setIconSize(Config.ToolBarIconSize)
 
1745
        unittesttb.setIconSize(Config.ToolBarIconSize)
 
1746
        settingstb.setIconSize(Config.ToolBarIconSize)
 
1747
        helptb.setIconSize(Config.ToolBarIconSize)
 
1748
        self.scriptsToolBar.setIconSize(Config.ToolBarIconSize)
 
1749
        profilestb.setIconSize(Config.ToolBarIconSize)
 
1750
        
 
1751
        toolstb.setObjectName("ToolsToolbar")
 
1752
        unittesttb.setObjectName("UnittestToolbar")
 
1753
        settingstb.setObjectName("SettingsToolbar")
 
1754
        helptb.setObjectName("HelpToolbar")
 
1755
        self.scriptsToolBar.setObjectName("ScriptsToolbar")
 
1756
        profilestb.setObjectName("ProfilesToolbar")
 
1757
        
 
1758
        toolstb.setToolTip(self.trUtf8("Tools"))
 
1759
        unittesttb.setToolTip(self.trUtf8("Unittest"))
 
1760
        settingstb.setToolTip(self.trUtf8("Settings"))
 
1761
        helptb.setToolTip(self.trUtf8("Help"))
 
1762
        self.scriptsToolBar.setToolTip(self.trUtf8("Scripts"))
 
1763
        profilestb.setToolTip(self.trUtf8("Profiles"))
 
1764
        
1747
1765
        filetb.addSeparator()
1748
1766
        self.exitAct.addTo(filetb)
1749
1767
        
1760
1778
        toolstb.addSeparator()
1761
1779
        self.diffAct.addTo(toolstb)
1762
1780
        self.compareAct.addTo(toolstb)
 
1781
        toolstb.addSeparator()
 
1782
        self.chartablesAct.addTo(toolstb)
1763
1783
        
1764
1784
        self.prefAct.addTo(settingstb)
1765
1785
        self.configViewProfilesAct.addTo(settingstb)
1766
1786
        self.shortcutsAct.addTo(settingstb)
1767
 
        self.toolsConfAct.addTo(settingstb)
 
1787
        self.showExternalToolsAct.addTo(settingstb)
1768
1788
        
1769
1789
        self.whatsThisAct.addTo(helptb)
1770
1790
        
1771
1791
        self.viewProfileActGrp.addTo(profilestb)
1772
1792
 
 
1793
        self.addToolBar(filetb)
 
1794
        self.addToolBar(edittb)
 
1795
        self.addToolBar(searchtb)
 
1796
        self.addToolBar(viewtb)
 
1797
        self.addToolBar(starttb)
 
1798
        self.addToolBar(debugtb)
 
1799
        self.addToolBar(projecttb)
 
1800
        self.addToolBar(toolstb)
 
1801
        self.addToolBar(helptb)
 
1802
        self.addToolBar(settingstb)
 
1803
        self.addToolBar(self.scriptsToolBar)
 
1804
        self.addToolBar(bookmarktb)
 
1805
        self.addToolBar(unittesttb)
 
1806
        self.addToolBar(profilestb)
 
1807
 
1773
1808
        # just add new toolbars to the end of the list
1774
1809
        self.toolbars = {}
1775
1810
        self.toolbars[0] = (self.trUtf8('File'), filetb)
1776
1811
        self.toolbars[1] = (self.trUtf8('Edit'), edittb)
1777
1812
        self.toolbars[2] = (self.trUtf8('Search'), searchtb)
1778
1813
        self.toolbars[3] = (self.trUtf8('View'), viewtb)
1779
 
        self.toolbars[4] = (self.trUtf8('Debug'), debugtb)
1780
 
        self.toolbars[5] = (self.trUtf8('Project'), projecttb)
1781
 
        self.toolbars[6] = (self.trUtf8('Tools'), toolstb)
1782
 
        self.toolbars[7] = (self.trUtf8('Help'), helptb)
1783
 
        self.toolbars[8] = (self.trUtf8('Settings'), settingstb)
1784
 
        self.toolbars[9] = (self.trUtf8('Scripts'), self.scriptsToolBar)
1785
 
        self.toolbars[10] = (self.trUtf8('Bookmarks'), bookmarktb)
1786
 
        self.toolbars[11] = (self.trUtf8('Unittest'), unittesttb)
1787
 
        self.toolbars[12] = (self.trUtf8('View Profiles'), profilestb)
1788
 
        Preferences.readToolbarSettings(self, self.toolbars)
 
1814
        self.toolbars[4] = (self.trUtf8('Start'), starttb)
 
1815
        self.toolbars[5] = (self.trUtf8('Debug'), debugtb)
 
1816
        self.toolbars[6] = (self.trUtf8('Project'), projecttb)
 
1817
        self.toolbars[7] = (self.trUtf8('Tools'), toolstb)
 
1818
        self.toolbars[8] = (self.trUtf8('Help'), helptb)
 
1819
        self.toolbars[9] = (self.trUtf8('Settings'), settingstb)
 
1820
        self.toolbars[10] = (self.trUtf8('Scripts'), self.scriptsToolBar)
 
1821
        self.toolbars[11] = (self.trUtf8('Bookmarks'), bookmarktb)
 
1822
        self.toolbars[12] = (self.trUtf8('Unittest'), unittesttb)
 
1823
        self.toolbars[13] = (self.trUtf8('View Profiles'), profilestb)
1789
1824
        
1790
 
    def initStatusbar(self):
 
1825
    def __initStatusbar(self):
1791
1826
        """
1792
1827
        Private slot to set up the status bar.
1793
1828
        """
1794
 
        sb = self.statusBar()
 
1829
        self.__statusBar = self.statusBar()
 
1830
        self.__statusBar.setSizeGripEnabled(False)
1795
1831
 
1796
 
        self.sbWritable = QLabel(sb)
1797
 
        sb.addWidget(self.sbWritable,0,1)
1798
 
        QWhatsThis.add(self.sbWritable,self.trUtf8(
 
1832
        self.sbWritable = QLabel(self.__statusBar)
 
1833
        self.__statusBar.addPermanentWidget(self.sbWritable)
 
1834
        self.sbWritable.setWhatsThis(self.trUtf8(
1799
1835
            """<p>This part of the status bar displays an indications of the"""
1800
1836
            """ current editors files writability.</p>"""
1801
1837
        ))
1802
1838
 
1803
 
        self.sbFile = QLabel(sb)
 
1839
        self.sbFile = QLabel(self.__statusBar)
1804
1840
        self.sbFile.setMaximumWidth(500)
1805
1841
        self.sbFile.setMinimumWidth(100)
1806
 
        sb.addWidget(self.sbFile,1,1)
1807
 
        QWhatsThis.add(self.sbFile,self.trUtf8(
 
1842
        self.__statusBar.addPermanentWidget(self.sbFile, True)
 
1843
        self.sbFile.setWhatsThis(self.trUtf8(
1808
1844
            """<p>This part of the status bar displays the name of the file of"""
1809
1845
            """ the current editor or of the file containing the"""
1810
1846
            """ Python statement that is about to be executed if a program is"""
1811
1847
            """ currently being debugged.</p>"""
1812
1848
        ))
1813
 
        self.sbFileWrap = pathlabelwrap_qt3.PathLabelWrap(self.sbFile)
 
1849
        self.sbFileWrap = pathlabelwrap_qt4.PathLabelWrap(self.sbFile)
1814
1850
 
1815
 
        self.sbLine = QLabel(sb)
1816
 
        sb.addWidget(self.sbLine,0,1)
1817
 
        QWhatsThis.add(self.sbLine,self.trUtf8(
 
1851
        self.sbLine = QLabel(self.__statusBar)
 
1852
        self.__statusBar.addPermanentWidget(self.sbLine)
 
1853
        self.sbLine.setWhatsThis(self.trUtf8(
1818
1854
            """<p>This part of the status bar displays the line number of the"""
1819
1855
            """ current editor or the line number of the Python"""
1820
1856
            """ statement that is about to be executed if a program is"""
1821
1857
            """ currently being debugged.</p>"""
1822
1858
        ))
1823
1859
 
1824
 
        self.sbPos = QLabel(sb)
1825
 
        sb.addWidget(self.sbPos,0,1)
1826
 
        QWhatsThis.add(self.sbPos,self.trUtf8(
 
1860
        self.sbPos = QLabel(self.__statusBar)
 
1861
        self.__statusBar.addPermanentWidget(self.sbPos)
 
1862
        self.sbPos.setWhatsThis(self.trUtf8(
1827
1863
            """<p>This part of the status bar displays the cursor position of"""
1828
1864
            """ the current editor. It is blank if there is no current editor or"""
1829
1865
            """ a program is currently being debugged.</p>"""
1830
1866
        ))
1831
 
            
1832
 
        self.viewmanager.setSbInfo(self.sbFileWrap, self.sbLine, self.sbPos, self.sbWritable)
1833
 
 
 
1867
        
 
1868
        self.viewmanager.setSbInfo(self.sbFileWrap, self.sbLine, self.sbPos, 
 
1869
                                   self.sbWritable)
 
1870
 
 
1871
        self.sbVcsMonitorLed = StatusMonitorLed(self.project, self.__statusBar)
 
1872
        self.__statusBar.addPermanentWidget(self.sbVcsMonitorLed)
 
1873
 
 
1874
    def __showHelpMenu(self):
 
1875
        """
 
1876
        Private slot to display the Help menu.
 
1877
        """
 
1878
        self.checkUpdateAct.setEnabled(not self.__inVersionCheck)
 
1879
    
1834
1880
    def __nextTab(self):
1835
1881
        """
1836
1882
        Private slot used to show the next tab.
1837
1883
        """
1838
 
        fwidget = qApp.focusWidget()
 
1884
        fwidget = QApplication.focusWidget()
1839
1885
        while fwidget and not hasattr(fwidget, 'nextTab'):
1840
1886
            fwidget = fwidget.parent()
1841
1887
        if fwidget:
1845
1891
        """
1846
1892
        Private slot used to show the previous tab.
1847
1893
        """
1848
 
        fwidget = qApp.focusWidget()
 
1894
        fwidget = QApplication.focusWidget()
1849
1895
        while fwidget and not hasattr(fwidget, 'prevTab'):
1850
1896
            fwidget = fwidget.parent()
1851
1897
        if fwidget:
1852
1898
            fwidget.prevTab()
1853
1899
    
1854
 
    def handleAbout(self):
 
1900
    def __whatsThis(self):
 
1901
        """
 
1902
        Private slot called in to enter Whats This mode.
 
1903
        """
 
1904
        QWhatsThis.enterWhatsThisMode()
 
1905
        
 
1906
    def __about(self):
1855
1907
        """
1856
1908
        Private slot to handle the About dialog.
1857
1909
        """
1858
1910
        dlg = AboutDialog(self)
1859
 
        dlg.exec_loop()
 
1911
        dlg.exec_()
1860
1912
 
1861
 
    def handleAboutQt(self):
 
1913
    def __aboutQt(self):
1862
1914
        """
1863
1915
        Private slot to handle the About Qt dialog.
1864
1916
        """
1865
 
        QMessageBox.aboutQt(self,Program)
 
1917
        QMessageBox.aboutQt(self, Program)
1866
1918
 
1867
 
    def handleAboutKde(self):
 
1919
    def __aboutKde(self):
1868
1920
        """
1869
1921
        Private slot to handle the About KDE dialog.
1870
1922
        """
1871
1923
        from kdeui import KAboutKDE
1872
1924
        dlg = KAboutKDE(self)
1873
 
        dlg.exec_loop()
 
1925
        dlg.exec_()
1874
1926
        
1875
 
    def handleVersions(self):
 
1927
    def __showVersions(self):
1876
1928
        """
1877
1929
        Private slot to handle the Versions dialog.
1878
1930
        """
1885
1937
        if KdeQt.isKDE():
1886
1938
            versionText = self.trUtf8(
1887
1939
                """<h3>Version Numbers</h3>"""
1888
 
                """<table>"""
1889
 
                """<tr><td><b>Python</b></td><td>%1</td></tr>"""
1890
 
                """<tr><td><b>KDE</b></td><td>%2</td></tr>"""
1891
 
                """<tr><td><b>PyKDE</b></td><td>%3</td></tr>"""
1892
 
                """<tr><td><b>Qt</b></td><td>%4</td></tr>"""
1893
 
                """<tr><td><b>PyQt</b></td><td>%5</td></tr>"""
1894
 
                """<tr><td><b>sip</b></td><td>%6</td></tr>"""
1895
 
                """<tr><td><b>QScintilla</b></td><td>%7</td></tr>"""
1896
 
                """<tr><td><b>%8</b></td><td>%9</td></tr>"""
1897
 
                """<tr><td><b>Bicycle Repair Man</b></td><td>%1</td></tr>"""
1898
 
                """</table>"""
1899
 
            )\
1900
 
            .arg(string.split(sys.version)[0])\
1901
 
            .arg(BRM_VERSION_STR)\
1902
 
            .arg(KdeQt.kdeVersionString())\
1903
 
            .arg(KdeQt.pyKdeVersionString())\
1904
 
            .arg(qVersion())\
1905
 
            .arg(PYQT_VERSION_STR)\
1906
 
            .arg(sip_version_str)\
1907
 
            .arg(QSCINTILLA_VERSION_STR)\
1908
 
            .arg(Program)\
1909
 
            .arg(Version)
 
1940
                """<table>""")
 
1941
            versionText.append(self.trUtf8(
 
1942
                """<tr><td><b>Python</b></td><td>%1</td></tr>""")\
 
1943
                .arg(sys.version.split()[0]))
 
1944
            versionText.append(self.trUtf8(
 
1945
                """<tr><td><b>KDE</b></td><td>%1</td></tr>""")\
 
1946
                .arg(KdeQt.kdeVersionString()))
 
1947
            versionText.append(self.trUtf8(
 
1948
                """<tr><td><b>PyKDE</b></td><td>%1</td></tr>""")\
 
1949
                .arg(KdeQt.pyKdeVersionString()))
 
1950
            versionText.append(self.trUtf8(
 
1951
                """<tr><td><b>Qt</b></td><td>%1</td></tr>""")\
 
1952
                .arg(qVersion()))
 
1953
            versionText.append(self.trUtf8(
 
1954
                """<tr><td><b>PyQt</b></td><td>%1</td></tr>""")\
 
1955
                .arg(PYQT_VERSION_STR))
 
1956
            versionText.append(self.trUtf8(
 
1957
                """<tr><td><b>sip</b></td><td>%1</td></tr>""")\
 
1958
                .arg(sip_version_str))
 
1959
            versionText.append(self.trUtf8(
 
1960
                """<tr><td><b>QScintilla</b></td><td>%1</td></tr>""")\
 
1961
                .arg(QSCINTILLA_VERSION_STR))
 
1962
            versionText.append(self.trUtf8(
 
1963
                """<tr><td><b>%1</b></td><td>%2</td></tr>""")\
 
1964
                .arg(Program)\
 
1965
                .arg(Version))
 
1966
            versionText.append(self.trUtf8(
 
1967
                """<tr><td><b>Bicycle Repair Man</b></td><td>%1</td></tr>""")\
 
1968
                .arg(BRM_VERSION_STR))
 
1969
            versionText.append(self.trUtf8("""</table>"""))
1910
1970
        else:
1911
1971
            versionText = self.trUtf8(
1912
1972
                """<h3>Version Numbers</h3>"""
1913
 
                """<table>"""
1914
 
                """<tr><td><b>Python</b></td><td>%1</td></tr>"""
1915
 
                """<tr><td><b>Qt</b></td><td>%2</td></tr>"""
1916
 
                """<tr><td><b>PyQt</b></td><td>%3</td></tr>"""
1917
 
                """<tr><td><b>sip</b></td><td>%4</td></tr>"""
1918
 
                """<tr><td><b>QScintilla</b></td><td>%5</td></tr>"""
1919
 
                """<tr><td><b>%6</b></td><td>%7</td></tr>"""
1920
 
                """<tr><td><b>Bicycle Repair Man</b></td><td>%8</td></tr>"""
1921
 
                """</table>"""
1922
 
            )\
1923
 
            .arg(string.split(sys.version)[0])\
1924
 
            .arg(qVersion())\
1925
 
            .arg(PYQT_VERSION_STR)\
1926
 
            .arg(sip_version_str)\
1927
 
            .arg(QSCINTILLA_VERSION_STR)\
1928
 
            .arg(Program)\
1929
 
            .arg(Version)\
1930
 
            .arg(BRM_VERSION_STR)
1931
 
            
1932
 
        KQMessageBox.about(self,Program,versionText)
1933
 
        
1934
 
    def handleReportBug(self):
 
1973
                """<table>""")
 
1974
            versionText.append(self.trUtf8(
 
1975
                """<tr><td><b>Python</b></td><td>%1</td></tr>""")\
 
1976
                .arg(sys.version.split()[0]))
 
1977
            versionText.append(self.trUtf8(
 
1978
                """<tr><td><b>Qt</b></td><td>%1</td></tr>""")\
 
1979
                .arg(qVersion()))
 
1980
            versionText.append(self.trUtf8(
 
1981
                """<tr><td><b>PyQt</b></td><td>%1</td></tr>""")\
 
1982
                .arg(PYQT_VERSION_STR))
 
1983
            versionText.append(self.trUtf8(
 
1984
                """<tr><td><b>sip</b></td><td>%1</td></tr>""")\
 
1985
                .arg(sip_version_str))
 
1986
            versionText.append(self.trUtf8(
 
1987
                """<tr><td><b>QScintilla</b></td><td>%1</td></tr>""")\
 
1988
                .arg(QSCINTILLA_VERSION_STR))
 
1989
            versionText.append(self.trUtf8(
 
1990
                """<tr><td><b>%1</b></td><td>%2</td></tr>""")\
 
1991
                .arg(Program)\
 
1992
                .arg(Version))
 
1993
            versionText.append(self.trUtf8(
 
1994
                """<tr><td><b>Bicycle Repair Man</b></td><td>%1</td></tr>""")\
 
1995
                .arg(BRM_VERSION_STR))
 
1996
            versionText.append(self.trUtf8("""</table>"""))
 
1997
        
 
1998
        KQMessageBox.about(self, Program, versionText)
 
1999
        
 
2000
    def __reportBug(self):
1935
2001
        """
1936
2002
        Private slot to handle the Report Bug dialog.
1937
2003
        """
1941
2007
                self.trUtf8("Report Bug"),
1942
2008
                self.trUtf8("""Email address or mail server address is empty.""" 
1943
2009
                            """ Please configure your Email settings in the"""
1944
 
                            """ Preferences Dialog."""),
1945
 
                self.trUtf8("&OK"),
1946
 
                QString.null,
1947
 
                QString.null,
1948
 
                0, -1)
1949
 
            self.handlePreferences()
 
2010
                            """ Preferences Dialog."""))
 
2011
            self.__preferences("emailPage")
1950
2012
            return
1951
2013
            
1952
2014
        self.dlg = EmailDialog()
1953
2015
        self.dlg.show()
1954
2016
        
1955
 
    def handleCompareFiles(self):
 
2017
    def __compareFiles(self):
1956
2018
        """
1957
2019
        Private slot to handle the Compare Files dialog.
1958
2020
        """
1959
2021
        self.diffDlg.show()
1960
2022
        
1961
 
    def handleCompareFilesSbs(self):
 
2023
    def __compareFilesSbs(self):
1962
2024
        """
1963
2025
        Private slot to handle the Compare Files dialog.
1964
2026
        """
1965
2027
        self.compareDlg.show()
 
2028
        
 
2029
    def __showChartables(self):
 
2030
        """
 
2031
        Private slot to show the character tables dialog.
 
2032
        """
 
2033
        if self.chartablesDlg is None:
 
2034
            # generate the character tables dialog
 
2035
            from ThirdParty.chartables.e4Chartables import E4CharTablesDialog
 
2036
            self.chartablesDlg = E4CharTablesDialog(self.locale)
 
2037
            self.connect(self.viewmanager, SIGNAL('editorOpened'),
 
2038
                self.chartablesDlg.editorOpened)
 
2039
            self.connect(self.viewmanager, SIGNAL('lastEditorClosed'),
 
2040
                self.chartablesDlg.lastEditorClosed)
 
2041
        self.chartablesDlg.show()
1966
2042
 
1967
 
    def getViewManager(self):
1968
 
        """
1969
 
        Public method to retrieve the viewmanager object.
1970
 
        
1971
 
        @return reference to the viewmanager object
1972
 
        """
1973
 
        return self.viewmanager
1974
 
        
1975
 
    def getProject(self):
1976
 
        """
1977
 
        Public method to retrieve the project object.
1978
 
        
1979
 
        @return reference to the project object
1980
 
        """
1981
 
        return self.project
1982
 
        
1983
 
    def getProjectBrowser(self):
1984
 
        """
1985
 
        Public method to retrieve the project browser object.
1986
 
        
1987
 
        @return reference to the project browser object
1988
 
        """
1989
 
        return self.projectBrowser
1990
 
        
1991
 
    def getDebugServer(self):
1992
 
        """
1993
 
        Public method to retrieve the debug server object.
1994
 
        
1995
 
        @return reference to the debug server object
1996
 
        """
1997
 
        return self.dbg.dbs
1998
 
        
1999
 
    def getDebugger(self):
2000
 
        """
2001
 
        Public method to retrieve the debugger object
2002
 
        
2003
 
        @return reference to the debug UI object
2004
 
        """
2005
 
        return self.dbg
2006
 
        
2007
 
    def getWizards(self):
2008
 
        """
2009
 
        Public method to retrieve the wizards object
2010
 
        
2011
 
        @return reference to the wizards object
2012
 
        """
2013
 
        return self.wizards
2014
 
        
2015
 
    def getRefactoring(self):
2016
 
        """
2017
 
        Public method to retrieve the refactoring object
2018
 
        
2019
 
        @return reference to the refactoring object
2020
 
        """
2021
 
        return self.refactoring
2022
 
        
2023
 
    def getTaskViewer(self):
2024
 
        """
2025
 
        Public method to retrieve the taskviewer object
2026
 
        
2027
 
        @return reference to the taskviewer object
2028
 
        """
2029
 
        return self.taskViewer
2030
 
        
2031
 
    def getTemplateViewer(self):
2032
 
        """
2033
 
        Public method to retrieve the templateviewer object
2034
 
        
2035
 
        @return reference to the templateviewer object
2036
 
        """
2037
 
        return self.templateViewer
2038
 
        
2039
 
    def getShell(self):
2040
 
        """
2041
 
        Public method to retrieve the shell object
2042
 
        
2043
 
        @return reference to the shell object
2044
 
        """
2045
 
        return self.shell
2046
 
        
2047
2043
    def getActions(self):
2048
2044
        """
2049
2045
        Public method to get a list of all actions.
2050
2046
        
2051
 
        @return list of all actions (list of E3Action)
 
2047
        @return list of all actions (list of E4Action)
2052
2048
        """
2053
2049
        return self.actions[:]
2054
2050
        
2055
 
    def handleQuit(self):
 
2051
    def __quit(self):
2056
2052
        """
2057
2053
        Private method to quit the application.
2058
2054
        """
2059
 
        if self.shutdown():
2060
 
            qApp.closeAllWindows()
 
2055
        if self.__shutdown():
 
2056
            e4App().closeAllWindows()
2061
2057
        
2062
 
    def handleShowToolsMenu(self):
 
2058
    def __showToolsMenu(self):
2063
2059
        """
2064
2060
        Private slot to display the Tools menu.
2065
2061
        """
2066
2062
        self.toolsMenu.clear()
2067
2063
        
2068
 
        self.toolsMenu.insertTearOffHandle()
2069
 
        
2070
 
        # add the fixed entries
2071
 
        if self.qtActGrp is not None:
2072
 
            self.qtActGrp.addTo(self.toolsMenu)
2073
 
        self.uipreviewerAct.addTo(self.toolsMenu)
2074
 
        self.trpreviewerAct.addTo(self.toolsMenu)
2075
 
        self.diffAct.addTo(self.toolsMenu)
2076
 
        self.compareAct.addTo(self.toolsMenu)
2077
 
        self.toolsMenu.insertSeparator()
2078
 
        
2079
 
        #add the configurable entries
 
2064
        self.toolsMenu.addMenu(self.toolGroupsMenu)
 
2065
        act = self.toolsMenu.addAction(self.trUtf8("Configure Tool Groups ..."),
 
2066
            self.__toolGroupsConfiguration)
 
2067
        act.setData(QVariant(-1))
 
2068
        act = self.toolsMenu.addAction(self.trUtf8("Configure current Tool Group ..."), 
 
2069
            self.__toolsConfiguration)
 
2070
        act.setData(QVariant(-2))
 
2071
        self.toolsMenu.addSeparator()
 
2072
        
 
2073
        if self.currentToolGroup == -1:
 
2074
            act.setEnabled(False)
 
2075
            # add the default entries
 
2076
            if self.qtActGrp is not None:
 
2077
                self.qtActGrp.addTo(self.toolsMenu)
 
2078
            self.uipreviewerAct.addTo(self.toolsMenu)
 
2079
            self.trpreviewerAct.addTo(self.toolsMenu)
 
2080
            self.diffAct.addTo(self.toolsMenu)
 
2081
            self.compareAct.addTo(self.toolsMenu)
 
2082
            self.chartablesAct.addTo(self.toolsMenu)
 
2083
        else:
 
2084
            # add the configurable entries
 
2085
            idx = 0
 
2086
            try:
 
2087
                for tool in self.toolGroups[self.currentToolGroup][1]:
 
2088
                    if tool['menutext'] == '--':
 
2089
                        self.toolsMenu.addSeparator()
 
2090
                    else:
 
2091
                        act = self.toolsMenu.addAction(\
 
2092
                            UI.PixmapCache.getIcon(tool['icon']), tool['menutext'])
 
2093
                        act.setData(QVariant(idx))
 
2094
                    idx = idx + 1
 
2095
            except IndexError:
 
2096
                # the current tool group might have been deleted
 
2097
                pass
 
2098
        
 
2099
    def __showToolGroupsMenu(self):
 
2100
        """
 
2101
        Private slot to display the Tool Groups menu.
 
2102
        """
 
2103
        self.toolGroupsMenu.clear()
 
2104
        
 
2105
        # add the default entry
 
2106
        act = self.toolGroupsMenu.addAction(self.trUtf8("&Builtin Tools"))
 
2107
        act.setData(QVariant(-1))
 
2108
        if self.currentToolGroup == -1:
 
2109
            font = act.font()
 
2110
            font.setBold(True)
 
2111
            act.setFont(font)
 
2112
        
 
2113
        # add the configurable tool groups
2080
2114
        idx = 0
2081
 
 
2082
 
        for tool in self.toollist:
2083
 
            id = self.toolsMenu.insertItem(tool[0], self.handleToolExecute)
2084
 
            self.toolsMenu.setItemParameter(id,idx)
2085
 
            
 
2115
        for toolGroup in self.toolGroups:
 
2116
            act = self.toolGroupsMenu.addAction(toolGroup[0])
 
2117
            act.setData(QVariant(idx))
 
2118
            if self.currentToolGroup == idx:
 
2119
                font = act.font()
 
2120
                font.setBold(True)
 
2121
                act.setFont(font)
2086
2122
            idx = idx + 1
2087
2123
        
2088
 
    def handleShowWindowMenu(self):
 
2124
    def __toolGroupSelected(self, act):
 
2125
        """
 
2126
        Private slot to set the current tool group.
 
2127
        
 
2128
        @param act reference to the action that was triggered (QAction)
 
2129
        """
 
2130
        self.toolGroupsMenuTriggered = True
 
2131
        idx, ok = act.data().toInt()
 
2132
        if ok:
 
2133
            self.currentToolGroup = idx
 
2134
        
 
2135
    def __showWindowMenu(self):
2089
2136
        """
2090
2137
        Private slot to display the Window menu.
2091
2138
        """
2092
2139
        self.windowMenu.clear()
2093
 
 
2094
 
        self.windowMenu.insertTearOffHandle()
2095
 
 
 
2140
        
2096
2141
        self.viewProfileActGrp.addTo(self.windowMenu)
2097
 
        self.windowMenu.insertSeparator()
 
2142
        self.windowMenu.addSeparator()
2098
2143
        
2099
2144
        # Set the options according to what is being displayed.
2100
2145
        self.pbAct.addTo(self.windowMenu)
2101
 
        if self.layout == 1:
2102
 
            self.pbAct.setOn(not self.projectBrowserDock.isHidden())
 
2146
        if self.layout == "DockWindows":
 
2147
            self.pbAct.setChecked(not self.projectBrowserDock.isHidden())
2103
2148
        else:
2104
 
            self.pbAct.setOn(not self.projectBrowser.isHidden())
 
2149
            self.pbAct.setChecked(not self.projectBrowser.isHidden())
2105
2150
        
2106
2151
        if not self.embeddedFileBrowser:
2107
2152
            self.browserAct.addTo(self.windowMenu)
2108
 
            if self.layout == 1:
2109
 
                self.browserAct.setOn(not self.browserDock.isHidden())
 
2153
            if self.layout == "DockWindows":
 
2154
                self.browserAct.setChecked(not self.browserDock.isHidden())
2110
2155
            else:
2111
 
                self.browserAct.setOn(not self.browser.isHidden())
 
2156
                self.browserAct.setChecked(not self.browser.isHidden())
2112
2157
            
2113
 
        self.sbvAct.addTo(self.windowMenu)
2114
 
        if self.layout == 1:
2115
 
            self.sbvAct.setOn(not self.sbvDock.isHidden())
 
2158
        self.debugViewerAct.addTo(self.windowMenu)
 
2159
        if self.layout == "DockWindows":
 
2160
            self.debugViewerAct.setChecked(not self.debugViewerDock.isHidden())
2116
2161
        else:
2117
 
            self.sbvAct.setOn(not self.sbv.isHidden())
 
2162
            self.debugViewerAct.setChecked(not self.debugViewer.isHidden())
2118
2163
        
2119
2164
        if not self.embeddedShell:
2120
2165
            self.shellAct.addTo(self.windowMenu)
2121
 
            if self.layout == 1:
2122
 
                self.shellAct.setOn(not self.shellDock.isHidden())
 
2166
            if self.layout == "DockWindows":
 
2167
                self.shellAct.setChecked(not self.shellDock.isHidden())
2123
2168
            else:
2124
 
                self.shellAct.setOn(not self.shell.isHidden())
 
2169
                self.shellAct.setChecked(not self.shell.isHidden())
2125
2170
            
2126
 
        self.lvAct.addTo(self.windowMenu)
2127
 
        if self.layout == 1:
2128
 
            self.lvAct.setOn(not self.logViewerDock.isHidden())
 
2171
        self.logViewerAct.addTo(self.windowMenu)
 
2172
        if self.layout == "DockWindows":
 
2173
            self.logViewerAct.setChecked(not self.logViewerDock.isHidden())
2129
2174
        else:
2130
 
            self.lvAct.setOn(not self.logViewer.isHidden())
 
2175
            self.logViewerAct.setChecked(not self.logViewer.isHidden())
2131
2176
        
2132
 
        self.tvAct.addTo(self.windowMenu)
2133
 
        if self.layout == 1:
2134
 
            self.tvAct.setOn(not self.taskViewerDock.isHidden())
 
2177
        self.taskViewerAct.addTo(self.windowMenu)
 
2178
        if self.layout == "DockWindows":
 
2179
            self.taskViewerAct.setChecked(not self.taskViewerDock.isHidden())
2135
2180
        else:
2136
 
            self.tvAct.setOn(not self.taskViewer.isHidden())
 
2181
            self.taskViewerAct.setChecked(not self.taskViewer.isHidden())
2137
2182
 
2138
 
        self.tevAct.addTo(self.windowMenu)
2139
 
        if self.layout == 1:
2140
 
            self.tevAct.setOn(not self.templateViewerDock.isHidden())
 
2183
        self.templateViewerAct.addTo(self.windowMenu)
 
2184
        if self.layout == "DockWindows":
 
2185
            self.templateViewerAct.setChecked(not self.templateViewerDock.isHidden())
2141
2186
        else:
2142
 
            self.tevAct.setOn(not self.templateViewer.isHidden())
 
2187
            self.templateViewerAct.setChecked(not self.templateViewer.isHidden())
2143
2188
 
2144
2189
        # Insert menu entry for toolbar settings
2145
 
        self.windowMenu.insertSeparator()
2146
 
        self.windowMenu.insertItem(self.trUtf8('&Toolbars'), self.toolbarsMenu)
 
2190
        self.windowMenu.addSeparator()
 
2191
        self.windowMenu.addMenu(self.toolbarsMenu)
2147
2192
        
2148
2193
        # Now do any Source Viewer related stuff.
2149
 
        self.viewmanager.handleShowWindowMenu(self.windowMenu)
 
2194
        self.viewmanager.showWindowMenu(self.windowMenu)
2150
2195
        
2151
 
    def handleShowToolbarsMenu(self):
 
2196
    def __showToolbarsMenu(self):
2152
2197
        """
2153
2198
        Private slot to display the Toolbars menu.
2154
2199
        """
2160
2205
        
2161
2206
        tbList.sort()
2162
2207
        for text, tb, ind in tbList:
2163
 
            id = self.toolbarsMenu.insertItem(text, self.handleTBMenu)
2164
 
            self.toolbarsMenu.setItemParameter(id,ind)
2165
 
            self.toolbarsMenu.setItemChecked(id,not tb.isHidden())
2166
 
            
2167
 
        self.toolbarsMenu.insertSeparator()
2168
 
        self.toolbarsMenu.insertItem(self.trUtf8('Line up'), self.handleLineUpTBs)
 
2208
            act = self.toolbarsMenu.addAction(text)
 
2209
            act.setCheckable(True)
 
2210
            act.setData(QVariant(ind))
 
2211
            act.setChecked(not tb.isHidden())
2169
2212
 
2170
 
    def handleTBMenu(self,idx):
 
2213
    def __TBMenuTriggered(self, act):
2171
2214
        """
2172
2215
        Private method to handle the toggle of a toolbar.
2173
2216
        
2174
 
        @param idx index of the selected toolbar (integer)
2175
 
        """
2176
 
        dummy, tb = self.toolbars[idx]
2177
 
        self.toggleWindow(tb)
2178
 
        
2179
 
    def handleLineUpTBs(self):
2180
 
        """
2181
 
        Private slot to handle the line up toolbars menu entry.
2182
 
        """
2183
 
        self.lineUpDockWindows()
2184
 
        
2185
 
    def activateViewProfile(self, name, save = 1):
 
2217
        @param act reference to the action that was triggered (QAction)
 
2218
        """
 
2219
        idx, ok = act.data().toInt()
 
2220
        if ok:
 
2221
            tb = self.toolbars[idx][1]
 
2222
            self.__toggleWindow(tb)
 
2223
        
 
2224
    def __saveCurrentViewProfile(self, save):
 
2225
        """
 
2226
        Private slot to save the window geometries of the active profile.
 
2227
        
 
2228
        @param save flag indicating that the current profile should
 
2229
            be saved (boolean)
 
2230
        """
 
2231
        if self.currentProfile and save:
 
2232
            # step 1: save the window geometries of the active profile
 
2233
            if self.layout == "DockWindows":
 
2234
                state = self.saveState()
 
2235
                self.profiles[self.currentProfile][1] = str(state)
 
2236
            elif self.layout == "FloatingWindows":
 
2237
                state = self.saveState()
 
2238
                self.profiles[self.currentProfile][3] = str(state)
 
2239
                for window, i in zip(self.windows, range(len(self.windows))):
 
2240
                    if window is not None:
 
2241
                        self.profiles[self.currentProfile][2][i] = \
 
2242
                            str(window.saveGeometry())
 
2243
            # step 2: save the visibility of the windows of the active profile
 
2244
            for window, i in zip(self.windows, range(len(self.windows))):
 
2245
                if window is not None:
 
2246
                    self.profiles[self.currentProfile][0][i] = window.isVisible()
 
2247
    
 
2248
    def __activateViewProfile(self, name, save = True):
2186
2249
        """
2187
2250
        Private slot to activate a view profile.
2188
2251
        
2190
2253
        @param save flag indicating that the current profile should
2191
2254
            be saved (boolean)
2192
2255
        """
2193
 
        # step 1: save the active profile
2194
 
        if self.currentProfile and save:
2195
 
            # step 1a: save the window geometries of the active profile
2196
 
            if self.layout == 1:
2197
 
                s = QString()
2198
 
                ts = QTextStream(s, IO_WriteOnly)
2199
 
                ts << self
2200
 
                self.profiles[self.currentProfile][1] = unicode(s)
2201
 
            elif self.layout == 2:
 
2256
        if self.currentProfile != name:
 
2257
            # step 1: save the active profile
 
2258
            self.__saveCurrentViewProfile(save)
 
2259
            
 
2260
            # step 2: set the window geometries of the new profile
 
2261
            if self.layout == "DockWindows":
 
2262
                state = QByteArray(self.profiles[name][1])
 
2263
                if not state.isEmpty():
 
2264
                    self.restoreState(state)
 
2265
            elif self.layout == "FloatingWindows":
 
2266
                state = QByteArray(self.profiles[name][3])
 
2267
                if not state.isEmpty():
 
2268
                    self.restoreState(state)
2202
2269
                for window, i in zip(self.windows, range(len(self.windows))):
2203
2270
                    if window is not None:
2204
 
                        self.profiles[self.currentProfile][2][i] = \
2205
 
                            self.getFloatingGeometry(window)[:4]
2206
 
            # step 1b: save the visibility of the windows of the active profile
2207
 
            for window, i in zip(self.windows, range(len(self.windows))):
2208
 
                if window is not None:
2209
 
                    self.profiles[self.currentProfile][0][i] = window.isShown()
2210
 
        
2211
 
        # step 2: set the window geometries of the new profile
2212
 
        if self.layout == 1:
2213
 
            s = QString(self.profiles[name][1])
2214
 
            if not s.isEmpty():
2215
 
                ts = QTextStream(s, IO_ReadOnly)
2216
 
                ts >> self
2217
 
        elif self.layout == 2:
2218
 
            for window, i in zip(self.windows, range(len(self.windows))):
2219
 
                if window is not None:
2220
 
                    g = self.profiles[name][2][i]
2221
 
                    window.resize(g[2], g[3])
2222
 
                    window.move(g[0], g[1])
2223
 
        
2224
 
        # step 3: activate the windows of the new profile
2225
 
        for window, visible in zip(self.windows, self.profiles[name][0]):
2226
 
            if window is not None:
2227
 
                window.setShown(visible)
2228
 
        
2229
 
        # step 4: remember the new profile
2230
 
        self.currentProfile = name
2231
 
        
2232
 
        # step 5: make sure that cursor of the shell is visible
2233
 
        self.shell.ensureCursorVisible()
2234
 
        
2235
 
    def handleSetEditProfile(self, save = 1):
 
2271
                        geo = QByteArray(self.profiles[name][2][i])
 
2272
                        if not geo.isEmpty():
 
2273
                            window.restoreGeometry(geo)
 
2274
                            pass
 
2275
            
 
2276
            # step 3: activate the windows of the new profile
 
2277
            for window, visible in zip(self.windows, self.profiles[name][0]):
 
2278
                if window is not None:
 
2279
                    window.setVisible(visible)
 
2280
            
 
2281
            # step 4: remember the new profile
 
2282
            self.currentProfile = name
 
2283
            
 
2284
            # step 5: make sure that cursor of the shell is visible
 
2285
            self.shell.ensureCursorVisible()
 
2286
        
 
2287
    def __setEditProfile(self, save = True):
2236
2288
        """
2237
 
        Public slot to activate the edit view profile.
 
2289
        Private slot to activate the edit view profile.
2238
2290
        
2239
 
        @param noSave flag indicating that the current profile should
 
2291
        @param save flag indicating that the current profile should
2240
2292
            be saved (boolean)
2241
2293
        """
2242
 
        self.activateViewProfile("edit", save)
2243
 
        self.setEditProfileAct.setOn(1)
 
2294
        self.__activateViewProfile("edit", save)
 
2295
        self.setEditProfileAct.setChecked(True)
2244
2296
        
2245
 
    def handleSetDebugProfile(self, save = 1):
 
2297
    def setDebugProfile(self, save = True):
2246
2298
        """
2247
2299
        Public slot to activate the debug view profile.
2248
2300
        
2249
 
        @param noSave flag indicating that the current profile should
 
2301
        @param save flag indicating that the current profile should
2250
2302
            be saved (boolean)
2251
2303
        """
2252
 
        self.activateViewProfile("debug", save)
2253
 
        self.setDebugProfileAct.setOn(1)
 
2304
        self.__activateViewProfile("debug", save)
 
2305
        self.setDebugProfileAct.setChecked(True)
2254
2306
        
2255
2307
    def getViewProfile(self):
2256
2308
        """
2260
2312
        """
2261
2313
        return self.currentProfile
2262
2314
        
2263
 
    def handleProjectBrowser(self):
 
2315
    def __toggleProjectBrowser(self):
2264
2316
        """
2265
2317
        Private slot to handle the toggle of the Project Browser window.
2266
2318
        """
2267
 
        if self.layout == 1:
2268
 
            self.toggleWindow(self.projectBrowserDock)
 
2319
        if self.layout == "DockWindows":
 
2320
            self.__toggleWindow(self.projectBrowserDock)
2269
2321
        else:
2270
 
            self.toggleWindow(self.projectBrowser)
 
2322
            self.__toggleWindow(self.projectBrowser)
2271
2323
 
2272
 
    def handleProjectBrowserActivate(self):
 
2324
    def __activateProjectBrowser(self):
2273
2325
        """
2274
2326
        Private slot to handle the activation of the project browser.
2275
2327
        """
2276
 
        if self.layout == 1:
 
2328
        if self.layout == "DockWindows":
2277
2329
            self.projectBrowserDock.show()
2278
2330
        else:
2279
2331
            self.projectBrowser.show()
2280
 
        self.projectBrowser.currentPage().setFocus()
 
2332
        self.projectBrowser.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
2281
2333
        
2282
 
    def handleSBV(self):
2283
 
        """
2284
 
        Private slot to handle the toggle of the Shell/Browser/Variables window.
2285
 
        """
2286
 
        if self.layout == 1:
2287
 
            self.toggleWindow(self.sbvDock)
 
2334
    def __toggleDebugViewer(self):
 
2335
        """
 
2336
        Private slot to handle the toggle of the debug viewer.
 
2337
        """
 
2338
        if self.layout == "DockWindows":
 
2339
            self.__toggleWindow(self.debugViewerDock)
2288
2340
        else:
2289
 
            self.toggleWindow(self.sbv)
 
2341
            self.__toggleWindow(self.debugViewer)
2290
2342
 
2291
 
    def handleSBVActivate(self):
 
2343
    def __activateDebugViewer(self):
2292
2344
        """
2293
2345
        Private slot to handle the activation of the debug browser.
2294
2346
        """
2295
 
        if self.layout == 1:
2296
 
            self.sbvDock.show()
 
2347
        if self.layout == "DockWindows":
 
2348
            self.debugViewerDock.show()
2297
2349
        else:
2298
 
            self.sbv.show()
2299
 
        self.sbv.currentPage().setFocus()
 
2350
            self.debugViewer.show()
 
2351
        self.debugViewer.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
2300
2352
        
2301
 
    def handleShell(self):
 
2353
    def __toggleShell(self):
2302
2354
        """
2303
2355
        Private slot to handle the toggle of the Shell window .
2304
2356
        """
2305
 
        if self.layout == 1:
2306
 
            self.toggleWindow(self.shellDock)
 
2357
        if self.layout == "DockWindows":
 
2358
            self.__toggleWindow(self.shellDock)
2307
2359
        else:
2308
 
            self.toggleWindow(self.shell)
 
2360
            self.__toggleWindow(self.shell)
2309
2361
 
2310
 
    def handleShellActivate(self):
 
2362
    def __activateShell(self):
2311
2363
        """
2312
2364
        Private slot to handle the activation of the Shell window.
2313
2365
        """
2314
2366
        if self.embeddedShell:              # embedded in debug browser
2315
 
            if self.layout == 1:
2316
 
                self.sbvDock.show()
 
2367
            if self.layout == "DockWindows":
 
2368
                self.debugViewerDock.show()
2317
2369
            else:
2318
 
                self.sbv.show()
2319
 
            self.sbv.showPage(self.shell)
 
2370
                self.debugViewer.show()
 
2371
            self.debugViewer.setCurrentWidget(self.shell)
2320
2372
        else:                               # separate window
2321
 
            if self.layout == 1:
 
2373
            if self.layout == "DockWindows":
2322
2374
                self.shellDock.show()
2323
2375
            else:
2324
2376
                self.shell.show()
2325
 
        self.shell.setFocus()
 
2377
        self.shell.setFocus(Qt.ActiveWindowFocusReason)
2326
2378
        
2327
 
    def handleLogViewer(self):
 
2379
    def __toggleLogViewer(self):
2328
2380
        """
2329
2381
        Private slot to handle the toggle of the Log Viewer window.
2330
2382
        """
2331
 
        if self.layout == 1:
2332
 
            self.toggleWindow(self.logViewerDock)
 
2383
        if self.layout == "DockWindows":
 
2384
            self.__toggleWindow(self.logViewerDock)
2333
2385
        else:
2334
 
            self.toggleWindow(self.logViewer)
 
2386
            self.__toggleWindow(self.logViewer)
2335
2387
 
2336
 
    def handleLogViewerActivate(self):
 
2388
    def __activateLogViewer(self):
2337
2389
        """
2338
2390
        Private slot to handle the activation of the Log Viewer.
2339
2391
        """
2340
 
        if self.layout == 1:
 
2392
        if self.layout == "DockWindows":
2341
2393
            self.logViewerDock.show()
2342
2394
        else:
2343
2395
            self.logViewer.show()
2344
 
        self.logViewer.currentPage().setFocus()
 
2396
        self.logViewer.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
2345
2397
        
2346
 
    def handleTaskViewer(self):
 
2398
    def __toggleTaskViewer(self):
2347
2399
        """
2348
2400
        Private slot to handle the toggle of the Task Viewer window.
2349
2401
        """
2350
 
        if self.layout == 1:
2351
 
            self.toggleWindow(self.taskViewerDock)
 
2402
        if self.layout == "DockWindows":
 
2403
            self.__toggleWindow(self.taskViewerDock)
2352
2404
        else:
2353
 
            self.toggleWindow(self.taskViewer)
 
2405
            self.__toggleWindow(self.taskViewer)
2354
2406
 
2355
 
    def handleTaskViewerActivate(self):
 
2407
    def __activateTaskViewer(self):
2356
2408
        """
2357
2409
        Private slot to handle the activation of the Task Viewer.
2358
2410
        """
2359
 
        if self.layout == 1:
 
2411
        if self.layout == "DockWindows":
2360
2412
            self.taskViewerDock.show()
2361
2413
        else:
2362
2414
            self.taskViewer.show()
2363
 
        self.taskViewer.setFocus()
 
2415
        self.taskViewer.setFocus(Qt.ActiveWindowFocusReason)
2364
2416
        
2365
 
    def handleTemplateViewer(self):
 
2417
    def __toggleTemplateViewer(self):
2366
2418
        """
2367
2419
        Private slot to handle the toggle of the Template Viewer window.
2368
2420
        """
2369
 
        if self.layout == 1:
2370
 
            self.toggleWindow(self.templateViewerDock)
 
2421
        if self.layout == "DockWindows":
 
2422
            self.__toggleWindow(self.templateViewerDock)
2371
2423
        else:
2372
 
            self.toggleWindow(self.templateViewer)
 
2424
            self.__toggleWindow(self.templateViewer)
2373
2425
 
2374
 
    def handleTemplateViewerActivate(self):
 
2426
    def __activateTemplateViewer(self):
2375
2427
        """
2376
2428
        Private slot to handle the activation of the Template Viewer.
2377
2429
        """
2378
 
        if self.layout == 1:
 
2430
        if self.layout == "DockWindows":
2379
2431
            self.templateViewerDock.show()
2380
2432
        else:
2381
2433
            self.templateViewer.show()
2382
 
        self.templateViewer.setFocus()
 
2434
        self.templateViewer.setFocus(Qt.ActiveWindowFocusReason)
2383
2435
        
2384
 
    def handleBrowser(self):
 
2436
    def __toggleBrowser(self):
2385
2437
        """
2386
2438
        Private slot to handle the toggle of the File Browser window.
2387
2439
        """
2388
 
        if self.layout == 1:
2389
 
            self.toggleWindow(self.browserDock)
 
2440
        if self.layout == "DockWindows":
 
2441
            self.__toggleWindow(self.browserDock)
2390
2442
        else:
2391
 
            self.toggleWindow(self.browser)
 
2443
            self.__toggleWindow(self.browser)
2392
2444
 
2393
 
    def handleBrowserActivate(self):
 
2445
    def __activateBrowser(self):
2394
2446
        """
2395
2447
        Private slot to handle the activation of the file browser.
2396
2448
        """
2397
2449
        if self.embeddedFileBrowser == 0:   # separate window
2398
 
            if self.layout == 1:
 
2450
            if self.layout == "DockWindows":
2399
2451
                self.browserDock.show()
2400
2452
            else:
2401
2453
                self.browser.show()
2402
2454
        elif self.embeddedFileBrowser == 1: # embedded in debug browser
2403
 
            if self.layout == 1:
2404
 
                self.sbvDock.show()
 
2455
            if self.layout == "DockWindows":
 
2456
                self.debugViewerDock.show()
2405
2457
            else:
2406
 
                self.sbv.show()
2407
 
            self.sbv.showPage(self.browser)
 
2458
                self.debugViewer.show()
 
2459
            self.debugViewer.setCurrentWidget(self.browser)
2408
2460
        else:                               # embedded in project browser
2409
 
            if self.layout == 1:
 
2461
            if self.layout == "DockWindows":
2410
2462
                self.projectBrowserDock.show()
2411
2463
            else:
2412
2464
                self.projectBrowser.show()
2413
 
            self.projectBrowser.showPage(self.browser)
2414
 
        self.browser.setFocus()
 
2465
            self.projectBrowser.setCurrentWidget(self.browser)
 
2466
        self.browser.setFocus(Qt.ActiveWindowFocusReason)
2415
2467
        
2416
 
    def handleViewmanagerActivate(self):
 
2468
    def __activateViewmanager(self):
2417
2469
        """
2418
2470
        Private slot to handle the activation of the current editor.
2419
2471
        """
2420
2472
        aw = self.viewmanager.activeWindow()
2421
2473
        if aw is not None:
2422
 
            aw.setFocus()
 
2474
            aw.setFocus(Qt.ActiveWindowFocusReason)
2423
2475
    
2424
 
    def toggleWindow(self,w):
 
2476
    def __toggleWindow(self,w):
2425
2477
        """
2426
2478
        Private method to toggle a workspace editor window.
2427
2479
        
2432
2484
        else:
2433
2485
            w.hide()
2434
2486
        
2435
 
    def handleToolsConfiguration(self):
 
2487
    def __toolsConfiguration(self):
2436
2488
        """
2437
2489
        Private slot to handle the tools configuration menu entry.
2438
2490
        """
2439
 
        dlg = ToolConfigurationDialog(self.toollist, self)
2440
 
        if dlg.exec_loop() == QDialog.Accepted:
2441
 
            self.toollist = dlg.getToollist()
2442
 
            
2443
 
    def handleUnittest(self):
 
2491
        dlg = ToolConfigurationDialog(self.toolGroups[self.currentToolGroup][1], self)
 
2492
        if dlg.exec_() == QDialog.Accepted:
 
2493
            self.toolGroups[self.currentToolGroup][1] = dlg.getToollist()
 
2494
        
 
2495
    def __toolGroupsConfiguration(self):
 
2496
        """
 
2497
        Private slot to handle the tool groups configuration menu entry.
 
2498
        """
 
2499
        dlg = ToolGroupConfigurationDialog(self.toolGroups, self.currentToolGroup, self)
 
2500
        if dlg.exec_() == QDialog.Accepted:
 
2501
            self.toolGroups, self.currentToolGroup = dlg.getToolGroups()
 
2502
        
 
2503
    def __unittest(self):
2444
2504
        """
2445
2505
        Private slot for displaying the unittest dialog.
2446
2506
        """
2447
2507
        self.unittestDialog.show()
2448
 
        self.unittestDialog.raiseW()
 
2508
        self.unittestDialog.raise_()
2449
2509
 
2450
 
    def handleUnittestScript(self, prog = None):
 
2510
    def __unittestScript(self, prog = None):
2451
2511
        """
2452
2512
        Private slot for displaying the unittest dialog and run the current script.
2453
2513
        
2464
2524
        
2465
2525
        self.unittestDialog.insertProg(prog)
2466
2526
        self.unittestDialog.show()
2467
 
        self.unittestDialog.raiseW()
2468
 
        self.utRestartAct.setEnabled(1)
 
2527
        self.unittestDialog.raise_()
 
2528
        self.utRestartAct.setEnabled(True)
2469
2529
        
2470
 
    def handleUnittestProject(self):
 
2530
    def __unittestProject(self):
2471
2531
        """
2472
2532
        Private slot for displaying the unittest dialog and run the current project.
2473
2533
        """
2474
 
        fn = self.project.getMainScript(1)
 
2534
        fn = self.project.getMainScript(True)
2475
2535
        if fn:
2476
2536
            tfn = Utilities.getTestFileName(fn)
2477
2537
            if os.path.exists(tfn):
2482
2542
            KQMessageBox.critical(self,
2483
2543
                self.trUtf8("Unittest Project"),
2484
2544
                self.trUtf8("There is no main script defined for the"
2485
 
                    " current project. Aborting"),
2486
 
                self.trUtf8("&OK"))
 
2545
                    " current project. Aborting"))
2487
2546
            return
2488
2547
        
2489
2548
        self.unittestDialog.insertProg(prog)
2490
2549
        self.unittestDialog.show()
2491
 
        self.unittestDialog.raiseW()
2492
 
        self.utRestartAct.setEnabled(1)
 
2550
        self.unittestDialog.raise_()
 
2551
        self.utRestartAct.setEnabled(True)
2493
2552
        
2494
 
    def handleUnittestRestart(self):
 
2553
    def __unittestRestart(self):
2495
2554
        """
2496
2555
        Private slot to display the unittest dialog and rerun the last test.
2497
2556
        """
2498
2557
        self.unittestDialog.show()
2499
 
        self.unittestDialog.raiseW()
2500
 
        self.unittestDialog.handleStartTest()
 
2558
        self.unittestDialog.raise_()
 
2559
        self.unittestDialog.on_startButton_clicked()
2501
2560
        
2502
 
    def handleDesigner(self,fn=None,version=0):
 
2561
    def __designer(self, fn = None, version = 0):
2503
2562
        """
2504
2563
        Private slot to start the Qt-Designer executable.
2505
2564
        
2517
2576
                f.close()
2518
2577
                if uiLine.find("version") == -1:
2519
2578
                    # it is an old version 3 UI file
2520
 
                    designer = os.path.join(self.qtdir, 'bin', 'designer')
 
2579
                    designer = os.path.join(self.qtdir, 'bin', 
 
2580
                        Utilities.generateQtToolName("designer", True))
2521
2581
                else:
2522
2582
                    if uiLine.split('"')[1].startswith("4."):
2523
 
                        designer = os.path.join(self.qt4dir, 'bin', 'designer')
 
2583
                        designer = Utilities.generateQtToolName("designer")
2524
2584
                    else:
2525
 
                        designer = os.path.join(self.qtdir, 'bin', 'designer')
 
2585
                        designer = os.path.join(self.qtdir, 'bin', 
 
2586
                            Utilities.generateQtToolName("designer", True))
2526
2587
            except IOError:
2527
2588
                pass
2528
2589
        if not designer:
2529
2590
            # determine from requested version
2530
2591
            if version == 4:
2531
 
                designer = os.path.join(self.qt4dir, 'bin', 'designer')
 
2592
                designer = Utilities.generateQtToolName("designer")
2532
2593
            else:
2533
 
                designer = os.path.join(self.qtdir, 'bin', 'designer')
 
2594
                designer = os.path.join(self.qtdir, 'bin', 
 
2595
                    Utilities.generateQtToolName("designer", True))
2534
2596
        if sys.platform == "win32":
2535
2597
            designer = designer + '.exe'
2536
 
        proc.addArgument(designer)
 
2598
        args = QStringList()
2537
2599
        if fn is not None:
2538
2600
            fn = unicode(fn)
2539
2601
            try:
2540
2602
                if os.path.isfile(fn) and os.path.getsize(fn):
2541
 
                    proc.addArgument(fn)
 
2603
                    args.append(fn)
2542
2604
                else:
2543
2605
                    KQMessageBox.critical(self,
2544
2606
                        self.trUtf8('Problem'),
2545
 
                        self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2607
                        self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2608
                            ' is zero length.</p>')
2546
2609
                            .arg(fn))
2547
2610
                    return
2548
2611
            except:
2549
2612
                KQMessageBox.critical(self,
2550
2613
                    self.trUtf8('Problem'),
2551
 
                    self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2614
                    self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2615
                        ' is zero length.</p>')
2552
2616
                        .arg(fn))
2553
2617
                return
2554
2618
                
2555
 
        if not proc.start():
 
2619
        if not proc.startDetached(designer, args):
2556
2620
            KQMessageBox.critical(self,
2557
2621
                self.trUtf8('Process Generation Error'),
2558
2622
                self.trUtf8(
2559
2623
                    '<p>Could not start Qt-Designer.<br>'
2560
2624
                    'Ensure that it is available as <b>%1</b>.</p>'
2561
 
                ).arg(designer),
2562
 
                self.trUtf8('OK'))
 
2625
                ).arg(designer))
2563
2626
        
2564
 
    def handleDesigner4(self):
 
2627
    def __designer4(self):
2565
2628
        """
2566
2629
        Private slot to start the Qt-Designer 4 executable.
2567
2630
        """
2568
 
        self.handleDesigner(version=4)
 
2631
        self.__designer(version=4)
2569
2632
        
2570
 
    def handleLinguist(self,fn=None,version=3):
 
2633
    def __linguist(self, fn = None, version = 3):
2571
2634
        """
2572
2635
        Private slot to start the Qt-Linguist executable.
2573
2636
        
2577
2640
        proc = QProcess()
2578
2641
        
2579
2642
        if version == 4:
2580
 
            linguist = os.path.join(self.qt4dir, 'bin', 'linguist')
 
2643
            linguist = Utilities.generateQtToolName("linguist")
2581
2644
        else:
2582
 
            linguist = os.path.join(self.qtdir, 'bin', 'linguist')
 
2645
            linguist = os.path.join(self.qtdir, 'bin', 
 
2646
                Utilities.generateQtToolName("linguist", True))
2583
2647
        if sys.platform == "win32":
2584
2648
            linguist = linguist + '.exe'
2585
 
        proc.addArgument(linguist)
 
2649
        args = QStringList()
2586
2650
        if fn is not None:
2587
 
            fn = unicode(fn)
 
2651
            fn = unicode(fn).replace('.qm', '.ts')
2588
2652
            try:
2589
2653
                if os.path.isfile(fn) and os.path.getsize(fn):
2590
 
                    proc.addArgument(fn)
 
2654
                    args.append(fn)
2591
2655
                else:
2592
2656
                    KQMessageBox.critical(self,
2593
2657
                        self.trUtf8('Problem'),
2594
 
                        self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2658
                        self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2659
                            ' is zero length.</p>')
2595
2660
                            .arg(fn))
2596
2661
                    return
2597
2662
            except:
2598
2663
                KQMessageBox.critical(self,
2599
2664
                    self.trUtf8('Problem'),
2600
 
                    self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2665
                    self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2666
                        ' is zero length.</p>')
2601
2667
                        .arg(fn))
2602
2668
                return
2603
2669
                
2604
 
        if not proc.start():
 
2670
        if not proc.startDetached(linguist, args):
2605
2671
            KQMessageBox.critical(self,
2606
2672
                self.trUtf8('Process Generation Error'),
2607
2673
                self.trUtf8(
2608
2674
                    '<p>Could not start Qt-Linguist.<br>'
2609
2675
                    'Ensure that it is available as <b>%1</b>.</p>'
2610
 
                ).arg(linguist),
2611
 
                self.trUtf8('OK'))
 
2676
                ).arg(linguist))
2612
2677
 
2613
 
    def handleLinguist4(self):
 
2678
    def __linguist4(self, fn = None):
2614
2679
        """
2615
2680
        Private slot to start the Qt-Linguist 4 executable.
 
2681
        
 
2682
        @param fn filename of the translation file to be opened
2616
2683
        """
2617
 
        self.handleLinguist(version=4)
 
2684
        self.__linguist(fn, version = 4)
2618
2685
 
2619
 
    def handleAssistant(self, home=None, version=3):
 
2686
    def __assistant(self, home = None, version = 3):
2620
2687
        """
2621
2688
        Private slot to start the Qt-Assistant executable.
2622
2689
        
2626
2693
        proc = QProcess()
2627
2694
        
2628
2695
        if version == 4:
2629
 
            assistant = os.path.join(self.qt4dir, 'bin', 'assistant')
 
2696
            assistant = Utilities.generateQtToolName("assistant")
2630
2697
        else:
2631
 
            assistant = os.path.join(self.qtdir, 'bin', 'assistant')
 
2698
            assistant = os.path.join(self.qtdir, 'bin', 
 
2699
                Utilities.generateQtToolName("assistant", True))
2632
2700
        if sys.platform == "win32":
2633
2701
            assistant = assistant + '.exe'
2634
 
        proc.addArgument(assistant)
 
2702
        args = QStringList()
2635
2703
        if home:
2636
 
            proc.addArgument('-file')
2637
 
            proc.addArgument(home)
 
2704
            args.append('-file')
 
2705
            args.append(home)
2638
2706
        
2639
 
        if not proc.start():
 
2707
        if not proc.startDetached(assistant, args):
2640
2708
            KQMessageBox.critical(self,
2641
2709
                self.trUtf8('Process Generation Error'),
2642
2710
                self.trUtf8(
2643
2711
                    '<p>Could not start Qt-Assistant.<br>'
2644
2712
                    'Ensure that it is available as <b>%1</b>.</p>'
2645
 
                ).arg(assistant),
2646
 
                self.trUtf8('OK'))
 
2713
                ).arg(assistant))
2647
2714
        
2648
 
    def handleAssistant4(self):
 
2715
    def __assistant4(self):
2649
2716
        """
2650
2717
        Private slot to start the Qt-Assistant 4 executable.
2651
2718
        """
2652
 
        self.handleAssistant(version=4)
 
2719
        self.__assistant(version=4)
2653
2720
    
2654
 
    def handleWebBrowser(self, home=None):
 
2721
    def __webBrowser(self, home = None):
2655
2722
        """
2656
2723
        Private slot to start a web browser executable.
2657
2724
        
2658
2725
        @param home full pathname of a file to display (string or QString)
2659
2726
        """
2660
 
        webbrowser = Preferences.getHelp("Webbrowser")
2661
 
        if webbrowser.isEmpty():
2662
 
            webbrowser = os.environ.get("BROWSER", "")
2663
 
            if not webbrowser:
2664
 
                KQMessageBox.information(self,
2665
 
                    self.trUtf8("Help"),
2666
 
                    self.trUtf8("""Currently no Web browser is selected."""
2667
 
                                """ Please use the preferences dialog to specify one."""),
2668
 
                    self.trUtf8("&OK"),
2669
 
                    QString.null,
2670
 
                    QString.null,
2671
 
                    0, -1)
2672
 
                return
2673
 
            
2674
 
        proc = QProcess()
2675
 
        proc.addArgument(webbrowser)
2676
 
        if home:
2677
 
            proc.addArgument(home)
2678
 
        
2679
 
        if not proc.start():
 
2727
        started = QDesktopServices.openUrl(QUrl(home))
 
2728
        if not started:
2680
2729
            KQMessageBox.critical(self,
2681
 
                self.trUtf8('Process Generation Error'),
2682
 
                self.trUtf8(
2683
 
                    '<p>Could not start web browser.<br>'
2684
 
                    'Ensure that it is available as <b>%1</b>.</p>'
2685
 
                ).arg(webbrowser),
2686
 
                self.trUtf8('OK'))
 
2730
                self.trUtf8('Open Browser'),
 
2731
                self.trUtf8('Could not start a web browser'))
2687
2732
        
2688
 
    def handleCustomViewer(self, home=None):
 
2733
    def __customViewer(self, home = None):
2689
2734
        """
2690
2735
        Private slot to start a custom viewer.
2691
2736
        
2696
2741
            KQMessageBox.information(self,
2697
2742
                self.trUtf8("Help"),
2698
2743
                self.trUtf8("""Currently no custom viewer is selected."""
2699
 
                            """ Please use the preferences dialog to specify one."""),
2700
 
                self.trUtf8("&OK"),
2701
 
                QString.null,
2702
 
                QString.null,
2703
 
                0, -1)
 
2744
                            """ Please use the preferences dialog to specify one."""))
2704
2745
            return
2705
2746
            
2706
2747
        proc = QProcess()
2707
 
        proc.addArgument(customViewer)
 
2748
        args = QStringList()
2708
2749
        if home:
2709
 
            proc.addArgument(home)
 
2750
            args.append(home)
2710
2751
        
2711
 
        if not proc.start():
 
2752
        if not proc.startDetached(customViewer, args):
2712
2753
            KQMessageBox.critical(self,
2713
2754
                self.trUtf8('Process Generation Error'),
2714
2755
                self.trUtf8(
2715
2756
                    '<p>Could not start custom viewer.<br>'
2716
2757
                    'Ensure that it is available as <b>%1</b>.</p>'
2717
 
                ).arg(customViewer),
2718
 
                self.trUtf8('OK'))
 
2758
                ).arg(customViewer))
2719
2759
        
2720
 
    def handleCHM(self, home=None):
 
2760
    def __chmViewer(self, home=None):
2721
2761
        """
2722
2762
        Private slot to start the win32 help viewer to show *.chm files.
2723
2763
        
2725
2765
        """
2726
2766
        if home:
2727
2767
            proc = QProcess()
2728
 
            proc.addArgument("hh")
2729
 
            proc.addArgument(home)
 
2768
            args = QStringList()
 
2769
            args.append(home)
2730
2770
            
2731
 
            if not proc.start():
 
2771
            if not proc.startDetached("hh", args):
2732
2772
                KQMessageBox.critical(self,
2733
2773
                    self.trUtf8('Process Generation Error'),
2734
2774
                    self.trUtf8(
2735
2775
                        '<p>Could not start the help viewer.<br>'
2736
2776
                        'Ensure that it is available as <b>hh</b>.</p>'
2737
 
                    ),
2738
 
                    self.trUtf8('OK'))
 
2777
                    ))
2739
2778
        
2740
 
    def handleUIPreviewer(self,fn=None):
 
2779
    def __UIPreviewer(self,fn=None):
2741
2780
        """
2742
2781
        Private slot to start the UI Previewer executable.
2743
2782
        
2745
2784
        """
2746
2785
        proc = QProcess()
2747
2786
        
2748
 
        viewer = os.path.join(getConfig("ericDir"), "eric3-uipreviewer.py")
 
2787
        viewer = os.path.join(getConfig("ericDir"), "eric4-uipreviewer.py")
2749
2788
        
2750
 
        proc.addArgument(sys.executable)
2751
 
        proc.addArgument(viewer)
 
2789
        args = QStringList()
 
2790
        args.append(viewer)
2752
2791
        
2753
2792
        if fn is not None:
2754
2793
            fn = unicode(fn)
2755
2794
            try:
2756
2795
                if os.path.isfile(fn) and os.path.getsize(fn):
2757
 
                    proc.addArgument(fn)
 
2796
                    args.append(fn)
2758
2797
                else:
2759
2798
                    KQMessageBox.critical(self,
2760
2799
                        self.trUtf8('Problem'),
2761
 
                        self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2800
                        self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2801
                            ' is zero length.</p>')
2762
2802
                            .arg(fn))
2763
2803
                    return
2764
2804
            except:
2765
2805
                KQMessageBox.critical(self,
2766
2806
                    self.trUtf8('Problem'),
2767
 
                    self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2807
                    self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2808
                        ' is zero length.</p>')
2768
2809
                        .arg(fn))
2769
2810
                return
2770
2811
                
2771
 
        if not os.path.isfile(viewer) or not proc.start():
 
2812
        if not os.path.isfile(viewer) or not proc.startDetached(sys.executable, args):
2772
2813
            KQMessageBox.critical(self,
2773
2814
                self.trUtf8('Process Generation Error'),
2774
2815
                self.trUtf8(
2775
2816
                    '<p>Could not start UI Previewer.<br>'
2776
2817
                    'Ensure that it is available as <b>%1</b>.</p>'
2777
 
                ).arg(viewer),
2778
 
                self.trUtf8('OK'))
 
2818
                ).arg(viewer))
2779
2819
        
2780
 
    def handleTRPreviewer(self,fileNames=None):
 
2820
    def __TRPreviewer(self, fileNames = None, ignore = False):
2781
2821
        """
2782
2822
        Private slot to start the Translation Previewer executable.
2783
2823
        
2784
2824
        @param fileNames filenames of forms and/or translations to be previewed
 
2825
        @param ignore flag indicating non existing files should be ignored (boolean)
2785
2826
        """
2786
2827
        proc = QProcess()
2787
2828
        
2788
 
        viewer = os.path.join(getConfig("ericDir"), "eric3-trpreviewer.py")
 
2829
        viewer = os.path.join(getConfig("ericDir"), "eric4-trpreviewer.py")
2789
2830
        
2790
 
        proc.addArgument(sys.executable)
2791
 
        proc.addArgument(viewer)
 
2831
        args = QStringList()
 
2832
        args.append(viewer)
2792
2833
        
2793
2834
        if fileNames is not None:
2794
2835
            for fn in fileNames:
2795
2836
                fn = unicode(fn)
2796
2837
                try:
2797
2838
                    if os.path.isfile(fn) and os.path.getsize(fn):
2798
 
                        proc.addArgument(fn)
 
2839
                        args.append(fn)
2799
2840
                    else:
 
2841
                        if not ignore:
 
2842
                            KQMessageBox.critical(self,
 
2843
                                self.trUtf8('Problem'),
 
2844
                                self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2845
                                    ' is zero length.</p>')
 
2846
                                    .arg(fn))
 
2847
                            return
 
2848
                except:
 
2849
                    if not ignore:
2800
2850
                        KQMessageBox.critical(self,
2801
2851
                            self.trUtf8('Problem'),
2802
 
                            self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
 
2852
                            self.trUtf8('<p>The file <b>%1</b> does not exist or'
 
2853
                                ' is zero length.</p>')
2803
2854
                                .arg(fn))
2804
2855
                        return
2805
 
                except:
2806
 
                    KQMessageBox.critical(self,
2807
 
                        self.trUtf8('Problem'),
2808
 
                        self.trUtf8('<p>The file <b>%1</b> does not exist or is zero length.</p>')
2809
 
                            .arg(fn))
2810
 
                    return
2811
2856
        
2812
 
        if not os.path.isfile(viewer) or not proc.start():
 
2857
        if not os.path.isfile(viewer) or not proc.startDetached(sys.executable, args):
2813
2858
            KQMessageBox.critical(self,
2814
2859
                self.trUtf8('Process Generation Error'),
2815
2860
                self.trUtf8(
2816
2861
                    '<p>Could not start Translation Previewer.<br>'
2817
2862
                    'Ensure that it is available as <b>%1</b>.</p>'
2818
 
                ).arg(viewer),
2819
 
                self.trUtf8('OK'))
 
2863
                ).arg(viewer))
2820
2864
        
2821
 
    def handlePixmap(self, fn):
 
2865
    def __showPixmap(self, fn):
2822
2866
        """
2823
2867
        Private slot to show a pixmap in a dialog.
2824
2868
        """
2826
2870
        if dlg.getStatus():
2827
2871
            dlg.show()
2828
2872
 
2829
 
    def handleToolExecute(self, idx):
 
2873
    def __toolExecute(self, act):
2830
2874
        """
2831
2875
        Private slot to execute a particular tool.
2832
2876
        
2833
 
        @param idx index into the list of configured tools
 
2877
        @param act reference to the action that was triggered (QAction)
2834
2878
        """
2835
 
        proc = QProcess()
2836
 
        proc.addArgument(self.toollist[idx][1])
2837
 
        argv = Utilities.parseOptionString(self.toollist[idx][2])
2838
 
        for arg in argv:
2839
 
            proc.addArgument(arg)
2840
 
        pl = proc.arguments()
2841
 
        t = self.trUtf8("Starting process: %1").arg(pl.join(' '))
2842
 
        self.emit(PYSIGNAL('appendStdout'), (t,))
2843
 
            
2844
 
        self.connect(proc, SIGNAL('processExited()'), self.handleToolExited)
2845
 
        if self.toollist[idx][3]:
2846
 
            proc.setCommunication(QProcess.Stdout | QProcess.Stderr)
2847
 
            self.connect(proc, SIGNAL('readyReadStdout()'), self.handleToolStdout)
2848
 
            self.connect(proc, SIGNAL('readyReadStderr()'), self.handleToolStderr)
2849
 
        else:
2850
 
            proc.setCommunication(0)
2851
 
            
2852
 
        if not proc.start():
2853
 
            KQMessageBox.critical(self,
2854
 
                self.trUtf8('Process Generation Error'),
2855
 
                self.trUtf8(
2856
 
                    '<p>Could not start the tool entry <b>%1</b>.<br>'
2857
 
                    'Ensure that it is available as <b>%2</b>.</p>')\
2858
 
                .arg(self.toollist[idx][0])\
2859
 
                .arg(self.toollist[idx][1]),
2860
 
                self.trUtf8('OK'))
2861
 
        else:
2862
 
            self.toolProcs.append(proc)
2863
 
        
2864
 
    def handleToolStdout(self):
 
2879
        if self.toolGroupsMenuTriggered:
 
2880
            # ignore actions triggered from the select tool group submenu
 
2881
            self.toolGroupsMenuTriggered = False
 
2882
            return
 
2883
        
 
2884
        if self.currentToolGroup == -1:
 
2885
            # it was a built in tool, don't handle it here
 
2886
            return
 
2887
        
 
2888
        idx, ok = act.data().toInt()
 
2889
        if ok and idx >= 0:
 
2890
            tool = self.toolGroups[self.currentToolGroup][1]
 
2891
            proc = QProcess()
 
2892
            procData = (None,)
 
2893
            program = unicode(tool[idx]['executable'])
 
2894
            args = QStringList()
 
2895
            argv = Utilities.parseOptionString(tool[idx]['arguments'])
 
2896
            for arg in argv:
 
2897
                args.append(arg)
 
2898
            pl = QStringList(program) + args
 
2899
            t = self.trUtf8("Starting process '%1 %2'.\n")\
 
2900
                .arg(program)\
 
2901
                .arg(tool[idx]['arguments'])
 
2902
            self.emit(SIGNAL('appendStdout'), t)
 
2903
            
 
2904
            self.connect(proc, SIGNAL('finished(int, QProcess::ExitStatus)'), 
 
2905
                self.__toolFinished)
 
2906
            if tool[idx]['redirect'] != 'no':
 
2907
                self.connect(proc, SIGNAL('readyReadStandardOutput()'), 
 
2908
                    self.__processToolStdout)
 
2909
                self.connect(proc, SIGNAL('readyReadStandardError()'), 
 
2910
                    self.__processToolStderr)
 
2911
                if tool[idx]['redirect'] in ["insert", "replaceSelection"]:
 
2912
                    aw = self.viewmanager.activeWindow()
 
2913
                    procData = (aw, tool[idx]['redirect'], [])
 
2914
                    if aw is not None:
 
2915
                        aw.beginUndoAction()
 
2916
            
 
2917
            proc.start(program, args)
 
2918
            if not proc.waitForStarted():
 
2919
                KQMessageBox.critical(self,
 
2920
                    self.trUtf8('Process Generation Error'),
 
2921
                    self.trUtf8(
 
2922
                        '<p>Could not start the tool entry <b>%1</b>.<br>'
 
2923
                        'Ensure that it is available as <b>%2</b>.</p>')\
 
2924
                    .arg(tool[idx]['menutext']).arg(tool[idx]['executable']))
 
2925
            else:
 
2926
                self.toolProcs.append((program, proc, procData))
 
2927
                if tool[idx]['redirect'] == 'no':
 
2928
                    proc.closeReadChannel(QProcess.StandardOutput)
 
2929
                    proc.closeReadChannel(QProcess.StandardError)
 
2930
                    proc.closeWriteChannel()
 
2931
        
 
2932
    def __processToolStdout(self):
2865
2933
        """
2866
2934
        Private slot to handle the readyReadStdout signal of a tool process.
2867
2935
        """
2868
2936
        # loop through all running tool processes
2869
 
        for toolProc in self.toolProcs:
2870
 
            if toolProc.canReadLineStdout():
2871
 
                pl = toolProc.arguments()
2872
 
                tool = pl[0]
2873
 
                tool.append(" - ")
2874
 
                while toolProc.canReadLineStdout():
2875
 
                    s = QString(tool)
2876
 
                    s.append(toolProc.readLineStdout())
2877
 
                    self.emit(PYSIGNAL('appendStdout'), (s,))
 
2937
        for program, toolProc, toolProcData in self.toolProcs:
 
2938
            toolProc.setReadChannel(QProcess.StandardOutput)
 
2939
            
 
2940
            if toolProcData[0] is None or \
 
2941
               toolProcData[1] not in ["insert", "replaceSelection"]: 
 
2942
                # not connected to an editor or wrong mode
 
2943
                while toolProc.canReadLine():
 
2944
                    s = QString("%s - " % program)
 
2945
                    s.append(toolProc.readLine())
 
2946
                    self.emit(SIGNAL('appendStdout'), s)
 
2947
            else:
 
2948
                if toolProcData[1] == "insert":
 
2949
                    text = toolProc.readAll()
 
2950
                    toolProcData[0].insert(text)
 
2951
                elif toolProcData[1] == "replaceSelection":
 
2952
                    text = toolProc.readAll()
 
2953
                    toolProcData[2].append(unicode(text))
2878
2954
        
2879
 
    def handleToolStderr(self):
 
2955
    def __processToolStderr(self):
2880
2956
        """
2881
2957
        Private slot to handle the readyReadStderr signal of a tool process.
2882
2958
        """
2883
2959
        # loop through all running tool processes
2884
 
        for toolProc in self.toolProcs:
2885
 
            if toolProc.canReadLineStderr():
2886
 
                pl = toolProc.arguments()
2887
 
                tool = pl[0]
2888
 
                tool.append(" - ")
2889
 
                while toolProc.canReadLineStderr():
2890
 
                    s = QString(tool)
2891
 
                    s.append(toolProc.readLineStderr())
2892
 
                    self.emit(PYSIGNAL('appendStderr'), (s,))
 
2960
        for program, toolProc, toolProcData in self.toolProcs:
 
2961
            toolProc.setReadChannel(QProcess.StandardError)
2893
2962
            
2894
 
    def handleToolExited(self):
 
2963
            while toolProc.canReadLine():
 
2964
                s = QString("%s - " % program)
 
2965
                s.append(toolProc.readLine())
 
2966
                self.emit(SIGNAL('appendStderr'), s)
 
2967
        
 
2968
    def __toolFinished(self, exitCode, exitStatus):
2895
2969
        """
2896
 
        Private slot to handle the processExited signal of a tool process.
 
2970
        Private slot to handle the finished signal of a tool process.
 
2971
        
 
2972
        @param exitCode exit code of the process (integer)
 
2973
        @param exitStatus exit status of the process (QProcess.ExitStatus)
2897
2974
        """
2898
2975
        exitedProcs = []
2899
2976
        
2900
2977
        # loop through all running tool processes
2901
 
        for toolProc in self.toolProcs:
2902
 
            if not toolProc.isRunning():
2903
 
                exitedProcs.append(toolProc)
2904
 
                
 
2978
        for program, toolProc, toolProcData in self.toolProcs:
 
2979
            if toolProc.state() == QProcess.NotRunning:
 
2980
                exitedProcs.append((program, toolProc, toolProcData))
 
2981
                if toolProcData[0] is not None:
 
2982
                    if toolProcData[1] == "replaceSelection":
 
2983
                        text = ''.join(toolProcData[2])
 
2984
                        toolProcData[0].replace(text)
 
2985
                    toolProcData[0].endUndoAction()
 
2986
        
2905
2987
        # now delete the exited procs from the list of running processes
2906
2988
        for proc in exitedProcs:
2907
2989
            self.toolProcs.remove(proc)
2908
 
            pl = proc.arguments()
2909
 
            tool = pl[0]
2910
 
            t = self.trUtf8("Process '%1' has exited.").arg(tool)
2911
 
            self.emit(PYSIGNAL('appendStdout'), (t,))
 
2990
            t = self.trUtf8("Process '%1' has exited.\n").arg(proc[0])
 
2991
            self.emit(SIGNAL('appendStdout'), t)
2912
2992
    
2913
 
    def handlePythonDoc(self):
 
2993
    def __showPythonDoc(self):
2914
2994
        """
2915
2995
        Private slot to show the Python documentation.
2916
2996
        """
2917
2997
        pythonDocDir = unicode(Preferences.getHelp("PythonDocDir"))
2918
2998
        if not pythonDocDir:
2919
2999
            if sys.platform == "win32":
2920
 
                pythonDocDir = os.environ.get("PYTHONDOCDIR", 
 
3000
                pythonDocDir = Utilities.getEnvironmentEntry("PYTHONDOCDIR", 
2921
3001
                    os.path.join(os.path.dirname(sys.executable), "doc"))
2922
3002
            else:
2923
 
                pythonDocDir = os.environ.get("PYTHONDOCDIR", 
 
3003
                pythonDocDir = Utilities.getEnvironmentEntry("PYTHONDOCDIR", 
2924
3004
                    '/usr/share/doc/packages/python/html')
2925
3005
        home = Utilities.normjoinpath(pythonDocDir, 'index.html')
2926
3006
        
2934
3014
                self.trUtf8("Documentation Missing"),
2935
3015
                self.trUtf8("""<p>The documentation starting point"""
2936
3016
                            """ "<b>%1</b>" could not be found.</p>""")\
2937
 
                    .arg(home),
2938
 
                self.trUtf8("&OK"),
2939
 
                QString.null,
2940
 
                QString.null,
2941
 
                0, -1)
 
3017
                    .arg(home))
2942
3018
            return
2943
3019
        
2944
3020
        if home.endswith(".chm"):
2945
 
            self.handleCHM(home)
 
3021
            self.__chmViewer(home)
2946
3022
        else:
2947
3023
            hvType = Preferences.getHelp("HelpViewerType")
2948
3024
            if hvType == 1:
2949
3025
                self.launchHelpViewer(home)
2950
3026
            elif hvType == 2:
2951
 
                self.handleAssistant(home)
 
3027
                self.__assistant(home)
2952
3028
            elif hvType == 3:
2953
 
                self.handleWebBrowser(home)
 
3029
                self.__webBrowser(home)
2954
3030
            else:
2955
 
                self.handleCustomViewer(home)
 
3031
                self.__customViewer(home)
2956
3032
 
2957
 
    def handleQtDoc(self):
 
3033
    def __showQtDoc(self):
2958
3034
        """
2959
3035
        Private slot to show the Qt documentation.
2960
3036
        """
2964
3040
                qtDefDocDir = ""
2965
3041
            else:
2966
3042
                qtDefDocDir = os.path.join(self.qtdir, 'doc', 'html')
2967
 
            qtDocDir = os.environ.get("QTDOCDIR", qtDefDocDir)
 
3043
            qtDocDir = Utilities.getEnvironmentEntry("QTDOCDIR", qtDefDocDir)
2968
3044
        home = Utilities.normjoinpath(qtDocDir, 'index.html')
2969
3045
        
2970
3046
        if not os.path.exists(home):
2972
3048
                self.trUtf8("Documentation Missing"),
2973
3049
                self.trUtf8("""<p>The documentation starting point"""
2974
3050
                            """ "<b>%1</b>" could not be found.</p>""")\
2975
 
                    .arg(home),
2976
 
                self.trUtf8("&OK"),
2977
 
                QString.null,
2978
 
                QString.null,
2979
 
                0, -1)
 
3051
                    .arg(home))
2980
3052
            return
2981
3053
        
2982
3054
        hvType = Preferences.getHelp("HelpViewerType")
2983
3055
        if hvType == 1:
2984
3056
            self.launchHelpViewer(home)
2985
3057
        elif hvType == 2:
2986
 
            self.handleAssistant(home)
 
3058
            self.__assistant(home)
2987
3059
        elif hvType == 3:
2988
 
            self.handleWebBrowser(home)
 
3060
            self.__webBrowser(home)
2989
3061
        else:
2990
 
            self.handleCustomViewer(home)
 
3062
            self.__customViewer(home)
2991
3063
        
2992
 
    def handleQt4Doc(self):
 
3064
    def __showQt4Doc(self):
2993
3065
        """
2994
3066
        Private slot to show the Qt4 documentation.
2995
3067
        """
2996
3068
        qt4DocDir = unicode(Preferences.getHelp("Qt4DocDir"))
2997
3069
        if not qt4DocDir:
2998
 
            if self.qt4dir is None:
2999
 
                qt4DefDocDir = ""
3000
 
            else:
3001
 
                qt4DefDocDir = os.path.join(self.qt4dir, 'doc', 'html')
3002
 
            qt4DocDir = os.environ.get("QT4DOCDIR", qt4DefDocDir)
 
3070
            qt4DocDir = Utilities.getEnvironmentEntry("QT4DOCDIR", "")
3003
3071
        home = Utilities.normjoinpath(qt4DocDir, 'index.html')
3004
3072
        
3005
3073
        if not os.path.exists(home):
3007
3075
                self.trUtf8("Documentation Missing"),
3008
3076
                self.trUtf8("""<p>The documentation starting point"""
3009
3077
                            """ "<b>%1</b>" could not be found.</p>""")\
3010
 
                    .arg(home),
3011
 
                self.trUtf8("&OK"),
3012
 
                QString.null,
3013
 
                QString.null,
3014
 
                0, -1)
3015
 
            return
3016
 
        
3017
 
        self.handleAssistant(home, version=4)
3018
 
        
3019
 
    def handleEricDoc(self):
 
3078
                    .arg(home))
 
3079
            return
 
3080
        
 
3081
        hvType = Preferences.getHelp("HelpViewerType")
 
3082
        if hvType == 1:
 
3083
            self.launchHelpViewer(home)
 
3084
        elif hvType == 2:
 
3085
            self.__assistant(home, version = 4)
 
3086
        elif hvType == 3:
 
3087
            self.__webBrowser(home)
 
3088
        else:
 
3089
            self.__customViewer(home)
 
3090
        
 
3091
    def __showPyQt4Doc(self):
 
3092
        """
 
3093
        Private slot to show the PyQt4 documentation.
 
3094
        """
 
3095
        pyqt4DocDir = unicode(Preferences.getHelp("PyQt4DocDir"))
 
3096
        if not pyqt4DocDir:
 
3097
            pyqt4DocDir = Utilities.getEnvironmentEntry("PYQT4DOCDIR", None)
 
3098
        
 
3099
        if not pyqt4DocDir:
 
3100
            KQMessageBox.warning(None,
 
3101
                self.trUtf8("Documentation"),
 
3102
                self.trUtf8("""<p>The PyQt4 documentation starting point"""
 
3103
                            """ has not been configured.</p>"""))
 
3104
            return
 
3105
        
 
3106
        home = ""
 
3107
        if pyqt4DocDir:
 
3108
            possibleHomes = [\
 
3109
                Utilities.normjoinpath(pyqt4DocDir, 'index.html'),
 
3110
                Utilities.normjoinpath(pyqt4DocDir, 'pyqt4ref.html'),
 
3111
                Utilities.normjoinpath(pyqt4DocDir, 'classes.html'),
 
3112
            ]
 
3113
            for possibleHome in possibleHomes:
 
3114
                if os.path.exists(possibleHome):
 
3115
                    home = possibleHome
 
3116
                    break
 
3117
        
 
3118
        if not home or not os.path.exists(home):
 
3119
            KQMessageBox.warning(None,
 
3120
                self.trUtf8("Documentation Missing"),
 
3121
                self.trUtf8("""<p>The documentation starting point"""
 
3122
                            """ "<b>%1</b>" could not be found.</p>""")\
 
3123
                    .arg(home))
 
3124
            return
 
3125
        
 
3126
        hvType = Preferences.getHelp("HelpViewerType")
 
3127
        if hvType == 1:
 
3128
            self.launchHelpViewer(home)
 
3129
        elif hvType == 2:
 
3130
            self.__assistant(home, version = 4)
 
3131
        elif hvType == 3:
 
3132
            self.__webBrowser(home)
 
3133
        else:
 
3134
            self.__customViewer(home)
 
3135
        
 
3136
    def __showEricDoc(self):
3020
3137
        """
3021
3138
        Private slot to show the Eric documentation.
3022
3139
        """
3028
3145
                self.trUtf8("Documentation Missing"),
3029
3146
                self.trUtf8("""<p>The documentation starting point"""
3030
3147
                            """ "<b>%1</b>" could not be found.</p>""")\
3031
 
                    .arg(home),
3032
 
                self.trUtf8("&OK"),
3033
 
                QString.null,
3034
 
                QString.null,
3035
 
                0, -1)
 
3148
                    .arg(home))
3036
3149
            return
3037
3150
        
3038
3151
        hvType = Preferences.getHelp("HelpViewerType")
3039
3152
        if hvType == 1:
3040
3153
            self.launchHelpViewer(home)
3041
3154
        elif hvType == 2:
3042
 
            self.handleAssistant(home)
 
3155
            self.__assistant(home)
3043
3156
        elif hvType == 3:
3044
 
            self.handleWebBrowser(home)
 
3157
            self.__webBrowser(home)
3045
3158
        else:
3046
 
            self.handleCustomViewer(home)
 
3159
            self.__customViewer(home)
3047
3160
        
3048
3161
    def launchHelpViewer(self, home):
3049
3162
        """
3050
 
        Private slot to start the help viewer.
 
3163
        Public slot to start the help viewer.
3051
3164
        
3052
 
        @param home filename of to be shown
 
3165
        @param home filename of file to be shown
3053
3166
        """
3054
 
        help = HelpWindow(home, '.', None, 'help viewer', 1)
3055
 
        help.setCaption(self.trUtf8('Helpviewer'))
 
3167
        if not Preferences.getHelp("SingleHelpWindow") or self.helpWindow is None:
 
3168
            help = HelpWindow(home, '.', None, 'help viewer', True)
3056
3169
 
3057
 
        if QApplication.desktop().width() > 400 and \
3058
 
           QApplication.desktop().height() > 500:
3059
 
            help.show()
 
3170
            if QApplication.desktop().width() > 400 and \
 
3171
               QApplication.desktop().height() > 500:
 
3172
                help.show()
 
3173
            else:
 
3174
                help.showMaximized()
 
3175
            
 
3176
            if Preferences.getHelp("SingleHelpWindow"):
 
3177
                self.helpWindow = help
 
3178
                self.connect(self.helpWindow, SIGNAL("helpClosed"), self.__helpClosed)
3060
3179
        else:
3061
 
            help.showMaximized()
3062
 
    
3063
 
    def handleHelpViewer(self):
 
3180
            self.helpWindow.newTab(home)
 
3181
            self.helpWindow.raise_()
 
3182
    
 
3183
    def __helpClosed(self):
 
3184
        """
 
3185
        Private slot to handle the helpClosed signal of the help window.
 
3186
        """
 
3187
        if Preferences.getHelp("SingleHelpWindow"):
 
3188
            self.helpWindow = None
 
3189
    
 
3190
    def __helpViewer(self):
3064
3191
        """
3065
3192
        Private slot to start an empty help viewer.
3066
3193
        """
3067
3194
        self.launchHelpViewer("")   
3068
3195
 
3069
 
    def handlePreferences(self):
 
3196
    def __preferences(self, pageName = None):
3070
3197
        """
3071
3198
        Private slot to set the preferences.
 
3199
        
 
3200
        @param pageName name of the configuration page to show (string or QString)
3072
3201
        """
3073
 
        dlg = ConfigurationDialog(self, 'Configuration', 1)
3074
 
        dlg.exec_loop()
3075
 
        qApp.processEvents()
 
3202
        dlg = ConfigurationDialog(self, 'Configuration', True)
 
3203
        self.connect(dlg, SIGNAL('preferencesChanged'), 
 
3204
                     self.__preferencesChanged)
 
3205
        if pageName is not None:
 
3206
            dlg.showConfigurationPageByName(pageName)
 
3207
        dlg.exec_()
 
3208
        QApplication.processEvents()
3076
3209
        if dlg.result() == QDialog.Accepted:
3077
3210
            dlg.setPreferences()
3078
3211
            Preferences.syncPreferences()
3079
 
            self.handlePreferencesChanged()
3080
 
            self.emit(PYSIGNAL('preferencesChanged'), ())
3081
 
        
3082
 
    def handlePreferencesChanged(self):
3083
 
        """
3084
 
        Private method to handle a change of the preferences.
3085
 
        """
 
3212
            self.__preferencesChanged()
 
3213
        
 
3214
    def __preferencesChanged(self):
 
3215
        """
 
3216
        Private slot to handle a change of the preferences.
 
3217
        """
 
3218
        self.__setStyle()
 
3219
        
3086
3220
        if Preferences.getUI("SingleApplicationMode"):
3087
3221
            if self.SAServer is None:
3088
 
                self.SAServer = E3SingleApplicationServer()
 
3222
                self.SAServer = E4SingleApplicationServer()
3089
3223
        else:
3090
3224
            if self.SAServer is not None:
3091
3225
                self.SAServer.shutdown()
3092
3226
                self.SAServer = None
3093
3227
        
3094
 
        if not Preferences.getUI("CaptionShowsFilename"):
3095
 
            self.setWindowCaption(editor="")
3096
 
            self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
3097
 
        else:
3098
 
            self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
 
3228
        if Preferences.getUI("UseIconProvider"):
 
3229
            if self.iconProvider is None:
 
3230
                # Generate and set our icon provider for KQFileDialog
 
3231
                self.iconProvider = E4IconProvider()
 
3232
                KQFileDialog.setIconProvider(self.iconProvider)
 
3233
        else:
 
3234
            if self.iconProvider is not None:
 
3235
                self.iconProvider = None
 
3236
                KQFileDialog.setIconProvider(None)
 
3237
        
 
3238
        self.maxEditorPathLen = Preferences.getUI("CaptionFilenameLength")
 
3239
        self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
 
3240
        if not self.captionShowsFilename:
 
3241
            self.__setWindowCaption(editor = "")
 
3242
        else:
3099
3243
            aw = self.viewmanager.activeWindow()
3100
3244
            fn = aw and aw.getFileName() or None
3101
3245
            if fn:
3102
 
                self.setWindowCaption(editor=unicode(fn))
 
3246
                self.__setWindowCaption(editor = unicode(fn))
3103
3247
            else:
3104
 
                self.setWindowCaption(editor="")
3105
 
        
3106
 
    def handleReloadAPIs(self):
3107
 
        """
3108
 
        Public slot to reload the api information.
3109
 
        """
3110
 
        self.emit(PYSIGNAL('reloadAPIs'), ())
3111
 
        
3112
 
    def handleConfigViewProfiles(self):
3113
 
        """
3114
 
        Private method to configure the various view profiles.
 
3248
                self.__setWindowCaption(editor = "")
 
3249
        
 
3250
        self.qtdir = Preferences.getQtDir()
 
3251
        self.qt4dir = Preferences.getQt4Dir()
 
3252
        
 
3253
        self.performVersionCheck(False)
 
3254
        
 
3255
        self.emit(SIGNAL('preferencesChanged'))
 
3256
        
 
3257
    def __reloadAPIs(self):
 
3258
        """
 
3259
        Private slot to reload the api information.
 
3260
        """
 
3261
        self.emit(SIGNAL('reloadAPIs'))
 
3262
        
 
3263
    def __showExternalTools(self):
 
3264
        """
 
3265
        Private slot to display a dialog show a list of external tools used by eric4.
 
3266
        """
 
3267
        self.programsDialog.show()
 
3268
        
 
3269
    def __configViewProfiles(self):
 
3270
        """
 
3271
        Private slot to configure the various view profiles.
3115
3272
        """
3116
3273
        dlg = ViewProfileDialog(self.profiles,
3117
3274
            not self.embeddedShell, not self.embeddedFileBrowser)
3118
 
        if dlg.exec_loop() == QDialog.Accepted:
 
3275
        if dlg.exec_() == QDialog.Accepted:
3119
3276
            self.profiles = dlg.getProfiles()
3120
3277
            Preferences.setUI("ViewProfiles", self.profiles)
3121
3278
            if self.currentProfile == "edit":
3122
 
                self.handleSetEditProfile(False)
 
3279
                self.__setEditProfile(False)
3123
3280
            elif self.currentProfile == "debug":
3124
 
                self.handleSetDebugProfile(False)
 
3281
                self.setDebugProfile(False)
3125
3282
        
3126
 
    def handleConfigShortcuts(self):
 
3283
    def __configShortcuts(self):
3127
3284
        """
3128
3285
        Private slot to configure the keyboard shortcuts.
3129
3286
        """
3130
3287
        self.shortcutsDialog.show()
3131
3288
        
3132
 
    def handleExportShortcuts(self):
 
3289
    def __exportShortcuts(self):
3133
3290
        """
3134
3291
        Private slot to export the keyboard shortcuts.
3135
3292
        """
3136
 
        selectedFilter = QString('')
 
3293
        selectedFilter = QString("")
3137
3294
        fn = KQFileDialog.getSaveFileName(\
3138
 
            QString.null,
3139
 
            self.trUtf8("Eric3 keyboard shortcut file (*.e3k);;"
3140
 
                "Compressed Eric3 keyboard shortcut file (*.e3kz)"),
3141
 
            None, None,
 
3295
            None,
3142
3296
            self.trUtf8("Export Keyboard Shortcuts"),
3143
 
            selectedFilter, 1)
3144
 
            
 
3297
            QString(),
 
3298
            self.trUtf8("eric4 keyboard shortcut file (*.e4k);;"
 
3299
                "Compressed eric4 keyboard shortcut file (*.e4kz)"),
 
3300
            selectedFilter,
 
3301
            QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
 
3302
        
3145
3303
        if fn.isEmpty():
3146
3304
            return
3147
 
            
3148
 
        ext = QFileInfo(fn).extension()
 
3305
        
 
3306
        ext = QFileInfo(fn).suffix()
3149
3307
        if ext.isEmpty():
3150
3308
            ex = selectedFilter.section('(*',1,1).section(')',0,0)
3151
3309
            if not ex.isEmpty():
3152
3310
                fn.append(ex)
3153
3311
        fn = unicode(fn)
3154
 
            
 
3312
        
3155
3313
        res = Preferences.exportShortcuts(fn)
3156
3314
        if not res:
3157
3315
            KQMessageBox.critical(None,
3158
3316
                self.trUtf8("Export Keyboard Shortcuts"),
3159
 
                self.trUtf8("<p>The keyboard shortcuts could not be written to file <b>%1</b>.</p>").arg(fn),
3160
 
                self.trUtf8("&Abort"))
 
3317
                self.trUtf8("<p>The keyboard shortcuts could not be written to file"
 
3318
                    " <b>%1</b>.</p>").arg(fn))
3161
3319
 
3162
 
    def handleImportShortcuts(self):
 
3320
    def __importShortcuts(self):
3163
3321
        """
3164
3322
        Private slot to import the keyboard shortcuts.
3165
3323
        """
3166
3324
        fn = KQFileDialog.getOpenFileName(\
3167
 
            QString.null,
3168
 
            self.trUtf8("Eric3 keyboard shortcut file (*.e3k *.e3kz)"),
3169
 
            None, None,
 
3325
            None,
3170
3326
            self.trUtf8("Import Keyboard Shortcuts"),
3171
 
            None, 1)
3172
 
            
 
3327
            QString(),
 
3328
            self.trUtf8("eric4 keyboard shortcut file (*.e4k *.e4kz);;"
 
3329
                "eric3 keyboard shortcut file (*.e3k *.e3kz)"))
 
3330
        
3173
3331
        if fn.isEmpty():
3174
3332
            return
3175
 
            
 
3333
        
3176
3334
        fn = unicode(fn)
3177
 
            
 
3335
        
3178
3336
        Preferences.importShortcuts(fn)
3179
3337
 
3180
 
    def handleNewProject(self):
3181
 
        """
3182
 
        Public slot to handle the NewProject signal.
3183
 
        """
3184
 
        self.setWindowCaption(project = self.project.name)
 
3338
    def __newProject(self):
 
3339
        """
 
3340
        Private slot to handle the NewProject signal.
 
3341
        """
 
3342
        self.__setWindowCaption(project = self.project.name)
3185
3343
        
3186
 
    def handleProjectOpened(self):
3187
 
        """
3188
 
        Public slot to handle the projectOpened signal.
3189
 
        """
3190
 
        self.setWindowCaption(project = self.project.name)
3191
 
        cap = self.getDebugServer().getClientCapabilities(self.project.pdata["PROGLANGUAGE"][0])
 
3344
    def __projectOpened(self):
 
3345
        """
 
3346
        Private slot to handle the projectOpened signal.
 
3347
        """
 
3348
        self.__setWindowCaption(project = self.project.name)
 
3349
        cap = e4App().getObject("DebugServer")\
 
3350
            .getClientCapabilities(self.project.pdata["PROGLANGUAGE"][0])
3192
3351
        self.utProjectAct.setEnabled(cap & HasUnittest)
3193
3352
        self.utProjectOpen = cap & HasUnittest
3194
3353
        
3195
 
    def handleProjectClosed(self):
3196
 
        """
3197
 
        Public slot to handle the projectClosed signal.
3198
 
        """
3199
 
        self.setWindowCaption(project = "")
3200
 
        self.utProjectAct.setEnabled(0)
 
3354
    def __projectClosed(self):
 
3355
        """
 
3356
        Private slot to handle the projectClosed signal.
 
3357
        """
 
3358
        self.__setWindowCaption(project = "")
 
3359
        self.utProjectAct.setEnabled(False)
3201
3360
        if not self.utEditorOpen:
3202
 
            self.utRestartAct.setEnabled(0)
3203
 
        self.utProjectOpen = 0
3204
 
 
3205
 
    def handleProgramChange(self,fn):
 
3361
            self.utRestartAct.setEnabled(False)
 
3362
        self.utProjectOpen = False
 
3363
        
 
3364
    def __programChange(self, fn):
3206
3365
        """
3207
 
        Public slot to handle the programChange signal.
 
3366
        Private slot to handle the programChange signal.
3208
3367
        
3209
3368
        This primarily is here to set the currentProg variable.
3210
3369
        
3211
 
        @param fn filename to be set as current prog (string)
 
3370
        @param fn filename to be set as current prog (QString)
3212
3371
        """
3213
3372
        # Delete the old program if there was one.
3214
3373
        if self.currentProg is not None:
3215
3374
            del self.currentProg
3216
3375
 
3217
 
        self.currentProg = os.path.normpath(fn)
 
3376
        self.currentProg = os.path.normpath(unicode(fn))
3218
3377
        
3219
 
    def handleLastEditorClosed(self):
3220
 
        """
3221
 
        Public slot to handle the lastEditorClosed signal.
3222
 
        """
3223
 
        self.extrasMenu.setItemEnabled(self.wizardsMenuItem, 0)
3224
 
        self.menuBar().setItemEnabled(self.refactoringMenuItem, 0)
3225
 
        self.scriptsExecDocAct.setEnabled(0)
3226
 
        self.utScriptAct.setEnabled(0)
3227
 
        self.utEditorOpen = 0
 
3378
    def __lastEditorClosed(self):
 
3379
        """
 
3380
        Private slot to handle the lastEditorClosed signal.
 
3381
        """
 
3382
        self.wizardsMenuAct.setEnabled(False)
 
3383
        self.refactoringMenuAct.setEnabled(False)
 
3384
        self.scriptsExecDocAct.setEnabled(False)
 
3385
        self.utScriptAct.setEnabled(False)
 
3386
        self.utEditorOpen = False
3228
3387
        if not self.utProjectOpen:
3229
 
            self.utRestartAct.setEnabled(0)
3230
 
        self.setWindowCaption(editor="")
3231
 
        
3232
 
    def handleEditorOpened(self, fn):
3233
 
        """
3234
 
        Public slot to handle the editorOpened signal.
3235
 
        
3236
 
        @param fn filename of the opened editor (string)
3237
 
        """
3238
 
        self.extrasMenu.setItemEnabled(self.wizardsMenuItem, 1)
3239
 
        self.menuBar().setItemEnabled(self.refactoringMenuItem, 1)
3240
 
        self.scriptsExecDocAct.setEnabled(1)
3241
 
        
3242
 
        if fn:
 
3388
            self.utRestartAct.setEnabled(False)
 
3389
        self.__setWindowCaption(editor = "")
 
3390
        
 
3391
    def __editorOpened(self, fn):
 
3392
        """
 
3393
        Private slot to handle the editorOpened signal.
 
3394
        
 
3395
        @param fn filename of the opened editor (QString)
 
3396
        """
 
3397
        fn = unicode(fn)
 
3398
        self.wizardsMenuAct.setEnabled(True)
 
3399
        self.refactoringMenuAct.setEnabled(True)
 
3400
        self.scriptsExecDocAct.setEnabled(True)
 
3401
        
 
3402
        if fn and unicode(fn) != "None":
3243
3403
            if fn.endswith('.py') or self.viewmanager.getOpenEditor(fn).isPyFile():
3244
 
                self.utScriptAct.setEnabled(1)
3245
 
                self.utEditorOpen = 1
 
3404
                self.utScriptAct.setEnabled(True)
 
3405
                self.utEditorOpen = True
3246
3406
            elif fn.endswith('.rb'):
3247
 
                cap = self.getDebugServer().getClientCapabilities('Ruby')
 
3407
                cap = e4App().getObject("DebugServer").getClientCapabilities('Ruby')
3248
3408
                self.utScriptAct.setEnabled(cap & HasUnittest)
3249
3409
                self.utEditorOpen = cap & HasUnittest
3250
3410
        
3251
 
    def checkActions(self, editor):
 
3411
    def __checkActions(self, editor):
3252
3412
        """
3253
3413
        Private slot to check some actions for their enable/disable status.
3254
3414
        
3262
3422
        if fn and ((os.path.splitext(fn)[1] in ['.py', '.rb']) or editor.isPyFile()):
3263
3423
            ext = os.path.splitext(fn)[1]
3264
3424
            if ext == '.py':
3265
 
                cap = self.getDebugServer().getClientCapabilities('Python')
 
3425
                cap = e4App().getObject("DebugServer").getClientCapabilities('Python')
3266
3426
            elif ext == '.rb':
3267
 
                cap = self.getDebugServer().getClientCapabilities('Ruby')
 
3427
                cap = e4App().getObject("DebugServer").getClientCapabilities('Ruby')
3268
3428
            else:
3269
3429
                cap = 0
3270
3430
            self.utScriptAct.setEnabled(cap & HasUnittest)
3271
3431
        else:
3272
 
            self.utScriptAct.setEnabled(0)
 
3432
            self.utScriptAct.setEnabled(False)
3273
3433
    
3274
 
    def writeTasks(self):
 
3434
    def __writeTasks(self):
3275
3435
        """
3276
 
        Public method to write the tasks data to an XML file (.e3t).
 
3436
        Private slot to write the tasks data to an XML file (.e4t).
3277
3437
        """
3278
3438
        try:
3279
 
            fn = os.path.join(Utilities.getConfigDir(), "eric3tasks.e3t")
 
3439
            fn = os.path.join(Utilities.getConfigDir(), "eric4tasks.e4t")
3280
3440
            f = open(fn, "wb")
3281
3441
            
3282
 
            TasksWriter(f, 0).writeXML()
 
3442
            TasksWriter(f, False).writeXML()
3283
3443
            
3284
3444
            f.close()
3285
3445
            
3287
3447
            KQMessageBox.critical(None,
3288
3448
                self.trUtf8("Save tasks"),
3289
3449
                self.trUtf8("<p>The tasks file <b>%1</b> could not be written.</p>")
3290
 
                    .arg(fn),
3291
 
                self.trUtf8("&Abort"))
 
3450
                    .arg(fn))
3292
3451
        
3293
 
    def readTasks(self):
 
3452
    def __readTasks(self):
3294
3453
        """
3295
 
        Private method to read in the tasks file (.e3t)
 
3454
        Private slot to read in the tasks file (.e4t)
3296
3455
        """
3297
3456
        try:
3298
 
            fn = os.path.join(Utilities.getConfigDir(), "eric3tasks.e3t")
 
3457
            fn = os.path.join(Utilities.getConfigDir(), "eric4tasks.e4t")
3299
3458
            if not os.path.exists(fn):
3300
3459
                return
3301
3460
            f = open(fn, "rb")
3305
3464
        except IOError:
3306
3465
            KQMessageBox.critical(None,
3307
3466
                self.trUtf8("Read tasks"),
3308
 
                self.trUtf8("<p>The tasks file <b>%1</b> could not be read.</p>").arg(fn),
3309
 
                self.trUtf8("&Abort"))
 
3467
                self.trUtf8("<p>The tasks file <b>%1</b> could not be read.</p>").arg(fn))
3310
3468
            return
3311
3469
            
3312
3470
        # now read the file
3313
3471
        if line.startswith('<?xml'):
3314
3472
            parser = make_parser(dtdLine.startswith("<!DOCTYPE"))
3315
 
            handler = TasksHandler(taskViewer=self.taskViewer)
 
3473
            handler = TasksHandler(taskViewer = self.taskViewer)
3316
3474
            er = XMLEntityResolver()
3317
3475
            eh = XMLErrorHandler()
3318
3476
            
3329
3487
            except IOError:
3330
3488
                KQMessageBox.critical(None,
3331
3489
                    self.trUtf8("Read tasks"),
3332
 
                    self.trUtf8("<p>The tasks file <b>%1</b> could not be read.</p>").arg(fn),
3333
 
                    self.trUtf8("&Abort"))
 
3490
                    self.trUtf8("<p>The tasks file <b>%1</b> could not be read.</p>")\
 
3491
                        .arg(fn))
3334
3492
                return
3335
3493
            except XMLFatalParseError:
3336
3494
                pass
3339
3497
        else:
3340
3498
            KQMessageBox.critical(None,
3341
3499
                self.trUtf8("Read tasks"),
3342
 
                self.trUtf8("<p>The tasks file <b>%1</b> has an unsupported format.</p>").arg(fn),
3343
 
                self.trUtf8("&Abort"))
3344
 
    
3345
 
    def writeTemplates(self, filename=None):
3346
 
        """
3347
 
        Public method to write the templates data to an XML file (.e3c).
3348
 
        
3349
 
        @param filename name of a templates file to read (string or QString)
3350
 
        """
3351
 
        try:
3352
 
            if filename is None:
3353
 
                fn = os.path.join(Utilities.getConfigDir(), "eric3templates.e3c")
3354
 
            else:
3355
 
                fn = unicode(filename)
3356
 
            f = open(fn, "wb")
3357
 
            
3358
 
            TemplatesWriter(f).writeXML()
3359
 
            
3360
 
            f.close()
3361
 
            
3362
 
        except IOError:
3363
 
            KQMessageBox.critical(None,
3364
 
                self.trUtf8("Save templates"),
3365
 
                self.trUtf8("<p>The templates file <b>%1</b> could not be written.</p>")
3366
 
                    .arg(fn),
3367
 
                self.trUtf8("&Abort"))
3368
 
        
3369
 
    def readTemplates(self, filename=None):
3370
 
        """
3371
 
        Public method to read in the templates file (.e3c)
3372
 
        
3373
 
        @param filename name of a templates file to read (string or QString)
3374
 
        """
3375
 
        try:
3376
 
            if filename is None:
3377
 
                fn = os.path.join(Utilities.getConfigDir(), "eric3templates.e3c")
3378
 
                if not os.path.exists(fn):
3379
 
                    return
3380
 
            else:
3381
 
                fn = unicode(filename)
3382
 
            f = open(fn, "rb")
3383
 
            line = f.readline()
3384
 
            dtdLine = f.readline()
3385
 
            f.close()
3386
 
        except IOError:
3387
 
            KQMessageBox.critical(None,
3388
 
                self.trUtf8("Read templates"),
3389
 
                self.trUtf8("<p>The templates file <b>%1</b> could not be read.</p>")
3390
 
                    .arg(fn),
3391
 
                self.trUtf8("&Abort"))
3392
 
            return
3393
 
            
3394
 
        # now read the file
3395
 
        if line.startswith('<?xml'):
3396
 
            parser = make_parser(dtdLine.startswith("<!DOCTYPE"))
3397
 
            handler = TemplatesHandler(templateViewer = self.templateViewer)
3398
 
            er = XMLEntityResolver()
3399
 
            eh = XMLErrorHandler()
3400
 
            
3401
 
            parser.setContentHandler(handler)
3402
 
            parser.setEntityResolver(er)
3403
 
            parser.setErrorHandler(eh)
3404
 
            
3405
 
            try:
3406
 
                f = open(fn, "rb")
3407
 
                try:
3408
 
                    parser.parse(f)
3409
 
                finally:
3410
 
                    f.close()
3411
 
            except IOError:
3412
 
                KQMessageBox.critical(None,
3413
 
                    self.trUtf8("Read templates"),
3414
 
                    self.trUtf8("<p>The templates file <b>%1</b> could not be read.</p>")
3415
 
                        .arg(fn),
3416
 
                    self.trUtf8("&Abort"))
3417
 
                return
3418
 
            except XMLFatalParseError:
3419
 
                pass
3420
 
                
3421
 
            eh.showParseMessages()
3422
 
        else:
3423
 
            KQMessageBox.critical(None,
3424
 
                self.trUtf8("Read templates"),
3425
 
                self.trUtf8("<p>The templates file <b>%1</b> has an unsupported format.</p>")
3426
 
                    .arg(fn),
3427
 
                self.trUtf8("&Abort"))
 
3500
                self.trUtf8("<p>The tasks file <b>%1</b> has an unsupported format.</p>")\
 
3501
                    .arg(fn))
3428
3502
    
3429
3503
    ##########################################################
3430
3504
    ## Below are slots needed by the scripts menu
3431
3505
    ##########################################################
3432
3506
    
3433
 
    def handleLoadScript(self):
 
3507
    def __loadScript(self):
3434
3508
        """
3435
3509
        Private slot to handle the load script menu action.
3436
3510
        """
3437
3511
        dlg = LoadScriptDialog()
3438
 
        if dlg.exec_loop() == QDialog.Accepted:
 
3512
        if dlg.exec_() == QDialog.Accepted:
3439
3513
            name, fname, execute, delete = dlg.getData()
3440
3514
            if fname == "":
3441
3515
                return      # no file name entered -> ignore the action
3442
 
                
 
3516
            
3443
3517
            if name == "":
3444
3518
                # empty script name -> execute it once and delete it
3445
 
                execute = 1
3446
 
                delete = 1
 
3519
                execute = True
 
3520
                delete = True
3447
3521
                name = "temp_script"
3448
 
                
 
3522
            
3449
3523
            try:
3450
3524
                f = open(fname)
3451
3525
                code = f.read()
3457
3531
                        'Problem: %2</p>')
3458
3532
                        .arg(fname).arg(unicode(e)))
3459
3533
                return
3460
 
                
 
3534
            
3461
3535
            try:
3462
3536
                self.scriptManager.addScript(name, code)
3463
3537
            except CompilationError, e:
3467
3541
                        'Problem: %2</p>')
3468
3542
                        .arg(fname).arg(unicode(e)))
3469
3543
                return
3470
 
                
 
3544
            
3471
3545
            if execute:
3472
3546
                oldpwd = os.getcwd()
3473
3547
                os.chdir(os.path.dirname(fname))
3476
3550
                except ExecutionError, e:
3477
3551
                    KQMessageBox.critical(self,
3478
3552
                        self.trUtf8('Error loading script'),
3479
 
                        self.trUtf8('<p>The script file <b>%1</b> could not be loaded.<br>'
3480
 
                            'Problem: %2</p>')
 
3553
                        self.trUtf8('<p>The script file <b>%1</b> could not be'
 
3554
                            ' loaded.<br>Problem: %2</p>')
3481
3555
                            .arg(fname).arg(unicode(e)))
3482
 
                    delete = 1
 
3556
                    delete = True
3483
3557
                os.chdir(oldpwd)
3484
 
                    
 
3558
            
3485
3559
            if delete:
3486
3560
                self.scriptManager.deleteScript(name)
3487
3561
    
3488
 
    def handleDeleteScript(self):
 
3562
    def __deleteScript(self):
3489
3563
        """
3490
 
        Public method to delete a script.
 
3564
        Private slot to delete a script.
3491
3565
        """
3492
3566
        name, ok = self.scriptManager.getScriptName()
3493
3567
        if ok and not name.isEmpty():
3494
3568
            self.scriptManager.deleteScript(name)
3495
3569
    
3496
 
    def handleExecuteScript(self):
 
3570
    def __executeScript(self):
3497
3571
        """
3498
 
        Public method to execute a script.
 
3572
        Private slot to execute a script.
3499
3573
        """
3500
3574
        name, ok = self.scriptManager.getScriptName()
3501
3575
        if ok and not name.isEmpty():
3508
3582
                        'Problem: %2</p>')
3509
3583
                        .arg(name).arg(unicode(e)))
3510
3584
        
3511
 
    def handleExecuteDocumentAsScript(self):
 
3585
    def __executeDocumentAsScript(self):
3512
3586
        """
3513
3587
        Private slot to handle the execute document as script menu action.
3514
3588
        """
3529
3603
                    'Problem: %1</p>')
3530
3604
                    .arg(unicode(e)))
3531
3605
     
3532
 
    def handleFirstScriptAdded(self):
 
3606
    def __firstScriptAdded(self):
3533
3607
        """
3534
3608
        Private slot to handle the firstScriptAdded signal
3535
3609
        """
3536
 
        self.scriptsDeleteAct.setEnabled(1)
3537
 
        self.scriptsExecAct.setEnabled(1)
 
3610
        self.scriptsDeleteAct.setEnabled(True)
 
3611
        self.scriptsExecAct.setEnabled(True)
3538
3612
        
3539
 
    def handleLastScriptDeleted(self):
 
3613
    def __lastScriptDeleted(self):
3540
3614
        """
3541
3615
        Private slot to handle the lastScriptDeleted signal
3542
3616
        """
3543
 
        self.scriptsDeleteAct.setEnabled(0)
3544
 
        self.scriptsExecAct.setEnabled(0)
 
3617
        self.scriptsDeleteAct.setEnabled(False)
 
3618
        self.scriptsExecAct.setEnabled(False)
3545
3619
 
3546
3620
    #################################################################
3547
3621
    ## Drag and Drop Support
3553
3627
        
3554
3628
        @param event the drag enter event (QDragEnterEvent)
3555
3629
        """
3556
 
        self.inDragDrop = QUriDrag.canDecode(event)
3557
 
        event.accept(self.inDragDrop)
 
3630
        self.inDragDrop = event.mimeData().hasUrls()
 
3631
        if self.inDragDrop:
 
3632
            event.acceptProposedAction()
3558
3633
        
3559
3634
    def dragMoveEvent(self, event):
3560
3635
        """
3562
3637
        
3563
3638
        @param event the drag move event (QDragMoveEvent)
3564
3639
        """
3565
 
        event.accept(self.inDragDrop)
 
3640
        if self.inDragDrop:
 
3641
            event.acceptProposedAction()
3566
3642
        
3567
3643
    def dragLeaveEvent(self, event):
3568
3644
        """
3571
3647
        @param event the drag leave event (QDragLeaveEvent)
3572
3648
        """
3573
3649
        if self.inDragDrop:
3574
 
            self.inDragDrop = 0
 
3650
            self.inDragDrop = False
3575
3651
        
3576
3652
    def dropEvent(self, event):
3577
3653
        """
3579
3655
        
3580
3656
        @param event the drop event (QDropEvent)
3581
3657
        """
3582
 
        if QUriDrag.canDecode(event):
3583
 
            flist = QStringList()
3584
 
            ok = QUriDrag.decodeLocalFiles(event, flist)
3585
 
            if ok:
3586
 
                event.acceptAction()
3587
 
                for fname in flist:
3588
 
                    if not QFileInfo(fname).isDir():
3589
 
                        self.viewmanager.handlePythonFile(unicode(fname))
 
3658
        if event.mimeData().hasUrls():
 
3659
            event.acceptProposedAction()
 
3660
            for url in event.mimeData().urls():
 
3661
                fname = url.toLocalFile()
 
3662
                if not fname.isEmpty():
 
3663
                    if QFileInfo(fname).isFile():
 
3664
                        self.viewmanager.openSourceFile(unicode(fname))
3590
3665
                    else:
3591
3666
                        KQMessageBox.information(None,
3592
3667
                            self.trUtf8("Drop Error"),
3593
3668
                            self.trUtf8("""<p><b>%1</b> is not a file.</p>""")
3594
 
                                .arg(fname),
3595
 
                            self.trUtf8("&OK"),
3596
 
                            QString.null,
3597
 
                            QString.null,
3598
 
                            0, -1)
3599
 
            del flist   # explicit destruction
 
3669
                                .arg(fname))
3600
3670
        
3601
 
        self.inDragDrop = 0
 
3671
        self.inDragDrop = False
3602
3672
    
3603
3673
    ##########################################################
3604
3674
    ## Below are methods needed for shutting down the IDE
3612
3682
        
3613
3683
        @param event close event (QCloseEvent)
3614
3684
        """
3615
 
        if self.shutdown():
 
3685
        if self.__shutdown():
3616
3686
            event.accept()
 
3687
            if not self.inCloseEevent:
 
3688
                self.inCloseEevent = True
 
3689
                QTimer.singleShot(0, e4App().closeAllWindows)
3617
3690
        else:
3618
3691
            event.ignore()
3619
3692
 
3620
 
    def shutdown(self):
 
3693
    def __shutdown(self):
3621
3694
        """
3622
3695
        Private method to perform all neccessary steps to close down the IDE.
3623
3696
        
3624
3697
        @return flag indicating success
3625
3698
        """
3626
3699
        if self.shutdownCalled:
3627
 
            return 1
 
3700
            return True
3628
3701
            
3629
3702
        if not self.project.closeProject():
3630
 
            return 0
 
3703
            return False
3631
3704
        
3632
3705
        if not self.viewmanager.closeViewManager():
3633
 
            return 0
 
3706
            return False
3634
3707
        
3635
3708
        self.shell.closeShell()
3636
3709
        
3637
 
        self.writeTasks()
3638
 
        self.writeTemplates()
 
3710
        self.__writeTasks()
 
3711
        self.templateViewer.writeTemplates()
3639
3712
        
3640
 
        if not self.dbg.shutdownServer():
3641
 
            return 0
 
3713
        if not self.debuggerUI.shutdownServer():
 
3714
            return False
 
3715
        self.debuggerUI.shutdown()
3642
3716
        
3643
3717
        if self.SAServer is not None:
3644
3718
            self.SAServer.shutdown()
3645
3719
            self.SAServer = None
3646
3720
        
3647
 
        s = self.geometry()
3648
 
        p = self.frameGeometry()
3649
 
        Preferences.setGeometry("MainGeometry", [p.x(),p.y(),s.width(),s.height()])
3650
 
        if self.layout == 0:            # splitters
3651
 
            if self.embeddedShell:
3652
 
                h = self.hSplitter.sizes()
3653
 
                v = self.vSplitter.sizes()
3654
 
                Preferences.setGeometry("MainSplitter0", h + v)
3655
 
            else:
3656
 
                v = self.vSplitter.sizes()
3657
 
                h1 = self.hSplitter1.sizes()
3658
 
                h2 = self.hSplitter2.sizes()
3659
 
                Preferences.setGeometry("MainSplitter1", v + h1 + h2)
3660
 
        elif self.layout == 1:          # dockable windows
3661
 
            if self.embeddedShell and self.embeddedFileBrowser:
3662
 
                Preferences.setMainDockLayout(self, 0)
3663
 
            elif not self.embeddedFileBrowser and not self.embeddedShell:
3664
 
                Preferences.setMainDockLayout(self, 3)
3665
 
            elif not self.embeddedShell:
3666
 
                Preferences.setMainDockLayout(self, 1)
3667
 
            else:
3668
 
                Preferences.setMainDockLayout(self, 2)
3669
 
        elif self.layout == 2:          # floating windows
 
3721
        Preferences.setGeometry("MainGeometry", self.saveGeometry())
 
3722
        if self.layout == "FloatingWindows":      # floating windows
3670
3723
            windows = {
3671
3724
                "ProjectBrowser": self.projectBrowser,
3672
 
                "SBV": self.sbv,
 
3725
                "DebugViewer": self.debugViewer,
3673
3726
                "LogViewer": self.logViewer,
3674
3727
                "Shell": self.shell,
3675
3728
                "FileBrowser" : self.browser,
3680
3733
                del windows["Shell"]
3681
3734
            if self.embeddedFileBrowser:
3682
3735
                del windows["FileBrowser"]
3683
 
            [Preferences.setGeometry(name, self.getFloatingGeometry(w))
3684
 
                for name, w in windows.items()]
3685
3736
            for window, i in zip(self.windows, range(len(self.windows))):
3686
3737
                if window is not None:
3687
3738
                    self.profiles[self.currentProfile][2][i] = \
3688
 
                        self.getFloatingGeometry(window)[:4]
 
3739
                        str(window.saveGeometry())
3689
3740
 
3690
3741
        self.browser.saveToplevelDirs()
3691
3742
        
 
3743
        self.__saveCurrentViewProfile(True)
3692
3744
        Preferences.savePreferences()
3693
 
        Preferences.saveToolbarSettings(self, self.toolbars)
3694
 
        Preferences.saveToolsMenu(self.toollist)
3695
 
        self.shutdownCalled = 1
3696
 
        return 1
3697
 
 
3698
 
    ###################################
 
3745
        Preferences.saveToolGroups(self.toolGroups, self.currentToolGroup)
 
3746
        self.shutdownCalled = True
 
3747
        return True
 
3748
 
 
3749
    ##############################################
 
3750
    ## Below are methods to check for new versions
 
3751
    ##############################################
 
3752
 
 
3753
    def performVersionCheck(self, manual = True,  alternative = 0):
 
3754
        """
 
3755
        Public method to check the internet for an eric4 update.
 
3756
        
 
3757
        @param manual flag indicating an invocation via the menu (boolean)
 
3758
        """
 
3759
        if not manual:
 
3760
            if Version.startswith("@@"):
 
3761
                return
 
3762
            else:
 
3763
                period = Preferences.getUI("PerformVersionCheck")
 
3764
                if period == 0:
 
3765
                    return
 
3766
                elif period in [2, 3, 4]:
 
3767
                    lastCheck = Preferences.Prefs.settings.value(\
 
3768
                        "Updates/LastCheckDate", QVariant(QDate(1970, 1, 1))).toDate()
 
3769
                    if lastCheck.isValid():
 
3770
                        now = QDate.currentDate()
 
3771
                        if period == 2 and lastCheck.day() == now.day():
 
3772
                            # daily
 
3773
                            return
 
3774
                        elif period == 3 and lastCheck.daysTo(now) < 7:
 
3775
                            # weekly
 
3776
                            return
 
3777
                        elif period == 4 and lastCheck.month() == now.month():
 
3778
                            # monthly
 
3779
                            return
 
3780
        
 
3781
        self.__inVersionCheck = True
 
3782
        self.manualUpdatesCheck = manual
 
3783
        if self.http is None:
 
3784
            self.http = QHttp()
 
3785
            self.connect(self.http, SIGNAL("done(bool)"), self.__versionsDownloadDone)
 
3786
        
 
3787
        if Preferences.getUI("UseProxy"):
 
3788
            host = Preferences.getUI("ProxyHost")
 
3789
            if host.isEmpty():
 
3790
                KQMessageBox.critical(None,
 
3791
                    self.trUtf8("Error during updates check"),
 
3792
                    self.trUtf8("""Proxy usage was activated"""
 
3793
                                """ but no proxy host configured."""))
 
3794
                return
 
3795
            else:
 
3796
                self.http.setProxy(host,
 
3797
                    Preferences.getUI("ProxyPort"),
 
3798
                    Preferences.getUI("ProxyUser"),
 
3799
                    Preferences.getUI("ProxyPassword"))
 
3800
        
 
3801
        self.httpAlternative = alternative
 
3802
        self.__versionCheckCanceled = False
 
3803
        if manual:
 
3804
            if self.__versionCheckProgress is None:
 
3805
                self.__versionCheckProgress = \
 
3806
                    KQProgressDialog("", self.trUtf8("&Cancel"),  
 
3807
                                     0,  len(self.__httpAlternatives),  self)
 
3808
                self.__versionCheckProgress.setMinimumDuration(0)
 
3809
                self.connect(self.__versionCheckProgress, SIGNAL("canceled()"), 
 
3810
                    self.__versionsDownloadCanceled)
 
3811
            self.__versionCheckProgress.setLabelText(self.trUtf8("Trying host %1")\
 
3812
                .arg(self.__httpAlternatives[alternative]["host"]))
 
3813
            self.__versionCheckProgress.setValue(alternative)
 
3814
        self.http.setHost(self.__httpAlternatives[alternative]["host"], 
 
3815
                          self.__httpAlternatives[alternative]["port"])
 
3816
        self.http.get(self.__httpAlternatives[alternative]["url"])
 
3817
        
 
3818
    def __versionsDownloadDone(self, error):
 
3819
        """
 
3820
        Private method called, after the versions file has been downloaded
 
3821
        from the internet.
 
3822
        
 
3823
        @param error flag indicating an error condition (boolean)
 
3824
        """
 
3825
        if self.__versionCheckCanceled:
 
3826
            self.__inVersionCheck = False
 
3827
            if self.__versionCheckProgress is not None:
 
3828
                self.__versionCheckProgress.reset()
 
3829
                self.__versionCheckProgress = None
 
3830
            return
 
3831
        
 
3832
        if error or self.http.lastResponse().statusCode() != 200:
 
3833
            self.httpAlternative += 1
 
3834
            if self.httpAlternative >= len(self.__httpAlternatives):
 
3835
                self.__inVersionCheck = False
 
3836
                if self.__versionCheckProgress is not None:
 
3837
                    self.__versionCheckProgress.reset()
 
3838
                    self.__versionCheckProgress = None
 
3839
                KQMessageBox.warning(None,
 
3840
                    self.trUtf8("Error during updates check"),
 
3841
                    self.trUtf8("""Could not perform updates check."""))
 
3842
                return
 
3843
            else:
 
3844
                self.http = None
 
3845
                self.performVersionCheck(self.manualUpdatesCheck, self.httpAlternative)
 
3846
                return
 
3847
        
 
3848
        self.__inVersionCheck = False
 
3849
        if self.__versionCheckProgress is not None:
 
3850
            self.__versionCheckProgress.reset()
 
3851
            self.__versionCheckProgress = None
 
3852
        Preferences.Prefs.settings.setValue(\
 
3853
            "Updates/LastCheckDate", QVariant(QDate.currentDate()))
 
3854
        versions = unicode(self.http.readAll()).splitlines()
 
3855
        
 
3856
        url = ""
 
3857
        try:
 
3858
            if "-snapshot-" in Version:
 
3859
                # check snapshot version
 
3860
                if versions[2] > Version:
 
3861
                    res = KQMessageBox.information(None,
 
3862
                        self.trUtf8("Update available"),
 
3863
                        self.trUtf8("""The update to <b>%1</b> of eric4 is available"""
 
3864
                                    """ at <b>%2</b>. Would you like to get it?""")\
 
3865
                            .arg(versions[2]).arg(versions[3]),
 
3866
                        QMessageBox.StandardButtons(\
 
3867
                            QMessageBox.No | \
 
3868
                            QMessageBox.Yes),
 
3869
                        QMessageBox.Yes)
 
3870
                    url = res == QMessageBox.Yes and versions[3] or ''
 
3871
                elif versions[0] > Version:
 
3872
                    res = KQMessageBox.information(None,
 
3873
                        self.trUtf8("Update available"),
 
3874
                        self.trUtf8("""The update to <b>%1</b> of eric4 is available"""
 
3875
                                    """ at <b>%2</b>. Would you like to get it?""")\
 
3876
                            .arg(versions[0]).arg(versions[1]),
 
3877
                        QMessageBox.StandardButtons(\
 
3878
                            QMessageBox.No | \
 
3879
                            QMessageBox.Yes),
 
3880
                        QMessageBox.Yes)
 
3881
                    url = res == QMessageBox.Yes and versions[1] or ''
 
3882
                else:
 
3883
                    if self.manualUpdatesCheck:
 
3884
                        KQMessageBox.information(None,
 
3885
                            self.trUtf8("Eric4 is up to date"),
 
3886
                            self.trUtf8("""You are using the latest version or eric4"""))
 
3887
            else:
 
3888
                # check release version
 
3889
                if versions[0] > Version:
 
3890
                    res = KQMessageBox.information(None,
 
3891
                        self.trUtf8("Update available"),
 
3892
                        self.trUtf8("""The update to <b>%1</b> of eric4 is available"""
 
3893
                                    """ at <b>%2</b>. Would you like to get it?""")\
 
3894
                            .arg(versions[0]).arg(versions[1]),
 
3895
                        QMessageBox.StandardButtons(\
 
3896
                            QMessageBox.No | \
 
3897
                            QMessageBox.Yes),
 
3898
                        QMessageBox.Yes)
 
3899
                    url = res == QMessageBox.Yes and versions[1] or ''
 
3900
                else:
 
3901
                    if self.manualUpdatesCheck:
 
3902
                        KQMessageBox.information(None,
 
3903
                            self.trUtf8("Eric4 is up to date"),
 
3904
                            self.trUtf8("""You are using the latest version or eric4"""))
 
3905
        except IndexError:
 
3906
            KQMessageBox.warning(None,
 
3907
                self.trUtf8("Error during updates check"),
 
3908
                self.trUtf8("""Could not perform updates check."""))
 
3909
        
 
3910
        if url:
 
3911
            QDesktopServices.openUrl(QUrl(url))
 
3912
        
 
3913
    def __versionsDownloadCanceled(self):
 
3914
        """
 
3915
        Private method called to cancel the version check.
 
3916
        """
 
3917
        if self.http is not None:
 
3918
            self.__versionCheckCanceled = True
 
3919
            self.http.abort()
 
3920
    
 
3921
    ######################################################
 
3922
    ## Below are methods to check the configuration status
 
3923
    ######################################################
 
3924
 
 
3925
    def checkConfigurationStatus(self):
 
3926
        """
 
3927
        Public method to check, if eric4 has been configured. If it is not, 
 
3928
        the configuration dialog is shown.
 
3929
        """
 
3930
        if not Preferences.isConfigured():
 
3931
            KQMessageBox.information(None,
 
3932
                self.trUtf8("First time usage"),
 
3933
                self.trUtf8("""eric4 has not been configured yet. """
 
3934
                            """The configuration dialog will be started."""),
 
3935
                QMessageBox.StandardButtons(\
 
3936
                    QMessageBox.Ok))
 
3937
            self.__preferences()
 
3938
    
 
3939
    #################################
3699
3940
    ## Below are some utility methods
3700
 
    ###################################
 
3941
    #################################
3701
3942
 
3702
 
    def getFloatingGeometry(self, w):
 
3943
    def __getFloatingGeometry(self, w):
3703
3944
        """
3704
 
        Private function to get the geometry of a floating windows.
3705
 
        
3706
 
        This function handles the upper left corner differently on
3707
 
        win32 systems.
 
3945
        Private method to get the geometry of a floating windows.
3708
3946
        
3709
3947
        @param w reference to the widget to be saved (QWidget)
3710
3948
        @return list giving the widget's geometry and it's visibility
3711
3949
        """
3712
 
        g = w.geometry()
3713
3950
        s = w.size()
3714
3951
        p = w.pos()
3715
3952
        return [p.x(), p.y(), s.width(), s.height(), not w.isHidden()]