ProjectDjango/Project.py

# -*- coding: utf-8 -*-

# Copyright (c) 2013 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the Django project support.
"""

import sys
import os

from PyQt4.QtCore import QObject
from PyQt4.QtGui import QMenu, QInputDialog, QLineEdit

from E5Gui.E5Application import e5App
from E5Gui import E5MessageBox
from E5Gui.E5Action import E5Action

from .DjangoDialog import DjangoDialog

import Preferences
import Utilities


class DjangoNoSiteSelectedException(Exception):
    """
    Exception thrown to signal, that there is no current site.
    """
    pass


class Project(QObject):
    """
    Class implementing the Django project support.
    """
    RecentApplicationsKey = "Django/RecentApplications"
    
    def __init__(self, plugin, parent=None):
        """
        Constructor
        
        @param plugin reference to the plugin object
        @param parent parent (QObject)
        """
        super().__init__(parent)
        
        self.__plugin = plugin
        self.__ui = parent
        self.__e5project = e5App().getObject("Project")
        self.__hooksInstalled = False
        
        self.__mainMenu = None
        
        self.__serverProc = None
        self.__testServerProc = None
        
        self.__recentApplications = []
        self.__loadRecentApplications()
    
    def initActions(self):
        """
        Public method to define the Pyramid actions.
        """
        self.actions = []
    
        self.selectSiteAct = E5Action(self.trUtf8('Current Project'),
                "",
                0, 0,
                self,'django_current_project')
        self.selectSiteAct.setStatusTip(self.trUtf8(
            'Selects the current project'))
        self.selectSiteAct.setWhatsThis(self.trUtf8(
            """<b>Current Project</b>"""
            """<p>Selects the current project. Used for multi-project """
            """Django projects to switch between the projects.</p>"""
        ))
        self.selectSiteAct.triggered[()].connect(self.__selectSite)
        self.actions.append(self.selectSiteAct)
        self.__setCurrentSite(None)
        
        ##############################
        ## start actions below      ##
        ##############################
        
        self.startProjectAct = E5Action(self.trUtf8('Start Project'),
                self.trUtf8('Start &Project'), 
                0, 0,
                self,'django_start_project')
        self.startProjectAct.setStatusTip(self.trUtf8(
            'Starts a new Django project'))
        self.startProjectAct.setWhatsThis(self.trUtf8(
            """<b>Start Project</b>"""
            """<p>Starts a new Django project using "django-admin.py startproject".</p>"""
        ))
        self.startProjectAct.triggered[()].connect(self.__startProject)
        self.actions.append(self.startProjectAct)
        
        self.startGlobalApplicationAct = E5Action(
                self.trUtf8('Start Application (global)'),
                self.trUtf8('Start Application (&global)'), 
                0, 0,
                self,'django_start_global_application')
        self.startGlobalApplicationAct.setStatusTip(self.trUtf8(
            'Starts a new global Django application'))
        self.startGlobalApplicationAct.setWhatsThis(self.trUtf8(
            """<b>Start Application (global)</b>"""
            """<p>Starts a new global Django application using"""
            """ "django-admin.py startapp".</p>"""
        ))
        self.startGlobalApplicationAct.triggered[()].connect(
            self.__startGlobalApplication)
        self.actions.append(self.startGlobalApplicationAct)
        
        self.startLocalApplicationAct = E5Action(
                self.trUtf8('Start Application (local)'),
                self.trUtf8('Start Application (&local)'), 
                0, 0,
                self,'django_start_local_application')
        self.startLocalApplicationAct.setStatusTip(self.trUtf8(
            'Starts a new local Django application'))
        self.startLocalApplicationAct.setWhatsThis(self.trUtf8(
            """<b>Start Application (local)</b>"""
            """<p>Starts a new local Django application using"""
            """ "manage.py startapp".</p>"""
        ))
        self.startLocalApplicationAct.triggered[()].connect(
            self.__startLocalApplication)
        self.actions.append(self.startLocalApplicationAct)
        
##        ##############################
##        ## run actions below        ##
##        ##############################
##        
##        self.runServerAct = E4Action(self.trUtf8('Run Server'),
##                self.trUtf8('Run &Server'), 
##                0, 0,
##                self,'django_run_server')
##        self.runServerAct.setStatusTip(self.trUtf8(
##            'Starts the Django Web server'))
##        self.runServerAct.setWhatsThis(self.trUtf8(
##            """<b>Run Server</b>"""
##            """<p>Starts the Django Web server using "manage.py runserver".</p>"""
##        ))
##        self.connect(self.runServerAct, SIGNAL('triggered()'), self.__runServer)
##        self.actions.append(self.runServerAct)
##        
##        self.runBrowserAct = E4Action(self.trUtf8('Run Web-Browser'),
##                self.trUtf8('Run &Web-Browser'), 
##                0, 0,
##                self,'django_run_browser')
##        self.runBrowserAct.setStatusTip(self.trUtf8(
##            'Starts the default Web-Browser with the URL of the Django Web server'))
##        self.runBrowserAct.setWhatsThis(self.trUtf8(
##            """<b>Run Web-Browser</b>"""
##            """<p>Starts the default Web-Browser with the URL of the """
##            """Django Web server.</p>"""
##        ))
##        self.connect(self.runBrowserAct, SIGNAL('triggered()'), self.__runBrowser)
##        self.actions.append(self.runBrowserAct)
##        
##        ##############################
##        ## caching actions below    ##
##        ##############################
##        
##        self.createCacheTableAct = E4Action(self.trUtf8('Create Cache Tables'),
##                self.trUtf8('C&reate Cache Tables'), 
##                0, 0,
##                self,'django_create_cache_tables')
##        self.createCacheTableAct.setStatusTip(self.trUtf8(
##            'Creates the tables needed to use the SQL cache backend'))
##        self.createCacheTableAct.setWhatsThis(self.trUtf8(
##            """<b>Create Cache Tables</b>"""
##            """<p>Creates the tables needed to use the SQL cache backend.</p>"""
##        ))
##        self.connect(self.createCacheTableAct, SIGNAL('triggered()'), 
##            self.__createCacheTables)
##        self.actions.append(self.createCacheTableAct)
##        
        ##############################
        ## help action below        ##
        ##############################
        
        self.helpAct = E5Action(self.trUtf8('Help'),
                self.trUtf8('&Help'), 
                0, 0,
                self,'django_help')
        self.helpAct.setStatusTip(self.trUtf8(
            'Shows the Django help index'))
        self.helpAct.setWhatsThis(self.trUtf8(
            """<b>Help</b>"""
            """<p>Shows the Django help index page.</p>"""
        ))
        self.helpAct.triggered[()].connect(self.__showHelpIndex)
        self.actions.append(self.helpAct)
        
        ##############################
        ## about action below       ##
        ##############################
        
        self.aboutDjangoAct = E5Action(self.trUtf8('About Django'),
                self.trUtf8('About D&jango'), 
                0, 0,
                self,'django_about')
        self.aboutDjangoAct.setStatusTip(self.trUtf8(
            'Shows some information about Django'))
        self.aboutDjangoAct.setWhatsThis(self.trUtf8(
            """<b>About Django</b>"""
            """<p>Shows some information about Django.</p>"""
        ))
        self.aboutDjangoAct.triggered[()].connect(self.__djangoInfo)
        self.actions.append(self.aboutDjangoAct)
##        
##        self.__initDatabaseActions()
##        self.__initDatabaseSqlActions()
##        self.__initToolsActions()
##        self.__initTestingActions()
##
##    def __initDatabaseActions(self):
##        """
##        Private method to define the database related actions.
##        """
##        self.syncDatabaseAct = E4Action(self.trUtf8('Synchronize'),
##                self.trUtf8('&Synchronize'), 
##                0, 0,
##                self,'django_database_syncdb')
##        self.syncDatabaseAct.setStatusTip(self.trUtf8(
##            'Synchronizes the database'))
##        self.syncDatabaseAct.setWhatsThis(self.trUtf8(
##            """<b>Synchronize</b>"""
##            """<p>Synchronizes the database.</p>"""
##        ))
##        self.connect(self.syncDatabaseAct, SIGNAL('triggered()'), 
##            self.__databaseSynchronize)
##        self.actions.append(self.syncDatabaseAct)
##        
##        self.inspectDatabaseAct = E4Action(self.trUtf8('Introspect'),
##                self.trUtf8('&Introspect'), 
##                0, 0,
##                self,'django_database_inspect')
##        self.inspectDatabaseAct.setStatusTip(self.trUtf8(
##            'Introspects the database tables and outputs a Django model module'))
##        self.inspectDatabaseAct.setWhatsThis(self.trUtf8(
##            """<b>Introspect</b>"""
##            """<p>Introspects the database tables and outputs a """
##            """Django model module.</p>"""
##        ))
##        self.connect(self.inspectDatabaseAct, SIGNAL('triggered()'), 
##            self.__databaseInspect)
##        self.actions.append(self.inspectDatabaseAct)
##        
##        self.flushDatabaseAct = E4Action(self.trUtf8('Flush'),
##                self.trUtf8('&Flush'), 
##                0, 0,
##                self,'django_database_flush')
##        self.flushDatabaseAct.setStatusTip(self.trUtf8(
##            'Returns all database tables to the state just after their installation'))
##        self.flushDatabaseAct.setWhatsThis(self.trUtf8(
##            """<b>Flush</b>"""
##            """<p>Returns all database tables to the state """
##            """just after their installation.</p>"""
##        ))
##        self.connect(self.flushDatabaseAct, SIGNAL('triggered()'), 
##            self.__databaseFlush)
##        self.actions.append(self.flushDatabaseAct)
##        
##        self.resetDatabaseAct = E4Action(self.trUtf8('Reset Application(s)'),
##                self.trUtf8('&Reset Application(s)'), 
##                0, 0,
##                self,'django_database_reset_application')
##        self.resetDatabaseAct.setStatusTip(self.trUtf8(
##            'Resets the database tables of one or more applications'))
##        self.resetDatabaseAct.setWhatsThis(self.trUtf8(
##            """<b>Reset Application(s)</b>"""
##            """<p>Resets the database tables of one or more applications.</p>"""
##        ))
##        self.connect(self.resetDatabaseAct, SIGNAL('triggered()'), 
##            self.__databaseReset)
##        self.actions.append(self.resetDatabaseAct)
##        
##        self.databaseClientAct = E4Action(self.trUtf8('Start Client Console'),
##                self.trUtf8('Start &Client Console'), 
##                0, 0,
##                self,'django_database_client')
##        self.databaseClientAct.setStatusTip(self.trUtf8(
##            'Starts a console window for the database client'))
##        self.databaseClientAct.setWhatsThis(self.trUtf8(
##            """<b>Start Client Console</b>"""
##            """<p>Starts a console window for the database client.</p>"""
##        ))
##        self.connect(self.databaseClientAct, SIGNAL('triggered()'), 
##            self.__runDatabaseClient)
##        self.actions.append(self.databaseClientAct)
##    
##    def __initDatabaseSqlActions(self):
##        """
##        Private method to define the database SQL related actions.
##        """
##        self.databaseSqlCreateTablesAct = E4Action(self.trUtf8('Create Tables'),
##                self.trUtf8('Create &Tables'), 
##                0, 0,
##                self,'django_database_sql_create_tables')
##        self.databaseSqlCreateTablesAct.setStatusTip(self.trUtf8(
##            'Prints the CREATE TABLE SQL statements for one or more applications'))
##        self.databaseSqlCreateTablesAct.setWhatsThis(self.trUtf8(
##            """<b>Create Tables</b>"""
##            """<p>Prints the CREATE TABLE SQL statements for one or """
##            """more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlCreateTablesAct, SIGNAL('triggered()'), 
##            self.__databaseSqlCreateTables)
##        self.actions.append(self.databaseSqlCreateTablesAct)
##        
##        self.databaseSqlCreateIndexesAct = E4Action(self.trUtf8('Create Indexes'),
##                self.trUtf8('Create &Indexes'), 
##                0, 0,
##                self,'django_database_sql_create_indexes')
##        self.databaseSqlCreateIndexesAct.setStatusTip(self.trUtf8(
##            'Prints the CREATE INDEX SQL statements for one or more applications'))
##        self.databaseSqlCreateIndexesAct.setWhatsThis(self.trUtf8(
##            """<b>Create Indexes</b>"""
##            """<p>Prints the CREATE INDEX SQL statements for one or """
##            """more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlCreateIndexesAct, SIGNAL('triggered()'), 
##            self.__databaseSqlCreateIndexes)
##        self.actions.append(self.databaseSqlCreateIndexesAct)
##        
##        self.databaseSqlCreateEverythingAct = E4Action(self.trUtf8('Create Everything'),
##                self.trUtf8('Create &Everything'), 
##                0, 0,
##                self,'django_database_sql_create_everything')
##        self.databaseSqlCreateEverythingAct.setStatusTip(self.trUtf8(
##            'Prints the CREATE ... SQL statements for one or more applications'))
##        self.databaseSqlCreateEverythingAct.setWhatsThis(self.trUtf8(
##            """<b>Create Everything</b>"""
##            """<p>Prints the CREATE TABLE, custom SQL and CREATE INDEX SQL """
##            """statements for one or more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlCreateEverythingAct, SIGNAL('triggered()'), 
##            self.__databaseSqlCreateEverything)
##        self.actions.append(self.databaseSqlCreateEverythingAct)
##        
##        self.databaseSqlCustomAct = E4Action(self.trUtf8('Custom Statements'),
##                self.trUtf8('&Custom Statements'), 
##                0, 0,
##                self,'django_database_sql_custom')
##        self.databaseSqlCustomAct.setStatusTip(self.trUtf8(
##            'Prints the custom table modifying SQL statements for '
##            'one or more applications'))
##        self.databaseSqlCustomAct.setWhatsThis(self.trUtf8(
##            """<b>Custom Statements</b>"""
##            """<p>Prints the custom table modifying SQL statements """
##            """for one or more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlCustomAct, SIGNAL('triggered()'), 
##            self.__databaseSqlCustom)
##        self.actions.append(self.databaseSqlCustomAct)
##        
##        self.databaseSqlDropTablesAct = E4Action(self.trUtf8('Drop Tables'),
##                self.trUtf8('&Drop Tables'), 
##                0, 0,
##                self,'django_database_sql_drop_tables')
##        self.databaseSqlDropTablesAct.setStatusTip(self.trUtf8(
##            'Prints the DROP TABLE SQL statements for '
##            'one or more applications'))
##        self.databaseSqlDropTablesAct.setWhatsThis(self.trUtf8(
##            """<b>Drop Tables</b>"""
##            """<p>Prints the DROP TABLE SQL statements """
##            """for one or more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlDropTablesAct, SIGNAL('triggered()'), 
##            self.__databaseSqlDropTables)
##        self.actions.append(self.databaseSqlDropTablesAct)
##        
##        self.databaseSqlFlushAct = E4Action(self.trUtf8('Flush Database'),
##                self.trUtf8('&Flush Database'), 
##                0, 0,
##                self,'django_database_sql_flush_database')
##        self.databaseSqlFlushAct.setStatusTip(self.trUtf8(
##            'Prints a list of statements to return all database tables to the state '
##            'just after their installation'))
##        self.databaseSqlFlushAct.setWhatsThis(self.trUtf8(
##            """<b>Flush Database</b>"""
##            """<p>Prints a list of statements to return all database tables to """
##            """the state just after their installation.</p>"""
##        ))
##        self.connect(self.databaseSqlFlushAct, SIGNAL('triggered()'), 
##            self.__databaseSqlFlushDatabase)
##        self.actions.append(self.databaseSqlFlushAct)
##        
##        self.databaseSqlResetApplAct = E4Action(self.trUtf8('Reset Application(s)'),
##                self.trUtf8('Reset &Application(s)'), 
##                0, 0,
##                self,'django_database_sql_reset_application')
##        self.databaseSqlResetApplAct.setStatusTip(self.trUtf8(
##            'Prints the DROP TABLE SQL, then the CREATE TABLE SQL, for '
##            'one or more applications'))
##        self.databaseSqlResetApplAct.setWhatsThis(self.trUtf8(
##            """<b>Reset Application(s)</b>"""
##            """<p>Prints the DROP TABLE SQL, then the CREATE TABLE SQL, for """
##            """one or more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlResetApplAct, SIGNAL('triggered()'), 
##            self.__databaseSqlResetApplication)
##        self.actions.append(self.databaseSqlResetApplAct)
##        
##        self.databaseSqlResetSeqAct = E4Action(self.trUtf8('Reset Sequences'),
##                self.trUtf8('Reset &Sequences'), 
##                0, 0,
##                self,'django_database_sql_reset_sequences')
##        self.databaseSqlResetSeqAct.setStatusTip(self.trUtf8(
##            'Prints the SQL statements for resetting sequences for '
##            'one or more applications'))
##        self.databaseSqlResetSeqAct.setWhatsThis(self.trUtf8(
##            """<b>Reset Sequences</b>"""
##            """<p>Prints the SQL statements for resetting sequences for """
##            """one or more applications.</p>"""
##        ))
##        self.connect(self.databaseSqlResetSeqAct, SIGNAL('triggered()'), 
##            self.__databaseSqlResetSequences)
##        self.actions.append(self.databaseSqlResetSeqAct)
##    
##    def __initToolsActions(self):
##        """
##        Private method to define the tool actions.
##        """
##        self.diffSettingsAct = E4Action(self.trUtf8('Diff Settings'),
##                self.trUtf8('&Diff Settings'), 
##                0, 0,
##                self,'django_tools_diffsettings')
##        self.diffSettingsAct.setStatusTip(self.trUtf8(
##            'Shows the modification made to the settings'))
##        self.diffSettingsAct.setWhatsThis(self.trUtf8(
##            """<b>Diff Settings</b>"""
##            """<p>Shows the modification made to the settings.</p>"""
##        ))
##        self.connect(self.diffSettingsAct, SIGNAL('triggered()'), 
##            self.__diffSettings)
##        self.actions.append(self.diffSettingsAct)
##    
##        self.cleanupAct = E4Action(self.trUtf8('Cleanup'),
##                self.trUtf8('&Cleanup'), 
##                0, 0,
##                self,'django_tools_cleanup')
##        self.cleanupAct.setStatusTip(self.trUtf8(
##            'Cleans out old data from the database'))
##        self.cleanupAct.setWhatsThis(self.trUtf8(
##            """<b>Cleanup</b>"""
##            """<p>Cleans out old data from the database.</p>"""
##        ))
##        self.connect(self.cleanupAct, SIGNAL('triggered()'), 
##            self.__cleanup)
##        self.actions.append(self.cleanupAct)
##    
##        self.validateAct = E4Action(self.trUtf8('Validate'),
##                self.trUtf8('&Validate'), 
##                0, 0,
##                self,'django_tools_validate')
##        self.validateAct.setStatusTip(self.trUtf8(
##            'Validates all installed models'))
##        self.validateAct.setWhatsThis(self.trUtf8(
##            """<b>Validate</b>"""
##            """<p>Validates all installed models.</p>"""
##        ))
##        self.connect(self.validateAct, SIGNAL('triggered()'), 
##            self.__validate)
##        self.actions.append(self.validateAct)
##    
##        self.adminindexAct = E4Action(self.trUtf8('Admin Index'),
##                self.trUtf8('&Admin Index'), 
##                0, 0,
##                self,'django_tools_adminindex')
##        self.adminindexAct.setStatusTip(self.trUtf8(
##            'Prints the admin-index template snippet'))
##        self.adminindexAct.setWhatsThis(self.trUtf8(
##            """<b>Admin Index</b>"""
##            """<p>Prints the admin-index template snippet.</p>"""
##        ))
##        self.connect(self.adminindexAct, SIGNAL('triggered()'), 
##            self.__adminIndex)
##        self.actions.append(self.adminindexAct)
##    
##        self.runPythonShellAct = E4Action(self.trUtf8('Start Python Console'),
##                self.trUtf8('Start &Python Console'), 
##                0, 0,
##                self,'django_tools_pythonconsole')
##        self.runPythonShellAct.setStatusTip(self.trUtf8(
##            'Starts a Python interactive interpreter'))
##        self.runPythonShellAct.setWhatsThis(self.trUtf8(
##            """<b>Start Python Console</b>"""
##            """<p>Starts a Python interactive interpreter.</p>"""
##        ))
##        self.connect(self.runPythonShellAct, SIGNAL('triggered()'), 
##            self.__runPythonShell)
##        self.actions.append(self.runPythonShellAct)
##    
##    def __initTestingActions(self):
##        """
##        Private method to define the testing actions.
##        """
##        self.dumpDataAct = E4Action(self.trUtf8('Dump Data'),
##                self.trUtf8('&Dump Data'), 
##                0, 0,
##                self,'django_tools_dumpdata')
##        self.dumpDataAct.setStatusTip(self.trUtf8(
##            'Dump the database data to a fixture'))
##        self.dumpDataAct.setWhatsThis(self.trUtf8(
##            """<b>Dump Data</b>"""
##            """<p>Dump the database data to a fixture.</p>"""
##        ))
##        self.connect(self.dumpDataAct, SIGNAL('triggered()'), 
##            self.__dumpData)
##        self.actions.append(self.dumpDataAct)
##        
##        self.loadDataAct = E4Action(self.trUtf8('Load Data'),
##                self.trUtf8('&Load Data'), 
##                0, 0,
##                self,'django_tools_loaddata')
##        self.loadDataAct.setStatusTip(self.trUtf8(
##            'Load data from fixture files'))
##        self.loadDataAct.setWhatsThis(self.trUtf8(
##            """<b>Load Data</b>"""
##            """<p>Load data from fixture files.</p>"""
##        ))
##        self.connect(self.loadDataAct, SIGNAL('triggered()'), 
##            self.__loadData)
##        self.actions.append(self.loadDataAct)
##        
##        self.runTestAct = E4Action(self.trUtf8('Run Testsuite'),
##                self.trUtf8('Run &Testsuite'), 
##                0, 0,
##                self,'django_tools_run_test')
##        self.runTestAct.setStatusTip(self.trUtf8(
##            'Run the test suite for applications or the whole site'))
##        self.runTestAct.setWhatsThis(self.trUtf8(
##            """<b>Run Testsuite</b>"""
##            """<p>Run the test suite for applications or the whole site.</p>"""
##        ))
##        self.connect(self.runTestAct, SIGNAL('triggered()'), 
##            self.__runTestSuite)
##        self.actions.append(self.runTestAct)
##        
##        self.runTestServerAct = E4Action(self.trUtf8('Run Testserver'),
##                self.trUtf8('Run Test&server'), 
##                0, 0,
##                self,'django_tools_run_test_server')
##        self.runTestServerAct.setStatusTip(self.trUtf8(
##            'Run a development server with data from a set of fixtures'))
##        self.runTestServerAct.setWhatsThis(self.trUtf8(
##            """<b>Run Testserver</b>"""
##            """<p>Run a development server with data from a set of fixtures.</p>"""
##        ))
##        self.connect(self.runTestServerAct, SIGNAL('triggered()'), 
##            self.__runTestServer)
##        self.actions.append(self.runTestServerAct)
##    
    def initMenu(self):
        """
        Public slot to initialize the Django menu.
        
        @return the menu generated (QMenu)
        """
        menu = QMenu(self.trUtf8('D&jango'), self.__ui)
        menu.setTearOffEnabled(True)
        
        menu.addAction(self.selectSiteAct)
        menu.addSeparator()
##        menu.addAction(self.runServerAct)
##        menu.addAction(self.runBrowserAct)
        menu.addSeparator()
        menu.addAction(self.startProjectAct)
        menu.addAction(self.startGlobalApplicationAct)
        menu.addAction(self.startLocalApplicationAct)
        menu.addSeparator()
        menu.addMenu(self.__initDatabaseMenu())
        menu.addSeparator()
        menu.addMenu(self.__initToolsMenu())
        menu.addSeparator()
##        menu.addAction(self.createCacheTableAct)
        menu.addSeparator()
        menu.addMenu(self.__initTestingMenu())
        menu.addSeparator()
        menu.addAction(self.aboutDjangoAct)
        menu.addSeparator()
        menu.addAction(self.helpAct)
        
        self.__mainMenu = menu
        
        return menu

    def __initDatabaseMenu(self):
        """
        Private slot to initialize the database menu.
        
        @return the menu generated (QMenu)
        """
        menu = QMenu(self.trUtf8("&Database"), self.__ui)
        menu.setTearOffEnabled(True)
        
##        menu.addAction(self.syncDatabaseAct)
        menu.addSeparator()
##        menu.addAction(self.inspectDatabaseAct)
        menu.addSeparator()
##        menu.addAction(self.flushDatabaseAct)
##        menu.addAction(self.resetDatabaseAct)
        menu.addSeparator()
##        menu.addAction(self.databaseClientAct)
        menu.addSeparator()
        menu.addMenu(self.__initDatabaseSqlMenu())
        
        return menu
    
    def __initDatabaseSqlMenu(self):
        """
        Private slot to initialize the database SQL submenu.
        
        @return the menu generated (QMenu)
        """
        menu = QMenu(self.trUtf8("Show &SQL"), self.__ui)
        menu.setTearOffEnabled(True)
        
##        menu.addAction(self.databaseSqlCreateTablesAct)
##        menu.addAction(self.databaseSqlCreateIndexesAct)
##        menu.addAction(self.databaseSqlCreateEverythingAct)
        menu.addSeparator()
##        menu.addAction(self.databaseSqlCustomAct)
        menu.addSeparator()
##        menu.addAction(self.databaseSqlDropTablesAct)
        menu.addSeparator()
##        menu.addAction(self.databaseSqlFlushAct)
##        menu.addAction(self.databaseSqlResetApplAct)
##        menu.addAction(self.databaseSqlResetSeqAct)
        
        return menu
    
    def __initToolsMenu(self):
        """
        Private slot to initialize the tools menu.
        
        @return the menu generated (QMenu)
        """
        menu = QMenu(self.trUtf8("&Tools"), self.__ui)
        menu.setTearOffEnabled(True)
        
##        menu.addAction(self.diffSettingsAct)
##        menu.addAction(self.cleanupAct)
##        menu.addAction(self.validateAct)
##        menu.addAction(self.adminindexAct)
        menu.addSeparator()
##        menu.addAction(self.runPythonShellAct)
        
        return menu
    
    def __initTestingMenu(self):
        """
        Private slot to initialize the testing menu.
        
        @return the menu generated (QMenu)
        """
        menu = QMenu(self.trUtf8("T&esting"), self.__ui)
        menu.setTearOffEnabled(True)
        
##        menu.addAction(self.dumpDataAct)
##        menu.addAction(self.loadDataAct)
        menu.addSeparator()
##        menu.addAction(self.runTestAct)
##        menu.addAction(self.runTestServerAct)
        
        return menu

    ##################################################################
    ## methods below implement the various hook related functions
    ##################################################################
    
    def projectOpenedHooks(self):
        """
        Public method to add our hook methods.
        """
        if self.__e5project.getProjectType() == "Django":
            self.__formsBrowser = \
                e5App().getObject("ProjectBrowser").getProjectBrowser("forms")
            self.__formsBrowser.addHookMethodAndMenuEntry("newForm", 
                self.newForm, self.trUtf8("New template..."))
            
            self.__e5project.projectLanguageAddedByCode.connect(
                self.__projectLanguageAdded)
            self.__translationsBrowser = \
                e5App().getObject("ProjectBrowser").getProjectBrowser("translations")
            self.__translationsBrowser.addHookMethodAndMenuEntry("generateAll", 
                self.updateCatalogs, self.trUtf8("Update all catalogs"))
            self.__translationsBrowser.addHookMethodAndMenuEntry("generateSelected", 
                self.updateSelectedCatalogs, self.trUtf8("Update selected catalogs"))
            self.__translationsBrowser.addHookMethodAndMenuEntry("releaseAll", 
                self.compileCatalogs, self.trUtf8("Compile all catalogs"))
            self.__translationsBrowser.addHookMethodAndMenuEntry("releaseSelected", 
                self.compileSelectedCatalogs, 
                self.trUtf8("Compile selected catalogs"))
            
            self.__hooksInstalled = True
    
    def projectClosedHooks(self):
        """
        Public method to remove our hook methods.
        """
        if self.__hooksInstalled:
            self.__formsBrowser.removeHookMethod("newForm")
            self.__formsBrowser = None
            
            self.__e5project.projectLanguageAddedByCode.disconnect(
                self.__projectLanguageAdded)
            self.__translationsBrowser.removeHookMethod("generateAll")
            self.__translationsBrowser.removeHookMethod("generateSelected")
            self.__translationsBrowser.removeHookMethod("releaseAll")
            self.__translationsBrowser.removeHookMethod("releaseSelected")
            self.__translationsBrowser = None
            
        self.__hooksInstalled = False
    
    def newForm(self, path):
        """
        Public method to create a new form.
        
        @param path full directory path for the new form file (string)
        """
##        selectedFilter = QString("")
##        filter = self.trUtf8("HTML Files (*.html);;All Files (*)")
##        fname = KQFileDialog.getSaveFileName(\
##            self.__ui,
##            self.trUtf8("New Form"),
##            path,
##            filter,
##            selectedFilter,
##            QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
##        
##        if fname.isEmpty():
##            # user aborted or didn't enter a filename
##            return
##        
##        ext = QFileInfo(fname).suffix()
##        if ext.isEmpty():
##            ex = selectedFilter.section('(*',1,1).section(')',0,0)
##            if not ex.isEmpty():
##                fname.append(ex)
##        
##        fname = unicode(fname)
##        if os.path.exists(fname):
##            res = KQMessageBox.warning(self.__ui,
##                self.trUtf8("New Form"),
##                self.trUtf8("The file already exists! Overwrite it?"),
##                QMessageBox.StandardButtons(\
##                    QMessageBox.No | \
##                    QMessageBox.Yes),
##                QMessageBox.No)
##            if res != QMessageBox.Yes:
##                # user selected to not overwrite
##                return
##        
##        try:
##            f = open(fname, "wb")
##            f.write('<html>\n')
##            f.write('  <head>\n')
##            f.write('    <meta content="" />\n')
##            f.write('    <title></title>\n')
##            f.write('    <style>\n')
##            f.write('    </style>\n')
##            f.write('  </head>\n')
##            f.write('\n')
##            f.write('  <body>\n')
##            f.write('  </body>\n')
##            f.write('</html>\n')
##            f.close()
##        except IOError, e:
##            KQMessageBox.critical(self.__ui,
##                self.trUtf8("New Form"),
##                self.trUtf8("<p>The new form file <b>%1</b> could not be created.<br>"
##                    "Problem: %2</p>").arg(fname).arg(unicode(e)))
##            return
##        
##        self.__e4project.appendFile(fname)
##        self.__formsBrowser.emit(SIGNAL('sourceFile'), fname)

    ##################################################################
    ## slots below implement general functionality
    ##################################################################
    
    def projectClosed(self):
        """
        Public method to handle the closing of a project.
        """
        if self.__serverProc is not None:
            self.__serverProcFinished()
        self.__setCurrentSite(None)
    
    def __djangoInfo(self):
        """
        Private slot to show some info about Django.
        """
        from django import VERSION
        version = '.'.join([str(i) for i in VERSION[:-1]])
        if VERSION[-1]:
            version += '-' + VERSION[-1]
        
        E5MessageBox.about(self.__ui,
            self.trUtf8("About Django"),
            self.trUtf8(
                "<p>Django is a high-level Python Web framework that encourages rapid "
                "development and clean, pragmatic design.</p>"
                "<p><table>"
                "<tr><td>Version:</td><td>{0}</td></tr>"
                "<tr><td>URL:</td><td><a href=\"http://www.djangoproject.com\">"
                "http://www.djangoproject.com</a></td></tr>"
                "</table></p>"
            ).format(version)
        )
    
##    def getDjangoVersion(self):
##        """
##        Public method to get the Django version.
##        
##        @return Django version as a tuple
##        """
##        from django import VERSION
##        return VERSION
##    
##    def __getApplications(self):
##        """
##        Private method to ask the user for a list of application names.
##        
##        @return list of application names (QStringList)
##        """
##        applStr, ok = KQInputDialog.getItem(\
##            self.__ui,
##            self.trUtf8("Select Applications"),
##            self.trUtf8("Enter the list of applications separated by spaces."),
##            self.getRecentApplications(),
##            0, True)
##        if ok and not applStr.isEmpty():
##            self.setMostRecentApplication(applStr)
##            return applStr.split(" ", QString.SkipEmptyParts)
##        else:
##            return QStringList()
##
    def __loadRecentApplications(self):
        """
        Private method to load the recently used applications list.
        """
        self.__recentApplications = []
        Preferences.Prefs.rsettings.sync()
        ra = Preferences.Prefs.rsettings.value(self.RecentApplicationsKey)
        if ra is not None:
            maxRecentApps = self.__plugin.getPreferences("RecentNumberApps")
            self.__recentApplications = ra[:maxRecentApps]
    
    def __saveRecentApplications(self):
        """
        Private method to save the list of recently used applications list.
        """
        Preferences.Prefs.rsettings.setValue(self.RecentApplicationsKey, 
                                             self.__recentApplications)
        Preferences.Prefs.rsettings.sync()
    
    def getRecentApplications(self):
        """
        Public method to get the list of recent applications.
        
        @return list of recent applications entries (list of strings)
        """
        self.__loadRecentApplications()
        return self.__recentApplications
    
    def setMostRecentApplication(self, applStr):
        """
        Public method to set the most recently used applications entry.
        
        @param applStr applications entry (string)
        """
        if applStr in self.__recentApplications:
            self.__recentApplications.remove(applStr)
        self.__recentApplications.insert(0, applStr)
        
        maxRecentApps = self.__plugin.getPreferences("RecentNumberApps")
        if len(self.__recentApplications) > maxRecentApps:
            self.__recentApplications = self.recent[:maxRecentApps]
        self.__saveRecentApplications()
    
    def getProjectPath(self):
        """
        Public method to get the path of the eric5 project.
        
        @return path of the eric5 project (string)
        """
        return self.__e5project.getProjectPath()
    
    def __getPythonExecutable(self):
        """
        Private method to determine the name of the Python executable.
        
        @return Python executable (string)
        """
        return sys.executable.replace("pythonw", "python")
    
    def __showHelpIndex(self):
        """
        Private slot to show the help index page.
        """
        page = os.path.join(os.path.dirname(__file__), 
                            "Documentation", "help", "index.html")
        self.__ui.launchHelpViewer(page)
    
    ##################################################################
    ## slots below implement creation functions
    ##################################################################
    
##    def startProjectOrApplication(self):
##        """
##        Public slot to start a new Django project or application.
##        """
##        if self.__e4project.getProjectType() == "Django":
##            projectStr = self.trUtf8("Project")
##            applStr = self.trUtf8("Application")
##            selections = QStringList() << QString("") << projectStr << applStr
##            selection,  ok = KQInputDialog.getItem(\
##                self.__ui,
##                self.trUtf8("Start Django"),
##                self.trUtf8("Select if this project should be a "
##                            "Django Project or Application.<br />"
##                            "Select the empty entry for none."),
##                selections,
##                0, False)
##            if ok and not selection.isEmpty():
##                if selection == projectStr:
##                    path, projectName = os.path.split(self.__e4project.getProjectPath())
##                    self.__createProject(projectName, path)
##                elif selection == applStr:
##                    path, applName = os.path.split(self.__e4project.getProjectPath())
##                    self.__createApplication(applName, path)
##    
    def __createProject(self, projectName, path):
        """
        Private slot to create a new Django project.
        
        @param projectName name of the new project (string)
        @param path the directory where the project should be created
            (string)
        @return flag indicating a successful creation (boolean)
        """
        title = self.trUtf8("Start Django Project")
        
        args = []
        if Utilities.isWindowsPlatform():
            args.append(self.__getPythonExecutable())
            args.append(os.path.join(sys.exec_prefix, "Scripts", "django-admin.py"))
        else:
            if Utilities.isinpath("django-admin.py"):
                args.append("django-admin.py")
            elif Utilities.isinpath("django-admin"):
                args.append("django-admin")
            else:
                # fall back
                args.append("django-admin.py")
        args.append("startproject")
        args.append(projectName)
        
        dia = DjangoDialog(title, 
            msgSuccess = self.trUtf8("Django project created successfully."))
        res = dia.startProcess(args, path)
        if res:
            dia.exec_()
            
            # create the base directory for translations
            i18nPath = os.path.join(path, projectName, "locale")
            if not os.path.exists(i18nPath):
                os.makedirs(i18nPath)
            
            if os.path.join(path, projectName) == self.__e5project.getProjectPath():
                self.__setCurrentSite("")
            else:
                self.__setCurrentSite(projectName)
            
        return res
    
    def __startProject(self):
        """
        Private slot to start a new Django project.
        """
        projectName, ok = QInputDialog.getText(
            self.__ui,
            self.trUtf8("Start Django Project"),
            self.trUtf8("Enter the name of the new Django project."),
            QLineEdit.Normal)
        if ok and projectName != "":
            res = self.__createProject(projectName, self.__e5project.getProjectPath())
            if res:
                # search for new files and add them to the project
                sitePath = os.path.join(self.__e5project.getProjectPath(), 
                                        projectName)
                for entry in os.walk(sitePath):
                    for fileName in entry[2]:
                        fullName = os.path.join(entry[0], fileName)
                        self.__e5project.appendFile(fullName)
    
    def __createApplication(self, applName, path, isGlobal = True):
        """
        Private slot to create a new Django application.
        
        @param applName name of the new application (string)
        @param path the directory where the application should be created
            (string)
        @param isGlobal flag indicating a standalone Django application (boolean)
        @return flag indicating a successful creation (boolean)
        """
        title = self.trUtf8("Start Django Application")
        
        args = []
        if isGlobal:
            if Utilities.isWindowsPlatform():
                args.append(self.__getPythonExecutable())
                args.append(os.path.join(sys.exec_prefix, "Scripts", "django-admin.py"))
            else:
                if Utilities.isinpath("django-admin.py"):
                    args.append("django-admin.py")
                elif Utilities.isinpath("django-admin"):
                    args.append("django-admin")
                else:
                    # fall back
                    args.append("django-admin.py")
        else:
            args.append(self.__getPythonExecutable())
            args.append("manage.py")
            try:
                path = self.__sitePath()
            except DjangoNoSiteSelectedException:
                return False
        args.append("startapp")
        args.append(applName)
        
        dia = DjangoDialog(title, 
            msgSuccess = self.trUtf8("Django application created successfully."))
        res = dia.startProcess(args, path)
        if res:
            dia.exec_()
        return res
    
    def __startGlobalApplication(self):
        """
        Private slot to start a new global Django application.
        """
        applName, ok = QInputDialog.getText(
            self.__ui,
            self.trUtf8("Start Global Django Application"),
            self.trUtf8("Enter the name of the new global Django application."),
            QLineEdit.Normal)
        if ok and applName != "":
            res = self.__createApplication(applName, self.__e5project.getProjectPath())
            if res:
                # search for new files and add them to the project
                appPath = os.path.join(self.__e5project.getProjectPath(), applName)
                for entry in os.walk(appPath):
                    for fileName in entry[2]:
                        fullName = os.path.join(entry[0], fileName)
                        self.__e5project.appendFile(fullName)
    
    def __startLocalApplication(self):
        """
        Private slot to start a new local Django application.
        """
        applName, ok = QInputDialog.getText(
            self.__ui,
            self.trUtf8("Start Local Django Application"),
            self.trUtf8("Enter the name of the new local Django application."),
            QLineEdit.Normal)
        if ok and applName != "":
            res = self.__createApplication(applName, "", False)
            if res:
                try:
                    # search for new files and add them to the project
                    appPath = os.path.join(self.__sitePath(), applName)
                    for entry in os.walk(appPath):
                        for fileName in entry[2]:
                            fullName = os.path.join(entry[0], fileName)
                            self.__e5project.appendFile(fullName)
                except DjangoNoSiteSelectedException:
                    return
    
    ##################################################################
    ## methods below implement site related functions
    ##################################################################
    
    def __findSites(self):
        """
        Private method to determine the relative path to all manage.py scripts.
        
        @return list of sites (list of strings)
        """
        sites = []
        for file in sorted(self.__e5project.getSources()):
            if os.path.basename(file) == "manage.py":
                sites.append(os.path.dirname(file))
        return sites
    
    def __selectSite(self):
        """
        Private method to select a site to work with.
        
        @return selected site (string)
        """
        sites = self.__findSites()
        if len(sites) == 1:
            site = sites[0]
        else:
            if self.__currentSite is not None:
                if self.__currentSite in sites:
                    cur = sites.index(self.__currentSite)
                else:
                    cur = 0
            else:
                cur = 0
            site, ok = QInputDialog.getItem(
                self.__ui,
                self.trUtf8("Select Project"),
                self.trUtf8("Select the Django project to work with."),
                sites,
                cur, False)
            if not ok:
                site = None
        self.__setCurrentSite(site)
    
    def __sitePath(self):
        """
        Private method to calculate the full path of the Django site.
        
        @exception DjangoNoSiteSelectedException raised, if no site is selected
        @return path of the site (string)
        """
        if self.__currentSite is None:
            self.__selectSite()
        
        if self.__currentSite is None:
            raise DjangoNoSiteSelectedException
        else:
            return os.path.join(self.__e5project.getProjectPath(), 
                                self.__currentSite)
    
    def __setCurrentSite(self, site):
        """
        Private slot to set the current site.
        
        @param site name of the site (string)
        """
        self.__currentSite = site
        if self.__currentSite is None:
            curSite = self.trUtf8("None")
        elif self.__currentSite == "":
            curSite = self.trUtf8("Project")
        else:
            curSite = self.__currentSite
        self.selectSiteAct.setText(
            self.trUtf8('&Current Django project ({0})').format(curSite))
        
        if self.__currentSite is None:
            self.__e5project.pdata["TRANSLATIONPATTERN"] = []
        else:
            self.__e5project.pdata["TRANSLATIONPATTERN"] = [
                os.path.join(site, "locale", "%language%", "LC_MESSAGES", "django.po")
            ]
    
    def __site(self):
        """
        Private method to get the name of the current site.
        
        @exception DjangoNoSiteSelectedException raised, if no site is selected
        @return name of the site (string)
        """
        if self.__currentSite is None:
            self.__selectSite()
        
        if self.__currentSite is None:
            raise DjangoNoSiteSelectedException
        else:
            return self.__currentSite

    ##################################################################
    ## slots below implement run functions
    ##################################################################
    
##    def __runServer(self):
##        """
##        Private slot to start the Django Web server.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommand"))
##        if consoleCmd:
##            args = Utilities.parseOptionString(consoleCmd)
##            args[0] = Utilities.getExecutablePath(args[0])
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("runserver")
##            addr = self.__plugin.getPreferences("ServerAddress")
##            if addr:
##                args.append(addr)
##            
##            try:
##                if Utilities.isWindowsPlatform():
##                    serverProcStarted, pid = \
##                        QProcess.startDetached(args[0], args[1:], self.__sitePath())
##                else:
##                    if self.__serverProc is not None:
##                        self.__serverProcFinished()
##                    
##                    self.__serverProc = QProcess()
##                    self.connect(self.__serverProc, 
##                                 SIGNAL('finished(int, QProcess::ExitStatus)'),
##                                 self.__serverProcFinished)
##                    self.__serverProc.setWorkingDirectory(self.__sitePath())
##                    self.__serverProc.start(args[0], args[1:])
##                    serverProcStarted = self.__serverProc.waitForStarted()
##                if not serverProcStarted:
##                    KQMessageBox.critical(None,
##                        self.trUtf8('Process Generation Error'),
##                        self.trUtf8('The Django server could not be started.'))
##            except DjangoNoSiteSelectedException:
##                pass
##    
##    def __serverProcFinished(self):
##        """
##        Private slot connected to the finished signal.
##        """
##        if self.__serverProc is not None and \
##           self.__serverProc.state() != QProcess.NotRunning:
##            self.__serverProc.terminate()
##            QTimer.singleShot(2000, self.__serverProc, SLOT('kill()'))
##            self.__serverProc.waitForFinished(3000)
##        self.__serverProc = None
##    
##    def __runBrowser(self):
##        """
##        Private slot to start the default web browser with the server URL.
##        """
##        addr = self.__plugin.getPreferences("ServerAddress")
##        if addr:
##            if ':' in addr:
##                port = addr.split(':')[1]
##            else:
##                port = addr
##        else:
##            port = QString("8000")
##        url = QUrl(QString("http://127.0.0.1:%1").arg(port))
##        res = QDesktopServices.openUrl(url)
##        if not res:
##            KQMessageBox.critical(None,
##                self.trUtf8('Run Web-Browser'),
##                self.trUtf8('Could not start the web-browser for the url "%1".')\
##                    .arg(url.toString()))

    ##################################################################
    ## slots below implement database related functions
    ##################################################################
    
##    def __databaseSynchronize(self):
##        """
##        Private slot to synchronize the database.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommandNoClose"))
##        if consoleCmd:
##            proc = QProcess()
##            args = Utilities.parseOptionString(consoleCmd)
##            args[0] = Utilities.getExecutablePath(args[0])
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("syncdb")
##            try:
##                wd = self.__sitePath()
##                started, pid = QProcess.startDetached(args[0], args[1:], wd)
##                if not started:
##                    KQMessageBox.critical(None,
##                        self.trUtf8('Process Generation Error'),
##                        self.trUtf8('The Django process could not be started.'))
##            except DjangoNoSiteSelectedException:
##                pass
##    
##    def __databaseInspect(self):
##        """
##        Private slot to introspect the database and output a Django model module.
##        """
##        title = self.trUtf8("Introspect Database")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("inspectdb")
##        
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dia = DjangoDialog(title, fixed = True, linewrap = False)
##        res = dia.startProcess(args, path, False)
##        if res:
##            dia.exec_()
##    
##    def __databaseFlush(self):
##        """
##        Private slot to return all database tables to the state just after their 
##        installation.
##        """
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        title = self.trUtf8("Flush Database")
##        
##        res = KQMessageBox.question(self.__ui,
##            title,
##            self.trUtf8("""Flushing the database will destroy all data. Are you sure?"""),
##            QMessageBox.StandardButtons(\
##                QMessageBox.No | \
##                QMessageBox.Yes),
##            QMessageBox.No)
##        if res == QMessageBox.No:
##            return
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("flush")
##        args.append("--noinput")
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = self.trUtf8("Database tables flushed successfully."))
##        res = dia.startProcess(args, path)
##        if res:
##            dia.exec_()
##    
##    def __databaseReset(self):
##        """
##        Private slot to reset the database tables of one or more applications.
##        """
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        title = self.trUtf8("Reset Application(s)")
##        
##        apps = self.__getApplications()
##        if apps.isEmpty():
##            return
##        
##        res = KQMessageBox.question(self.__ui,
##            title,
##            self.trUtf8("""Resetting the database tables for the applications '%1' """
##                        """will destroy all data. Are you sure?""")\
##                .arg(apps.join(", ")),
##            QMessageBox.StandardButtons(\
##                QMessageBox.No | \
##                QMessageBox.Yes),
##            QMessageBox.No)
##        if res == QMessageBox.No:
##            return
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("reset")
##        args.append("--noinput")
##        args += apps
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = self.trUtf8("Database tables for applications '%1' reset "
##                                     "successfully.").arg(apps.join(", "))
##        )
##        res = dia.startProcess(args, path)
##        if res:
##            dia.exec_()
##    
##    def __runDatabaseClient(self):
##        """
##        Private slot to start a database client for a Django project.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommand"))
##        if consoleCmd:
##            proc = QProcess()
##            args = Utilities.parseOptionString(consoleCmd)
##            args[0] = Utilities.getExecutablePath(args[0])
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("dbshell")
##            try:
##                wd = self.__sitePath()
##                started, pid = QProcess.startDetached(args[0], args[1:], wd)
##                if not started:
##                    KQMessageBox.critical(None,
##                        self.trUtf8('Process Generation Error'),
##                        self.trUtf8('The Django process could not be started.'))
##            except DjangoNoSiteSelectedException:
##                pass
    
    #######################################################################
    ## slots below implement database functions outputting SQL statements
    #######################################################################
    
##    def __sqlCommand(self, title, command, requestApps = True):
##        """
##        Private method to perform an SQL creation function.
##        
##        @param title dialog title (string or QString)
##        @param command Django sql... command (string or QString)
##        @param requestApps flag indicating to request a list of applications
##            to work on (boolean)
##        """
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        if requestApps:
##            apps = self.__getApplications()
##            if apps.isEmpty():
##                return
##        else:
##            apps = QStringList()
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append(command)
##        args += apps
##        
##        fileFilter = self.trUtf8("SQL Files (*.sql)")
##        
##        dia = DjangoDialog(title, fixed = True, linewrap = False, 
##                           saveFilters = fileFilter)
##        res = dia.startProcess(args, path, False)
##        if res:
##            dia.exec_()
##    
##    def __databaseSqlCreateTables(self):
##        """
##        Private slot to print the CREATE TABLE SQL statements for one 
##        or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Create Tables"), "sql")
##    
##    def __databaseSqlCreateIndexes(self):
##        """
##        Private slot to print the CREATE INDEX SQL statements for one 
##        or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Create Indexes"), "sqlindexes")
##    
##    def __databaseSqlCreateEverything(self):
##        """
##        Private slot to print the CREATE TABLE, custom SQL and 
##        CREATE INDEX SQL statements for one or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Create Everything"), "sqlall")
##    
##    def __databaseSqlCustom(self):
##        """
##        Private slot to print the custom table modifying SQL statements
##        for one or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Custom Statements"), "sqlcustom")
##    
##    def __databaseSqlDropTables(self):
##        """
##        Private slot to print the DROP TABLE SQL statements for one or
##        more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Drop Tables"), "sqlclear")
##    
##    def __databaseSqlFlushDatabase(self):
##        """
##        Private slot to print a list of statements to return all database
##        tables to their initial state.
##        """
##        self.__sqlCommand(self.trUtf8("Flush Database"), "sqlflush", False)
##    
##    def __databaseSqlResetApplication(self):
##        """
##        Private slot to print the DROP TABLE SQL, then the CREATE TABLE SQL 
##        for one or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Reset Application(s)"), "sqlreset")
##    
##    def __databaseSqlResetSequences(self):
##        """
##        Private slot to print the SQL statements for resetting sequences for
##        one or more applications.
##        """
##        self.__sqlCommand(self.trUtf8("Reset Sequences"), "sqlsequencereset")
    
    ##################################################################
    ## slots below implement some tool functions
    ##################################################################
    
##    def __diffSettings(self):
##        """
##        Private slot to show the changes made to the settings.py file.
##        """
##        title = self.trUtf8("Diff Settings")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("diffsettings")
##        
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dia = DjangoDialog(title, fixed = True, linewrap = False)
##        res = dia.startProcess(args, path, False)
##        if res:
##            dia.exec_()
##    
##    def __cleanup(self):
##        """
##        Private slot to clean out old data from the database.
##        """
##        title = self.trUtf8("Cleanup")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("cleanup")
##        
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = self.trUtf8("Database cleaned up successfully."))
##        res = dia.startProcess(args, path)
##        if res:
##            dia.exec_()
##    
##    def __validate(self):
##        """
##        Private slot to validate all installed models.
##        """
##        title = self.trUtf8("Validate")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("validate")
##        
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dia = DjangoDialog(title)
##        res = dia.startProcess(args, path)
##        if res:
##            dia.exec_()
##    
##    def __adminIndex(self):
##        """
##        Private slot to print the admin-index template snippet.
##        """
##        apps = self.__getApplications()
##        if apps.isEmpty():
##            return
##        
##        title = self.trUtf8("Print admin-index")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("adminindex")
##        args += apps
##        
##        try:
##            path = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dia = DjangoDialog(title, fixed = True, linewrap = False)
##        res = dia.startProcess(args, path, False)
##        if res:
##            dia.exec_()
##    
##    def __runPythonShell(self):
##        """
##        Private slot to start a Python console for a Django project.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommand"))
##        if consoleCmd:
##            proc = QProcess()
##            args = Utilities.parseOptionString(consoleCmd)
##            args[0] = Utilities.getExecutablePath(args[0])
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("shell")
##            if self.__plugin.getPreferences("UsePlainPython"):
##                args.append("--plain")
##            try:
##                wd = self.__sitePath()
##                started, pid = QProcess.startDetached(args[0], args[1:], wd)
##                if not started:
##                    KQMessageBox.critical(None,
##                        self.trUtf8('Process Generation Error'),
##                        self.trUtf8('The Django process could not be started.'))
##            except DjangoNoSiteSelectedException:
##                pass
    
    ##################################################################
    ## slots below implement caching functions
    ##################################################################
    
##    def __createCacheTables(self):
##        """
##        Private slot to create the tables for the SQL caching backend.
##        """
##        title = self.trUtf8("Create Cache Tables")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        tblStr, ok = KQInputDialog.getText(\
##            self.__ui,
##            title,
##            self.trUtf8("Enter the names of the cache tables separated by spaces."),
##            QLineEdit.Normal)
##        if ok and not tblStr.isEmpty():
##            tableNames = tblStr.split(" ", QString.SkipEmptyParts)
##            
##            args = QStringList()
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("createcachetable")
##            args += tableNames
##            
##            dia = DjangoDialog(title, 
##                msgSuccess = self.trUtf8("Cache tables created successfully."))
##            res = dia.startProcess(args, wd)
##            if res:
##                dia.exec_()
    
    ##################################################################
    ## slots below implement testing functions
    ##################################################################
    
##    def __dumpData(self):
##        """
##        Private slot to dump the database data to a fixture.
##        """
##        title = self.trUtf8("Dump Data")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dlg = DjangoDumpdataDataDialog(self, self.__ui)
##        if dlg.exec_() == QDialog.Accepted:
##            appls, excls, format = dlg.getData()
##            
##            args = QStringList()
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("dumpdata")
##            args.append("--format=%s" % format)
##            args.append("--indent=2")
##            for excl in excls:
##                args.append("--exclude=%s" % excl)
##            if not appls.isEmpty():
##                args += appls
##            
##            if format == "json":
##                fileFilters = self.trUtf8("JSON Files (*.json)")
##            elif format == "xml":
##                fileFilters = self.trUtf8("XML Files (*.xml)")
##            elif format == "yaml":
##                fileFilters = self.trUtf8("YAML Files (*.yaml)")
##            
##            dia = DjangoDialog(title, fixed = True, linewrap = False, 
##                saveFilters = fileFilters)
##            res = dia.startProcess(args, wd, showCommand = False)
##            if res:
##                dia.exec_()
##    
##    def __loadData(self):
##        """
##        Private slot to load data from fixture files.
##        """
##        title = self.trUtf8("Load Data")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            return
##        
##        dlg = DjangoLoaddataDataDialog(self, self.__ui)
##        if dlg.exec_() == QDialog.Accepted:
##            fixtures = dlg.getData()
##            
##            args = QStringList()
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("loaddata")
##            args += fixtures
##            
##            dia = DjangoDialog(title)
##            res = dia.startProcess(args, wd)
##            if res:
##                dia.exec_()
##    
##    def __runTestSuite(self):
##        """
##        Private slot to run the test suite for applications or the whole site.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommandNoClose"))
##        if consoleCmd:
##            try:
##                wd = self.__sitePath()
##            except DjangoNoSiteSelectedException:
##                return
##            
##            proc = QProcess()
##            args = Utilities.parseOptionString(consoleCmd)
##            args[0] = Utilities.getExecutablePath(args[0])
##            args.append(self.__getPythonExecutable())
##            args.append("manage.py")
##            args.append("test")
##            args += self.__getApplications()
##            
##            started, pid = QProcess.startDetached(args[0], args[1:], wd)
##            if not started:
##                KQMessageBox.critical(None,
##                    self.trUtf8('Process Generation Error'),
##                    self.trUtf8('The Django process could not be started.'))
##    
##    def __runTestServer(self):
##        """
##        Private slot to run a development server with data from a set of fixtures.
##        """
##        consoleCmd = unicode(self.__plugin.getPreferences("ConsoleCommand"))
##        if consoleCmd:
##            dlg = DjangoLoaddataDataDialog(self, self.__ui)
##            if dlg.exec_() == QDialog.Accepted:
##                fixtures = dlg.getData()
##                
##                args = Utilities.parseOptionString(consoleCmd)
##                args[0] = Utilities.getExecutablePath(args[0])
##                args.append(self.__getPythonExecutable())
##                args.append("manage.py")
##                args.append("testserver")
##                addr = self.__plugin.getPreferences("ServerAddress")
##                if addr:
##                    args.append("--addrport=%s" % addr)
##                args += fixtures
##                
##                try:
##                    if Utilities.isWindowsPlatform():
##                        serverProcStarted, pid = \
##                            QProcess.startDetached(args[0], args[1:], self.__sitePath())
##                    else:
##                        if self.__testServerProc is not None:
##                            self.__testServerProcFinished()
##                        
##                        self.__testServerProc = QProcess()
##                        self.connect(self.__testServerProc, 
##                            SIGNAL('finished(int, QProcess::ExitStatus)'),
##                            self.__serverProcFinished)
##                        
##                        self.__testServerProc.setWorkingDirectory(self.__sitePath())
##                        self.__testServerProc.start(args[0], args[1:])
##                        serverProcStarted = self.__testServerProc.waitForStarted()
##                    if not serverProcStarted:
##                        KQMessageBox.critical(None,
##                            self.trUtf8('Process Generation Error'),
##                            self.trUtf8('The Django test server could not be started.'))
##                except DjangoNoSiteSelectedException:
##                    pass
##    
##    def __testServerProcFinished(self):
##        """
##        Private slot connected to the finished signal of the test server.
##        """
##        if self.__testServerProc is not None and \
##           self.__testServerProc.state() != QProcess.NotRunning:
##            self.__testServerProc.terminate()
##            QTimer.singleShot(2000, self.__testServerProc, SLOT('kill()'))
##            self.__testServerProc.waitForFinished(3000)
##        self.__testServerProc = None
    
    ##################################################################
    ## slots below implement translation functions
    ##################################################################
    
##    def __getLocale(self, filename):
##        """
##        Private method to extract the locale out of a file name.
##        
##        @param filename name of the file used for extraction (string or QString)
##        @return extracted locale (string) or None
##        """
##        if self.__e4project.pdata["TRANSLATIONPATTERN"]:
##            pattern = unicode(self.__e4project.pdata["TRANSLATIONPATTERN"][0])\
##                .replace("%language%", "(.*?)")
##            match = re.search(pattern, unicode(filename))
##            if match is not None:
##                loc = match.group(1)
##                return loc
##            else:
##                loc = None
##        else:
##            loc = None
##        
##        return loc
##    
##    def __normalizeList(self, filenames):
##        """
##        Private method to normalize a list of file names.
##        
##        @param filenames list of file names to normalize (list of string or QString)
##        @return normalized file names (list of string)
##        """
##        nfilenames = []
##        for filename in filenames:
##            filename = unicode(filename)
##            if filename.endswith(".mo"):
##                filename = filename.replace(".mo", ".po")
##            if filename not in nfilenames:
##                nfilenames.append(filename)
##        
##        return nfilenames
##    
##    def __siteFilteredList(self, filenames):
##        """
##        Private method to filter a list of file names by site.
##        
##        @param filenames list of file names to be filtered (list of string or QString)
##        @return file names belonging to the current site (list of string)
##        """
##        site = self.__site()
##        nfilenames = []
##        for filename in filenames:
##            filename = unicode(filename)
##            if site == "" or filename.startswith(site + os.sep):
##                nfilenames.append(filename)
##        
##        return nfilenames
    
    def __projectLanguageAdded(self, code):
        """
        Private slot handling the addition of a new language.
        
        @param code language code of the new language (string or QString)
        """
##        title = self.trUtf8("Initializing message catalog for '%1'").arg(code)
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("makemessages")
##        args.append("-l")
##        args.append(code)
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No current site selected or no site created yet.'
##                            ' Aborting...'))
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = \
##                self.trUtf8("\nMessage catalog initialized successfully."))
##        res = dia.startProcess(args, wd)
##        if res:
##            dia.exec_()
##            
##            langFile = self.__e4project.pdata["TRANSLATIONPATTERN"][0]\
##                .replace("%language%", code)
##            self.__e4project.appendFile(langFile)
    
    def updateSelectedCatalogs(self, filenames):
        """
        Public method to update the message catalogs.
        
        @param filenames list of filenames
        """
##        title = self.trUtf8("Updating message catalogs")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No current site selected or no site created yet.'
##                            ' Aborting...'))
##            return
##        
##        argsLists = []
##        
##        for filename in self.__normalizeList(self.__siteFilteredList(filenames)):
##            locale = self.__getLocale(filename)
##            if locale:
##                args = QStringList()
##                args.append(self.__getPythonExecutable())
##                args.append("manage.py")
##                args.append("makemessages")
##                args.append("-l")
##                args.append(locale)
##                argsLists.append(args)
##        
##        if len(argsLists) == 0:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No locales detected.'
##                            ' Aborting...'))
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = \
##                self.trUtf8("\nMessage catalogs updated successfully."))
##        res = dia.startBatchProcesses(argsLists, wd)
##        if res:
##            dia.exec_()
    
    def updateCatalogs(self, filenames):
        """
        Public method to update the message catalogs.
        
        @param filenames list of filenames (not used)
        """
##        title = self.trUtf8("Updating message catalogs")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("makemessages")
##        args.append("-a")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No current site selected or no site created yet.'
##                            ' Aborting...'))
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = \
##                self.trUtf8("\nMessage catalogs updated successfully."))
##        res = dia.startProcess(args, wd)
##        if res:
##            dia.exec_()
    
    def compileSelectedCatalogs(self, filenames):
        """
        Public method to update the message catalogs.
        
        @param filenames list of filenames
        """
##        title = self.trUtf8("Compiling message catalogs")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No current site selected or no site created yet.'
##                            ' Aborting...'))
##            return
##        
##        argsLists = []
##        
##        for filename in self.__normalizeList(self.__siteFilteredList(filenames)):
##            locale = self.__getLocale(filename)
##            if locale:
##                args = QStringList()
##                args.append(self.__getPythonExecutable())
##                args.append("manage.py")
##                args.append("compilemessages")
##                args.append("-l")
##                args.append(locale)
##                argsLists.append(args)
##        
##        if len(argsLists) == 0:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No locales detected.'
##                            ' Aborting...'))
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = \
##                self.trUtf8("\nMessage catalogs compiled successfully."))
##        res = dia.startBatchProcesses(argsLists, wd, mergedOutput = True)
##        if res:
##            dia.exec_()
##            
##            for entry in os.walk(self.__sitePath()):
##                for fileName in entry[2]:
##                    fullName = os.path.join(entry[0], fileName)
##                    if fullName.endswith('.mo'):
##                        self.__e4project.appendFile(fullName)
    
    def compileCatalogs(self, filenames):
        """
        Public method to compile the message catalogs.
        
        @param filenames list of filenames (not used)
        """
##        title = self.trUtf8("Compiling message catalogs")
##        
##        args = QStringList()
##        args.append(self.__getPythonExecutable())
##        args.append("manage.py")
##        args.append("compilemessages")
##        
##        try:
##            wd = self.__sitePath()
##        except DjangoNoSiteSelectedException:
##            KQMessageBox.warning(None,
##                title,
##                self.trUtf8('No current site selected or no site created yet.'
##                            ' Aborting...'))
##            return
##        
##        dia = DjangoDialog(title, 
##            msgSuccess = \
##                self.trUtf8("\nMessage catalogs compiled successfully."))
##        res = dia.startProcess(args, wd, mergedOutput = True)
##        if res:
##            dia.exec_()
##            
##            for entry in os.walk(self.__sitePath()):
##                for fileName in entry[2]:
##                    fullName = os.path.join(entry[0], fileName)
##                    if fullName.endswith('.mo'):
##                        self.__e4project.appendFile(fullName)