Refactor to use new protocol module and sipo.

[bertos.git] / wizard / BToolchainPage.py

diff --git a/wizard/BToolchainPage.py b/wizard/BToolchainPage.py
index 9d575a13ebf3c7deb54ce918287f108076f66946..041a8069a8c86cb62034ae8d33d9daa4da984d1f 100644 (file)
--- a/wizard/BToolchainPage.py
+++ b/wizard/BToolchainPage.py
@@ -1,10 +1,33 @@
 #!/usr/bin/env python
 # encoding: utf-8
 #
 #!/usr/bin/env python
 # encoding: utf-8
 #

+# This file is part of BeRTOS.
+#
+# Bertos is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+# As a special exception, you may use this file as part of a free software
+# library without restriction.  Specifically, if other files instantiate
+# templates or use macros or inline functions from this file, or you compile
+# this file and link it with other files to produce an executable, this
+# file does not by itself cause the resulting executable to be covered by
+# the GNU General Public License.  This exception does not however
+# invalidate any other reasons why the executable file might be covered by
+# the GNU General Public License.
+#

 # Copyright 2008 Develer S.r.l. (http://www.develer.com/)
 # Copyright 2008 Develer S.r.l. (http://www.develer.com/)

-# All rights reserved.

 #
 #

-# $Id$

 #
 # Author: Lorenzo Berni <duplo@develer.com>
 #
 #
 # Author: Lorenzo Berni <duplo@develer.com>
 #


@@ -13,10 +36,14 @@ import os
 import collections
 
 from BWizardPage import *
 import collections
 
 from BWizardPage import *

+from BCreationPage import BCreationPage
+

 import BToolchainSearch
 import bertos_utils
 import qvariant_converter
 
 import BToolchainSearch
 import bertos_utils
 import qvariant_converter
 

+from toolchain_manager import ToolchainManager
+

 from const import *
 
 class BToolchainPage(BWizardPage):
 from const import *
 
 class BToolchainPage(BWizardPage):


@@ -28,7 +55,9 @@ class BToolchainPage(BWizardPage):
     def __init__(self):
         BWizardPage.__init__(self, UI_LOCATION + "/toolchain_select.ui")
         self.setTitle(self.tr("Select toolchain"))
     def __init__(self):
         BWizardPage.__init__(self, UI_LOCATION + "/toolchain_select.ui")
         self.setTitle(self.tr("Select toolchain"))

-        self._validation_process = None
+        self.setSubTitle(self.tr("You can look for more toolchains in your system by pressing the \"Search\" button, or manually add them with the \"+\" button"))
+        self._valid_items = []
+        self._toolchain_manager = ToolchainManager()

 
     ## Overloaded QWizardPage methods. ##
 
 
     ## Overloaded QWizardPage methods. ##
 


@@ -43,6 +72,16 @@ class BToolchainPage(BWizardPage):
         else:
             return False
 
         else:
             return False
 

+    def nextId(self):
+        """
+        Overload of the QWizardPage nextId method.
+        """
+        # Route to Output page if it's a predefined easy project.
+        if self.projectInfo("PROJECT_FROM_PRESET") and self.projectInfo("BASE_MODE"):
+            return self.wizard().pageIndex(BCreationPage)
+        else:
+            return QWizardPage.nextId(self)
+

     ####
 
     ## Overloaded BWizardPage methods. ##
     ####
 
     ## Overloaded BWizardPage methods. ##


@@ -57,19 +96,22 @@ class BToolchainPage(BWizardPage):
         """
         Connects the signals with the related slots.
         """
         """
         Connects the signals with the related slots.
         """

-        self.connect(self.pageContent.toolchainList, SIGNAL("itemSelectionChanged()"), self.selectionChanged)
+        self.connect(self.pageContent.toolchainList, SIGNAL("currentItemChanged(QListWidgetItem *, QListWidgetItem*)"), self.selectionChanged)

         self.connect(self.pageContent.addButton, SIGNAL("clicked()"), self.addToolchain)
         self.connect(self.pageContent.removeButton, SIGNAL("clicked()"), self.removeToolchain)
         self.connect(self.pageContent.searchButton, SIGNAL("clicked()"), self.searchToolchain)
         self.connect(self.pageContent.checkButton, SIGNAL("clicked()"), self.validateAllToolchains)
 
         self.connect(self.pageContent.addButton, SIGNAL("clicked()"), self.addToolchain)
         self.connect(self.pageContent.removeButton, SIGNAL("clicked()"), self.removeToolchain)
         self.connect(self.pageContent.searchButton, SIGNAL("clicked()"), self.searchToolchain)
         self.connect(self.pageContent.checkButton, SIGNAL("clicked()"), self.validateAllToolchains)
 

-    def reloadData(self):
+    def reloadData(self, previous_id=None):

         """
         Overload of the BWizard reloadData method.
         """
         """
         Overload of the BWizard reloadData method.
         """

-        self._clearList()
-        self.setupUi()
-        self._populateToolchainList()
+        if previous_id is None or previous_id < self.wizard().currentId():
+            self._clearList()
+            self.setupUi()
+            self._populateToolchainList()
+            if len(self._valid_items) >= 1:
+                self.pageContent.toolchainList.setCurrentItem(self._valid_items[0])

 
     ####
 
 
     ####
 


@@ -84,6 +126,10 @@ class BToolchainPage(BWizardPage):
             infos.update(qvariant_converter.getStringDict(self.pageContent.toolchainList.currentItem().data(Qt.UserRole)))
             self.pageContent.infoLabel.setText("GCC " + infos["version"] + " (" + infos["build"] + ")\nTarget: " + infos["target"] + "\nPath: " + os.path.normpath(infos["path"]))
             self.pageContent.infoLabel.setVisible(True)
             infos.update(qvariant_converter.getStringDict(self.pageContent.toolchainList.currentItem().data(Qt.UserRole)))
             self.pageContent.infoLabel.setText("GCC " + infos["version"] + " (" + infos["build"] + ")\nTarget: " + infos["target"] + "\nPath: " + os.path.normpath(infos["path"]))
             self.pageContent.infoLabel.setVisible(True)

+            if self.isDefaultToolchain(infos):
+                self.disableRemoveButton()
+            else:
+                self.enableRemoveButton()

             self.emit(SIGNAL("completeChanged()"))
 
     def addToolchain(self):
             self.emit(SIGNAL("completeChanged()"))
 
     def addToolchain(self):


@@ -95,9 +141,7 @@ class BToolchainPage(BWizardPage):
             item = QListWidgetItem(sel_toolchain)
             item.setData(Qt.UserRole, qvariant_converter.convertStringDict({"path": sel_toolchain}))
             self.pageContent.toolchainList.addItem(item)
             item = QListWidgetItem(sel_toolchain)
             item.setData(Qt.UserRole, qvariant_converter.convertStringDict({"path": sel_toolchain}))
             self.pageContent.toolchainList.addItem(item)

-            toolchains = self.toolchains()
-            toolchains[sel_toolchain] = False
-            self.setToolchains(toolchains)
+            self._toolchain_manager.addToolchain(sel_toolchain)

 
     def removeToolchain(self):
         """
 
     def removeToolchain(self):
         """


@@ -106,9 +150,7 @@ class BToolchainPage(BWizardPage):
         if self.pageContent.toolchainList.currentRow() != -1:
             item = self.pageContent.toolchainList.takeItem(self.pageContent.toolchainList.currentRow())
             toolchain = qvariant_converter.getStringDict(item.data(Qt.UserRole))["path"]
         if self.pageContent.toolchainList.currentRow() != -1:
             item = self.pageContent.toolchainList.takeItem(self.pageContent.toolchainList.currentRow())
             toolchain = qvariant_converter.getStringDict(item.data(Qt.UserRole))["path"]

-            toolchains = self.toolchains()
-            del toolchains[toolchain]
-            self.setToolchains(toolchains)
+            self._toolchain_manager.removeToolchain(toolchain)

 
     def searchToolchain(self):
         """
 
     def searchToolchain(self):
         """


@@ -124,10 +166,14 @@ class BToolchainPage(BWizardPage):
         Slot called when the user clicks on the validate button. It starts the
         toolchain validation procedure for all the toolchains.
         """
         Slot called when the user clicks on the validate button. It starts the
         toolchain validation procedure for all the toolchains.
         """

-        QApplication.instance().setOverrideCursor(Qt.WaitCursor)
-        for i in range(self.pageContent.toolchainList.count()):
-            self.validateToolchain(i)
-        QApplication.instance().restoreOverrideCursor()
+        try:
+            QApplication.instance().setOverrideCursor(Qt.WaitCursor)
+            for i in range(self.pageContent.toolchainList.count()):
+                data = qvariant_converter.getStringDict(self.pageContent.toolchainList.item(i).data(Qt.UserRole))
+                self.validateToolchain(data["path"])
+            self._populateToolchainList()
+        finally:
+            QApplication.instance().restoreOverrideCursor()

 
     ####
 
 
     ####
 


@@ -135,16 +181,44 @@ class BToolchainPage(BWizardPage):
         """
         Fills the toolchain list with the toolchains stored in the QSettings.
         """
         """
         Fills the toolchain list with the toolchains stored in the QSettings.
         """

-        toolchains = self.toolchains()
+        self.pageContent.toolchainList.clear()
+        self._valid_items = []
+        toolchains = self._toolchain_manager.predefined_toolchains + self._toolchain_manager.toolchains
+        toolchain_dict = {
+            'valid': [],
+            'non-valid': [],
+            'unknown': [],
+            'unverified': [],
+        }
+        for key, value in toolchains:
+            if os.path.exists(key):
+                item_data = {"path":key}
+                if value:
+                    item_data.update(value)
+                if value is not None:
+                    k, data = self.validateToolchain(key)
+                    item_data.update(data)
+                    toolchain_dict[k].append(item_data)
+                else:
+                    toolchain_dict["unverified"].append(item_data)
+        self._processItems(toolchain_dict["valid"], self._validItem)
+        self._processItems(toolchain_dict["non-valid"], self._invalidItem)
+        self._processItems(toolchain_dict["unknown"], self._unknownItem)
+        self._processItems(toolchain_dict["unverified"])
+
+    def _processItems(self, item_list, procedure=lambda x: None):

         sel_toolchain = self.projectInfo("TOOLCHAIN")
         sel_toolchain = self.projectInfo("TOOLCHAIN")

-        for key, value in toolchains.items():
-            item = QListWidgetItem(key)
-            item.setData(Qt.UserRole, qvariant_converter.convertStringDict({"path": key}))
+        for item_data in item_list:
+            item = QListWidgetItem(item_data["path"])
+            item.setData(Qt.UserRole, qvariant_converter.convertStringDict(item_data))

             self.pageContent.toolchainList.addItem(item)
             self.pageContent.toolchainList.addItem(item)

-            if sel_toolchain is not None and sel_toolchain["path"] == key:
+            procedure(item)
+            if sel_toolchain and sel_toolchain["path"] == item_data["path"]:

                 self.pageContent.toolchainList.setCurrentItem(item)
                 self.pageContent.toolchainList.setCurrentItem(item)

-            if value:
-                self.validateToolchain(self.pageContent.toolchainList.row(item))
+
+    def currentToolchain(self):
+        selected_toolchain = qvariant_converter.getStringDict(self.pageContent.toolchainList.currentItem().data(Qt.UserRole))
+        return selected_toolchain

 
     def _clearList(self):
         """
 
     def _clearList(self):
         """


@@ -160,70 +234,66 @@ class BToolchainPage(BWizardPage):
         dir_list = self.searchDirList()
         if self.pathSearch():
             dir_list += [element for element in bertos_utils.getSystemPath()]
         dir_list = self.searchDirList()
         if self.pathSearch():
             dir_list += [element for element in bertos_utils.getSystemPath()]

+        _toolchain_dict = self._toolchain_manager.storedToolchainDict()

         toolchain_list = bertos_utils.findToolchains(dir_list)
         toolchain_list = bertos_utils.findToolchains(dir_list)

-        stored_toolchains = self.toolchains()
-        for element in toolchain_list:
-            if not element in stored_toolchains:
-                item = QListWidgetItem(element)
-                item.setData(Qt.UserRole, qvariant_converter.convertStringDict({"path": element}))
-                self.pageContent.toolchainList.addItem(item)
-                stored_toolchains[element] = False
-        self.setToolchains(stored_toolchains)
+        for toolchain in toolchain_list:
+            self._toolchain_manager.addToolchain(toolchain, _toolchain_dict.get(toolchain, False))
+        self._populateToolchainList()
+        self.showMessage(self.tr("Toolchain search result."), self.tr("%1 toolchains found").arg(len(toolchain_list)))

 
 

-    def _validItem(self, index, infos):
+    def _validItem(self, item):

         """
         Sets the item at index as a valid item and associates the given info to it.
         """
         """
         Sets the item at index as a valid item and associates the given info to it.
         """

-        item = self.pageContent.toolchainList.item(index)
-        new_data = qvariant_converter.getStringDict(self.pageContent.toolchainList.item(index).data(Qt.UserRole))
-        new_data.update(infos)
-        item.setData(Qt.UserRole, qvariant_converter.convertStringDict(new_data))
-        needed = self.projectInfo("CPU_INFOS")
-        if "target" in infos and infos["target"].find(needed["TOOLCHAIN"]) != -1:
-            item.setIcon(QIcon(":/images/ok.png"))
-        else:
-            item.setIcon(QIcon(":/images/warning.png"))
-        if "version" in infos and "target" in infos:
-            item.setText("GCC " + infos["version"] + " - " + infos["target"].strip())
+        data = qvariant_converter.getStringDict(item.data(Qt.UserRole))
+        item.setIcon(QIcon(":/images/ok.png"))
+        self._valid_items.append(item)
+        if "version" in data and "target" in data:
+            item.setText("GCC " + data["version"] + " - " + data["target"].strip())
+
+    def _invalidItem(self, item):
+        data = qvariant_converter.getStringDict(item.data(Qt.UserRole))
+        item.setIcon(QIcon(":/images/warning.png"))
+        if "version" in data and "target" in data:
+            item.setText("GCC " + data["version"] + " - " + data["target"].strip())

 
 

-    def _invalidItem(self, index):
+    def _unknownItem(self, item):

         """
         Sets the item at index as an invalid item.
         """
         """
         Sets the item at index as an invalid item.
         """

-        item = self.pageContent.toolchainList.item(index)

         item.setIcon(QIcon(":/images/error.png"))
 
         item.setIcon(QIcon(":/images/error.png"))
 

-    def validateToolchain(self, i):
+    def validateToolchain(self, filename):

         """
         Toolchain validation procedure.
         """
         """
         Toolchain validation procedure.
         """

-        filename = qvariant_converter.getStringDict(self.pageContent.toolchainList.item(i).data(Qt.UserRole))["path"]
-        valid = False
-        info = {}
-        # Check for the other tools of the toolchain
-        for tool in TOOLCHAIN_ITEMS:
-            if os.path.exists(filename.replace("gcc", tool)):
-                valid = True
-            else:
-                valid = False
-                break
-        # Try to retrieve the informations about the toolchain only for the valid toolchains
-        if valid:
-            self._validation_process = QProcess()
-            self._validation_process.start(filename, ["-v"])
-            self._validation_process.waitForStarted(1000)
-            if self._validation_process.waitForFinished(200):
-                description = str(self._validation_process.readAllStandardError())
-                info = bertos_utils.getToolchainInfo(description)
-                if len(info) >= 4:
-                    valid = True
+        info = self._toolchain_manager.validateToolchain(filename)
+        if info:
+            needed = self.projectInfo("CPU_INFOS")
+            if "target" in info and info["target"].find(needed["TOOLCHAIN"]) != -1:
+                return 'valid', info

             else:
             else:

-                self._validation_process.kill()
-        # Add the item in the list with the appropriate associate data.
-        if valid:
-            self._validItem(i, info)
+                return 'non-valid', info

         else:
         else:

-            self._invalidItem(i)
-        toolchains = self.toolchains()
-        toolchains[filename] = True
-        self.setToolchains(toolchains)
\ No newline at end of file
+            return 'unknown', {'path': filename}
+    
+    def isDefaultToolchain(self, toolchain):
+        """
+        Returns True if the given toolchain is one of the default toolchains.
+        """
+        return toolchain["path"] in self._toolchain_manager._predefined_toolchain_set
+    
+    def disableRemoveButton(self):
+        """
+        Disable the remove button.
+        """
+        self.pageContent.removeButton.setEnabled(False)
+    
+    def enableRemoveButton(self):
+        """
+        Enable the remove button.
+        """
+        self.pageContent.removeButton.setEnabled(True)
+        
+    def currentItem(self):
+        return self.pageContent.toolchainList.currentItem()