Changeset 11614:a4aa7f9b09fd in orange


Ignore:
Timestamp:
07/02/13 15:23:49 (10 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Refactored widget state messages handling.

Moved the resposibility for handling messages (OWBaseWidget.widgetStateChanged)
to WidgetsScheme.

Added support for messages in base SchemeNode class.

Location:
Orange/OrangeCanvas
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/canvas/items/nodeitem.py

    r11525 r11614  
    2222from .utils import saturated, radial_gradient 
    2323 
     24from ...scheme.node import UserMessage 
    2425from ...registry import NAMED_COLORS 
    2526from ...resources import icon_loader 
     
    979980        """ 
    980981        pass 
     982 
     983    def setStateMessage(self, message): 
     984        """ 
     985        Set a state message to display over the item. 
     986 
     987        Parameters 
     988        ---------- 
     989        message : UserMessage 
     990            Message to display. `message.severity` is used to determine 
     991            the icon and `message.contents` is used as a tool tip. 
     992 
     993        """ 
     994        # TODO: Group messages by message_id not by severity 
     995        # and deprecate set[Error|Warning|Error]Message 
     996        if message.severity == UserMessage.Info: 
     997            self.setInfoMessage(message.contents) 
     998        elif message.severity == UserMessage.Warning: 
     999            self.setWarningMessage(message.contents) 
     1000        elif message.severity == UserMessage.Error: 
     1001            self.setErrorMessage(message.contents) 
    9811002 
    9821003    def setErrorMessage(self, message): 
  • Orange/OrangeCanvas/canvas/scene.py

    r11558 r11614  
    333333        node.progress_changed.connect(item.setProgress) 
    334334        node.processing_state_changed.connect(item.setProcessingState) 
     335        node.state_message_changed.connect(item.setStateMessage) 
    335336 
    336337        return self.add_node_item(item) 
     
    388389        node.progress_changed.disconnect(item.setProgress) 
    389390        node.processing_state_changed.disconnect(item.setProcessingState) 
     391        node.state_message_changed.disconnect(item.setStateMessage) 
    390392 
    391393        self.remove_node_item(item) 
  • Orange/OrangeCanvas/document/schemeedit.py

    r11550 r11614  
    589589            if self.__scheme: 
    590590                self.__scheme.title_changed.disconnect(self.titleChanged) 
    591                 self.__scheme.node_added.disconnect(self.__onNodeAdded) 
    592                 self.__scheme.node_removed.disconnect(self.__onNodeRemoved) 
    593591                self.__scheme.removeEventFilter(self) 
    594592 
     
    599597            if self.__scheme: 
    600598                self.__scheme.title_changed.connect(self.titleChanged) 
    601                 self.__scheme.node_added.connect(self.__onNodeAdded) 
    602                 self.__scheme.node_removed.connect(self.__onNodeRemoved) 
    603599                self.titleChanged.emit(scheme.title) 
    604600                self.__cleanSettings = scheme.widget_settings() 
     
    619615 
    620616            if self.__scheme: 
    621                 for node in self.__scheme.nodes: 
    622                     self.__onNodeAdded(node) 
    623  
    624617                self.__scheme.installEventFilter(self) 
    625618 
     
    12291222            QCoreApplication.sendEvent(self, ev) 
    12301223 
    1231     def __onNodeAdded(self, node): 
    1232         widget = self.__scheme.widget_for_node[node] 
    1233         widget.widgetStateChanged.connect(self.__onWidgetStateChanged) 
    1234  
    1235     def __onNodeRemoved(self, node): 
    1236         widget = self.__scheme.widget_for_node[node] 
    1237         widget.widgetStateChanged.disconnect(self.__onWidgetStateChanged) 
    1238  
    1239     def __onWidgetStateChanged(self, *args): 
    1240         widget = self.sender() 
    1241         self.scheme() 
    1242         widget_to_node = dict(reversed(item) for item in \ 
    1243                               self.__scheme.widget_for_node.items()) 
    1244         node = widget_to_node[widget] 
    1245         item = self.__scene.item_for_node(node) 
    1246  
    1247         info = widget.widgetStateToHtml(True, False, False) 
    1248         warning = widget.widgetStateToHtml(False, True, False) 
    1249         error = widget.widgetStateToHtml(False, False, True) 
    1250  
    1251         item.setInfoMessage(info or None) 
    1252         item.setWarningMessage(warning or None) 
    1253         item.setErrorMessage(error or None) 
    1254  
    12551224    def __onNodeActivate(self, item): 
    12561225        node = self.__scene.node_for_item(item) 
  • Orange/OrangeCanvas/scheme/node.py

    r11419 r11614  
    99from PyQt4.QtCore import pyqtSignal as Signal 
    1010from PyQt4.QtCore import pyqtProperty as Property 
     11 
     12 
     13class UserMessage(object): 
     14    """ 
     15    A user message that should be displayed in a scheme view. 
     16 
     17    Paramaters 
     18    ---------- 
     19    contents : str 
     20        Message text. 
     21    severity : int 
     22        Message severity. 
     23    message_id : A hashable object 
     24        Message id. 
     25    data : dict 
     26        A dictionary with optional extra data. 
     27 
     28    """ 
     29    #: Severity flags 
     30    Info, Warning, Error = 1, 2, 3 
     31 
     32    def __init__(self, contents, severity=Info, message_id=None, data={}): 
     33        self.contents = contents 
     34        self.severity = severity 
     35        self.message_id = message_id 
     36        self.data = dict(data) 
    1137 
    1238 
     
    4268        self.__progress = -1 
    4369        self.__processing_state = 0 
     70        self.__state_messages = {} 
    4471        self.properties = properties or {} 
    4572 
     
    167194                        fget=tool_tip) 
    168195 
     196    def set_state_message(self, message): 
     197        """ 
     198        Set a message to be displayed by a scheme view for this node. 
     199        """ 
     200        if message.message_id in self.__state_messages and \ 
     201                not message.contents: 
     202            del self.__state_messages[message.message_id] 
     203 
     204        self.__state_messages[message.message_id] = message 
     205 
     206        self.state_message_changed.emit(message) 
     207 
     208    #: The node's state message has changed 
     209    state_message_changed = Signal(UserMessage) 
     210 
    169211    def __str__(self): 
    170212        return u"SchemeNode(description_id=%s, title=%r, ...)" % \ 
  • Orange/OrangeCanvas/scheme/widgetsscheme.py

    r11563 r11614  
    2626from .signalmanager import SignalManager, compress_signals, can_enable_dynamic 
    2727from .scheme import Scheme, SchemeNode 
     28from .node import UserMessage 
    2829from .utils import name_lookup, check_arg, check_type 
    2930from ..resources import icon_loader 
     
    145146        widget.progressBarValueChanged.connect(node.set_progress) 
    146147        widget.processingStateChanged.connect(node.set_processing_state) 
     148        widget.widgetStateChanged.connect(self.__on_widget_state_changed) 
    147149        self.connect(widget, 
    148150                     SIGNAL("blockingStateChanged(bool)"), 
     
    159161        return [self.widget_for_node[node].getSettings(alsoContexts=False) 
    160162                for node in self.nodes] 
     163 
     164    def __on_widget_state_changed(self, message_type, message_id, 
     165                                  message_value): 
     166        """ 
     167        The OWBaseWidget info/warning/error state has changed. 
     168 
     169        message_type is one of "Info", "Warning" or "Error" string depending 
     170        of which method (information, warning, error) was called. message_id 
     171        is the first int argument if supplied, and message_value the message 
     172        text. 
     173 
     174        """ 
     175        widget = self.sender() 
     176        node = self.node_for_widget.get(widget) 
     177        if node is not None: 
     178            message_type = str(message_type) 
     179            if message_type == "Info": 
     180                contents = widget.widgetStateToHtml(True, False, False) 
     181                level = UserMessage.Info 
     182            elif message_type == "Warning": 
     183                contents = widget.widgetStateToHtml(False, True, False) 
     184                level = UserMessage.Warning 
     185            elif message_type == "Error": 
     186                contents = widget.widgetStateToHtml(False, False, True) 
     187                level = UserMessage.Error 
     188            else: 
     189                raise ValueError("Invalid message_type: %r" % message_type) 
     190 
     191            if not contents: 
     192                contents = None 
     193 
     194            message = UserMessage(contents, severity=level, 
     195                                  message_id=message_type, 
     196                                  data={"contents-type": "text/html"}) 
     197            node.set_state_message(message) 
    161198 
    162199    def sync_node_properties(self): 
Note: See TracChangeset for help on using the changeset viewer.