Ignore:
Files:
1 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/application/canvasmain.py

    r11415 r11399  
    336336        self.dock_widget.setCollapsedWidget(dock2) 
    337337        self.dock_widget.setExpanded(True) 
    338         self.dock_widget.expandedChanged.connect(self._on_tool_dock_expanded) 
    339338 
    340339        self.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) 
     
    531530                    ) 
    532531 
    533         self.toggle_tool_dock_expand = \ 
    534             QAction(self.tr("Expand Tool Dock"), self, 
    535                     objectName="toggle-tool-dock-expand", 
    536                     checkable=True, 
    537                     checked=True, 
    538                     shortcut=QKeySequence(Qt.ControlModifier | 
    539                                           Qt.ShiftModifier | Qt.Key_D), 
    540                     triggered=self.set_tool_dock_expanded) 
    541  
    542532        # Gets assigned in setup_ui (the action is defined in CanvasToolDock) 
    543533        # TODO: This is bad (should be moved here). 
     
    607597            QActionGroup(self, objectName="toolbox-menu-group") 
    608598 
    609         self.view_menu.addAction(self.toggle_tool_dock_expand) 
    610  
     599        a1 = self.toolbox_menu.addAction(self.tr("Tool Box")) 
     600        a2 = self.toolbox_menu.addAction(self.tr("Tool List")) 
     601        self.toolbox_menu_group.addAction(a1) 
     602        self.toolbox_menu_group.addAction(a2) 
     603 
     604        self.view_menu.addMenu(self.toolbox_menu) 
    611605        self.view_menu.addSeparator() 
    612606        self.view_menu.addAction(self.toogle_margins_action) 
     
    11171111 
    11181112        dialog.deleteLater() 
    1119         model.deleteLater() 
    11201113 
    11211114        if status == QDialog.Accepted: 
     
    12301223 
    12311224        bottom_row = [self.get_started_action, tutorials_action, 
    1232                       self.documentation_action] 
     1225                   self.documentation_action] 
    12331226 
    12341227        self.new_action.triggered.connect(dialog.accept) 
     
    14541447        """ 
    14551448        self.__update_scheme_margins() 
    1456  
    1457     def set_tool_dock_expanded(self, expanded): 
    1458         """ 
    1459         Set the dock widget expanded state. 
    1460         """ 
    1461         self.dock_widget.setExpanded(expanded) 
    1462  
    1463     def _on_tool_dock_expanded(self, expanded): 
    1464         """ 
    1465         'dock_widget' widget was expanded/collapsed. 
    1466         """ 
    1467         if expanded != self.toggle_tool_dock_expand.isChecked(): 
    1468             self.toggle_tool_dock_expand.setChecked(expanded) 
    14691449 
    14701450    def createPopupMenu(self): 
     
    16841664        self.scheme_widget.setChannelNamesVisible(show_channel_names) 
    16851665 
    1686         node_animations = settings.value("enable-node-animations", 
    1687                                          defaultValue=False, 
    1688                                          type=bool) 
    1689         self.scheme_widget.setNodeAnimationEnabled(node_animations) 
    16901666        settings.endGroup() 
    16911667 
  • Orange/OrangeCanvas/application/settings.py

    r11416 r11320  
    234234        tab.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) 
    235235 
    236         nodes = QWidget(self, objectName="nodes") 
    237         nodes.setLayout(QVBoxLayout()) 
    238         nodes.layout().setContentsMargins(0, 0, 0, 0) 
    239  
    240         cb_anim = QCheckBox( 
    241             self.tr("Enable node animations"), 
    242             objectName="enable-node-animations", 
    243             toolTip=self.tr("Enable shadow and ping animations for node " 
    244                             "items in the scheme.") 
    245         ) 
    246         self.bind(cb_anim, "checked", "schemeedit/enable-node-animations") 
    247         nodes.layout().addWidget(cb_anim) 
    248  
    249         form.addRow(self.tr("Nodes"), nodes) 
    250  
    251236        links = QWidget(self, objectName="links") 
    252237        links.setLayout(QVBoxLayout()) 
     
    260245        ) 
    261246 
     247        cb_state = QCheckBox( 
     248            self.tr("Show link state"), 
     249            objectName="show-link-state", 
     250            toolTip=self.tr("Show link state") 
     251        ) 
     252 
    262253        self.bind(cb_show, "checked", "schemeedit/show-channel-names") 
     254        self.bind(cb_state, "checked", "schemeedit/show-link-state") 
    263255 
    264256        links.layout().addWidget(cb_show) 
     257        links.layout().addWidget(cb_state) 
    265258 
    266259        form.addRow(self.tr("Links"), links) 
     
    320313        toolbox.layout().setContentsMargins(0, 0, 0, 0) 
    321314 
    322         exclusive = QCheckBox(self.tr("Only one tab can be open at a time")) 
     315        exclusive = QCheckBox(self.tr("Exclusive"), 
     316                              toolTip="Only one tab can be opened at a time.") 
     317 
     318        floatable = QCheckBox(self.tr("Floatable"), 
     319                              toolTip="Toolbox can be undocked.") 
    323320 
    324321        self.bind(exclusive, "checked", "mainwindow/toolbox-dock-exclusive") 
     322        self.bind(floatable, "checked", "mainwindow/toolbox-dock-floatable") 
    325323 
    326324        toolbox.layout().addWidget(exclusive) 
     325        toolbox.layout().addWidget(floatable) 
    327326 
    328327        form.addRow(self.tr("Tool box"), toolbox) 
  • Orange/OrangeCanvas/canvas/items/nodeitem.py

    r11411 r11369  
    77 
    88from PyQt4.QtGui import ( 
    9     QGraphicsItem, QGraphicsObject, QGraphicsTextItem, 
    10     QGraphicsDropShadowEffect, QGraphicsView, 
     9    QGraphicsItem, QGraphicsPathItem, QGraphicsObject, 
     10    QGraphicsTextItem, QGraphicsDropShadowEffect, QGraphicsView, 
    1111    QPen, QBrush, QColor, QPalette, QIcon, QStyle, QPainter, 
    1212    QPainterPath, QPainterPathStroker, QApplication 
    1313) 
    1414 
    15 from PyQt4.QtCore import Qt, QPointF, QRectF, QSize, QTimer, QPropertyAnimation 
     15from PyQt4.QtCore import Qt, QPointF, QRectF, QSize, QTimer 
    1616from PyQt4.QtCore import pyqtSignal as Signal 
    1717from PyQt4.QtCore import pyqtProperty as Property 
     
    5656 
    5757 
    58 def animation_restart(animation): 
    59     if animation.state() == QPropertyAnimation.Running: 
    60         animation.pause() 
    61     animation.start() 
    62  
    63  
    6458SHADOW_COLOR = "#9CACB4" 
    6559FOCUS_OUTLINE_COLOR = "#609ED7" 
    6660 
    6761 
    68 class NodeBodyItem(GraphicsPathObject): 
     62class NodeBodyItem(QGraphicsPathItem): 
    6963    """ 
    7064    The central part (body) of the `NodeItem`. 
    7165    """ 
    7266    def __init__(self, parent=None): 
    73         GraphicsPathObject.__init__(self, parent) 
     67        QGraphicsPathItem.__init__(self, parent) 
    7468        assert(isinstance(parent, NodeItem)) 
    7569 
    7670        self.__processingState = 0 
    7771        self.__progress = -1 
    78         self.__animationEnabled = False 
    7972        self.__isSelected = False 
    8073        self.__hasFocus = False 
     
    9285 
    9386        self.shadow = QGraphicsDropShadowEffect( 
    94             blurRadius=3, 
     87            blurRadius=10, 
    9588            color=QColor(SHADOW_COLOR), 
    9689            offset=QPointF(0, 0), 
     
    9891 
    9992        self.setGraphicsEffect(self.shadow) 
    100         self.shadow.setEnabled(True) 
    101  
    102         self.__blurAnimation = QPropertyAnimation(self.shadow, "blurRadius", 
    103                                                   self) 
    104         self.__blurAnimation.setDuration(100) 
    105         self.__blurAnimation.finished.connect(self.__on_finished) 
    106  
    107         self.__pingAnimation = QPropertyAnimation(self, "scale", self) 
    108         self.__pingAnimation.setDuration(250) 
    109         self.__pingAnimation.setKeyValues([(0.0, 1.0), (0.5, 1.1), (1.0, 1.0)]) 
     93        self.shadow.setEnabled(False) 
    11094 
    11195    # TODO: The body item should allow the setting of arbitrary painter 
     
    129113        self.__updateBrush() 
    130114 
    131     def setAnimationEnabled(self, enabled): 
    132         """ 
    133         Set the node animation enabled. 
    134         """ 
    135         if self.__animationEnabled != enabled: 
    136             self.__animationEnabled = enabled 
    137  
    138115    def setProcessingState(self, state): 
    139116        """ 
    140117        Set the processing state of the node. 
    141118        """ 
    142         if self.__processingState != state: 
    143             self.__processingState = state 
    144             if not state and self.__animationEnabled: 
    145                 self.ping() 
     119        self.__processingState = state 
     120        self.update() 
    146121 
    147122    def setProgress(self, progress): 
     
    153128        self.__progress = progress 
    154129        self.update() 
    155  
    156     def ping(self): 
    157         """ 
    158         Trigger a 'ping' animation. 
    159         """ 
    160         animation_restart(self.__pingAnimation) 
    161130 
    162131    def hoverEnterEvent(self, event): 
    163132        self.__hover = True 
    164133        self.__updateShadowState() 
    165         return GraphicsPathObject.hoverEnterEvent(self, event) 
     134        return QGraphicsPathItem.hoverEnterEvent(self, event) 
    166135 
    167136    def hoverLeaveEvent(self, event): 
    168137        self.__hover = False 
    169138        self.__updateShadowState() 
    170         return GraphicsPathObject.hoverLeaveEvent(self, event) 
     139        return QGraphicsPathItem.hoverLeaveEvent(self, event) 
    171140 
    172141    def paint(self, painter, option, widget): 
     
    178147            # Prevent the default bounding rect selection indicator. 
    179148            option.state = option.state ^ QStyle.State_Selected 
    180         GraphicsPathObject.paint(self, painter, option, widget) 
     149        QGraphicsPathItem.paint(self, painter, option, widget) 
    181150 
    182151        if self.__progress >= 0: 
     
    200169            self.setPen(QPen(Qt.NoPen)) 
    201170 
    202         radius = 3 
    203171        enabled = False 
    204  
    205172        if self.__isSelected: 
     173            self.shadow.setBlurRadius(7) 
    206174            enabled = True 
    207             radius = 7 
    208  
    209         if self.__hover: 
    210             radius = 17 
     175        elif self.__hover: 
     176            self.shadow.setBlurRadius(17) 
    211177            enabled = True 
    212  
    213         if enabled and not self.shadow.isEnabled(): 
    214             self.shadow.setEnabled(enabled) 
    215  
    216         if self.__animationEnabled: 
    217             if self.__blurAnimation.state() == QPropertyAnimation.Running: 
    218                 self.__blurAnimation.pause() 
    219  
    220             self.__blurAnimation.setStartValue(self.shadow.blurRadius()) 
    221             self.__blurAnimation.setEndValue(radius) 
    222             self.__blurAnimation.start() 
    223         else: 
    224             self.shadow.setBlurRadius(radius) 
     178        self.shadow.setEnabled(enabled) 
    225179 
    226180    def __updateBrush(self): 
     
    261215        self.__hasFocus = focus 
    262216        self.__updateShadowState() 
    263  
    264     def __on_finished(self): 
    265         if self.shadow.blurRadius() == 0: 
    266             self.shadow.setEnabled(False) 
    267217 
    268218 
     
    742692 
    743693        self.__anchorLayout = None 
    744         self.__animationEnabled = False 
    745694 
    746695        self.setZValue(self.Z_VALUE) 
     
    778727        self.shapeItem = NodeBodyItem(self) 
    779728        self.shapeItem.setShapeRect(shape_rect) 
    780         self.shapeItem.setAnimationEnabled(self.__animationEnabled) 
    781729 
    782730        # Rect for widget's 'ears'. 
     
    907855        return self.captionTextItem.font() 
    908856 
    909     def setAnimationEnabled(self, enabled): 
    910         """ 
    911         Set the node animation enabled state. 
    912         """ 
    913         if self.__animationEnabled != enabled: 
    914             self.__animationEnabled = enabled 
    915             self.shapeItem.setAnimationEnabled(enabled) 
    916  
    917     def animationEnabled(self): 
    918         """ 
    919         Are node animations enabled. 
    920         """ 
    921         return self.__animationEnabled 
    922  
    923857    def setProcessingState(self, state): 
    924858        """ 
     
    933867                # Clear the progress meter. 
    934868                self.setProgress(-1) 
    935                 if self.__animationEnabled: 
    936                     self.shapeItem.ping() 
    937869 
    938870    def processingState(self): 
  • Orange/OrangeCanvas/canvas/scene.py

    r11411 r11369  
    100100 
    101101        self.__channel_names_visible = True 
    102         self.__node_animation_enabled = True 
    103102 
    104103        self.user_interaction_handler = None 
     
    218217        return self.__channel_names_visible 
    219218 
    220     def set_node_animation_enabled(self, enabled): 
    221         if self.__node_animation_enabled != enabled: 
    222             self.__node_animation_enabled = enabled 
    223  
    224             for node in self.__node_items: 
    225                 node.setAnimationEnabled(enabled) 
    226  
    227219    def add_node_item(self, item): 
    228220        """Add a :class:`NodeItem` instance to the scene. 
     
    309301            item.setWidgetCategory(category_desc) 
    310302 
    311         item.setAnimationEnabled(self.__node_animation_enabled) 
    312303        return item 
    313304 
  • Orange/OrangeCanvas/config.py

    r11411 r11388  
    7979     ("schemeedit/show-link-state", bool, True, 
    8080      "Show link state hints."), 
    81  
    82      ("schemeedit/enable-node-animations", bool, True, 
    83       "Enable node animations."), 
    8481 
    8582     ("schemeedit/freeze-on-load", bool, False, 
  • Orange/OrangeCanvas/document/quickmenu.py

    r11420 r11371  
    4848    A menu page in a :class:`QuickMenu` widget, showing a list of actions. 
    4949    Shown actions can be disabled by setting a filtering function using the 
    50     :func:`setFilterFunc`. 
     50    :ref:`setFilterFunc`. 
    5151 
    5252    """ 
     
    8080        return self.__title 
    8181 
    82     title_ = Property(unicode, fget=title, fset=setTitle, 
    83                       doc="Title of the page.") 
     82    title_ = Property(unicode, fget=title, fset=setTitle) 
    8483 
    8584    def setIcon(self, icon): 
     
    9796        return self.__icon 
    9897 
    99     icon_ = Property(QIcon, fget=icon, fset=setIcon, 
    100                      doc="Page icon") 
     98    icon_ = Property(QIcon, fget=icon, fset=setIcon) 
    10199 
    102100    def setFilterFunc(self, func): 
     
    113111    def setModel(self, model): 
    114112        """ 
    115         Reimplemented from :func:`ToolTree.setModel`. 
     113        Reimplemented from :ref:`ToolTree.setModel`. 
    116114        """ 
    117115        proxyModel = ItemDisableFilter(self) 
     
    121119    def setRootIndex(self, index): 
    122120        """ 
    123         Reimplemented from :func:`ToolTree.setRootIndex` 
     121        Reimplemented from :ref:`ToolTree.setRootIndex` 
    124122        """ 
    125123        proxyModel = self.view().model() 
     
    129127    def rootIndex(self): 
    130128        """ 
    131         Reimplemented from :func:`ToolTree.rootIndex` 
     129        Reimplemented from :ref:`ToolTree.rootIndex` 
    132130        """ 
    133131        proxyModel = self.view().model() 
     
    632630    A quick menu popup for the widgets. 
    633631 
    634     The widgets are set using :func:`QuickMenu.setModel` which must be a 
    635     model as returned by :func:`QtWidgetRegistry.model` 
    636  
    637     """ 
    638  
    639     #: An action has been triggered in the menu. 
     632    The widgets are set using :ref:`setModel` which must be a 
     633    model as returned by QtWidgetRegistry.model() 
     634 
     635    """ 
     636 
    640637    triggered = Signal(QAction) 
    641  
    642     #: An action has been hovered in the menu 
    643638    hovered = Signal(QAction) 
    644639 
     
    728723    def addPage(self, name, page): 
    729724        """ 
    730         Add the `page` (:class:`MenuPage`) with `name` and return it's index. 
    731         The `page.icon()` will be used as the icon in the tab bar. 
    732  
     725        Add the page and return it's index. 
    733726        """ 
    734727        icon = page.icon() 
     
    739732 
    740733        index = self.__pages.addPage(page, name, icon, tip) 
     734        # TODO: get the background. 
    741735 
    742736        # Route the page's signals 
     
    744738        page.hovered.connect(self.hovered) 
    745739 
    746         # Install event filter to intercept key presses. 
     740        # Install event filter to process key presses. 
    747741        page.view().installEventFilter(self) 
    748742 
     
    874868 
    875869    def exec_(self, pos=None): 
    876         """ 
    877         Execute the menu at position `pos` (in global screen coordinates). 
    878         Return the triggered :class:`QAction` or `None` if no action was 
    879         triggered. 
    880  
    881         """ 
    882870        self.popup(pos) 
    883871        self.setFocus(Qt.PopupFocusReason) 
     
    894882 
    895883    def hideEvent(self, event): 
    896         """ 
    897         Reimplemented from :class:`QWidget` 
    898         """ 
    899884        FramelessWindow.hideEvent(self, event) 
    900885        if self.__loop: 
     
    977962 
    978963class ItemViewKeyNavigator(QObject): 
    979     """ 
    980     A event filter class listening to key press events and responding 
    981     by moving 'currentItem` on a :class:`QListView`. 
    982  
    983     """ 
    984964    def __init__(self, parent=None): 
    985965        QObject.__init__(self, parent) 
     
    987967 
    988968    def setView(self, view): 
    989         """ 
    990         Set the QListView. 
    991         """ 
    992969        if self.__view != view: 
    993970            self.__view = view 
    994971 
    995972    def view(self): 
    996         """ 
    997         Return the view 
    998         """ 
    999973        return self.__view 
    1000974 
     
    10471021            curr = self.__view.currentIndex() 
    10481022            if curr.isValid(): 
    1049                 # TODO: Does this work? We are emitting signals that are 
    1050                 # defined by a different class. This might break some things. 
    1051                 # Should we just send the keyPress events to the view, and let 
    1052                 # it handle them. 
     1023                # TODO: Does this work 
    10531024                self.__view.activated.emit(curr) 
    10541025 
     
    10711042    """ 
    10721043    Automatically positioning :class:`QSizeGrip`. 
    1073     The widget automatically maintains its position in the window 
    1074     corner during resize events. 
    1075  
    10761044    """ 
    10771045    def __init__(self, parent): 
     
    10851053    def setCorner(self, corner): 
    10861054        """ 
    1087         Set the corner (:class:`Qt.Corner`) where the size grip should 
    1088         position itself. 
    1089  
     1055        Set the corner where the size grip should position itself. 
    10901056        """ 
    10911057        if corner not in [Qt.TopLeftCorner, Qt.TopRightCorner, 
  • Orange/OrangeCanvas/document/schemeedit.py

    r11411 r11390  
    116116        self.__emptyClickButtons = 0 
    117117        self.__channelNamesVisible = True 
    118         self.__nodeAnimationEnabled = True 
    119118        self.__possibleSelectionHandler = None 
    120119        self.__possibleMouseItemsMove = False 
     
    345344        scene = CanvasScene() 
    346345        scene.set_channel_names_visible(self.__channelNamesVisible) 
    347         scene.set_node_animation_enabled(self.__nodeAnimationEnabled) 
    348346        scene.setFont(self.font()) 
    349347 
     
    471469        """ 
    472470        return self.__channelNamesVisible 
    473  
    474     def setNodeAnimationEnabled(self, enabled): 
    475         """ 
    476         Set the node item animation enabled state. 
    477         """ 
    478         if self.__nodeAnimationEnabled != enabled: 
    479             self.__nodeAnimationEnabled = enabled 
    480             self.__scene.set_node_animation_enabled(enabled) 
    481  
    482     def nodeAnimationEnabled(self): 
    483         """ 
    484         Return the node item animation enabled state. 
    485         """ 
    486         return self.__nodeAnimationEnabled 
    487471 
    488472    def undoStack(self): 
     
    561545            self.__view.setScene(self.__scene) 
    562546            self.__scene.set_channel_names_visible(self.__channelNamesVisible) 
    563             self.__scene.set_node_animation_enabled( 
    564                 self.__nodeAnimationEnabled 
    565             ) 
    566  
    567547            self.__scene.setFont(self.font()) 
    568548 
  • Orange/OrangeCanvas/gui/dock.py

    r11414 r11366  
    1616from PyQt4.QtCore import Qt, QEvent 
    1717 
    18 from PyQt4.QtCore import pyqtProperty as Property, pyqtSignal as Signal 
     18from PyQt4.QtCore import pyqtProperty as Property 
    1919 
    2020from .stackedwidget import AnimatedStackedWidget 
     
    3131    and ``setCollapsedWidget``. 
    3232 
    33     .. note:: Do  not use the base class ``QDockWidget.setWidget`` method 
    34               to set the docks contents. Use set[Expanded|Collapsed]Widget 
    35               instead. 
     33    .. note:: Do use the base class ``QDockWidget.setWidget`` method to set 
     34              the contents. 
    3635 
    3736    """ 
    38  
    39     #: Emitted when the dock widget's expanded state changes. 
    40     expandedChanged = Signal(bool) 
    41  
    4237    def __init__(self, *args, **kwargs): 
    4338        QDockWidget.__init__(self, *args, **kwargs) 
     
    10398            self.__fixIcon() 
    10499 
    105             self.expandedChanged.emit(state) 
    106  
    107100    def expanded(self): 
    108101        """ 
    109         Is the dock widget in expanded state. If `True` the 
     102        Is the dock widget in expanded state. When `True` the 
    110103        ``expandedWidget`` will be shown, and ``collapsedWidget`` otherwise. 
    111104 
     
    138131            self.updateGeometry() 
    139132 
    140     def expandedWidget(self): 
     133    def expandedWidet(self): 
    141134        """ 
    142135        Return the widget previously set with ``setExpandedWidget``, 
  • Orange/OrangeCanvas/gui/toolbox.py

    r11417 r11366  
    230230            self.__exclusive = exclusive 
    231231            self.__tabActionGroup.setExclusive(exclusive) 
    232             checked = self.__tabActionGroup.checkedAction() 
    233             # Trigger/toggle remaining open pages 
    234             if exclusive and checked is not None: 
    235                 for page in self.__pages: 
    236                     if checked != page.action and page.action.isChecked(): 
    237                         page.action.trigger() 
    238232 
    239233    def exclusive(self): 
  • Orange/OrangeCanvas/preview/previewmodel.py

    r11413 r11191  
    5050            self.insertColumn(0, items) 
    5151 
    52         self.__timer = QTimer(self) 
    53  
    5452    def delayedScanUpdate(self, delay=10): 
    5553        """Run a delayed preview item scan update. 
     
    7371            try: 
    7472                iter_scan.next() 
     73                QTimer.singleShot(delay, process_one) 
    7574            except StopIteration: 
    76                 self.__timer.timeout.disconnect(process_one) 
    77                 self.__timer.stop() 
     75                pass 
    7876 
    79         self.__timer.timeout.connect(process_one) 
    80         self.__timer.start(delay) 
     77        QTimer.singleShot(delay, process_one) 
    8178 
    8279 
  • Orange/OrangeCanvas/registry/__init__.py

    r11418 r11368  
    11""" 
    2 ======== 
    3 Registry 
    4 ======== 
    5  
    62The registry module implements discovery and description of the widgets 
    73that are available/installed. The :class:`WidgetRegistry` is a repository 
  • Orange/OrangeCanvas/registry/base.py

    r11418 r11368  
    11""" 
    2 =============== 
    3 Widget Registry 
    4 =============== 
     2WidgetRegistry Base 
    53 
    64""" 
     
    2220    """ 
    2321    A container for widget and category descriptions. 
     22 
     23    This class is most often used with WidgetDiscovery class but can 
     24    be used separately. 
    2425 
    2526    >>> reg = WidgetRegistry() 
     
    3738        If supplied the registry is initialized with the contents of `other`. 
    3839 
    39     See also 
    40     -------- 
    41     WidgetDiscovery 
    42  
    4340    """ 
    4441 
     
    4643        # A list of (category, widgets_list) tuples ordered by priority. 
    4744        self.registry = [] 
    48  
    4945        # tuples from 'registry' indexed by name 
    5046        self._categories_dict = {} 
    51  
    52         # WidgetDecriptions by qualified name 
     47        # WidgetDscriptions by qualified name 
    5348        self._widgets_dict = {} 
    5449 
     
    6560        """ 
    6661        Return a list all top level :class:`CategoryDescription` instances 
    67         ordered by `priority`. 
     62        ordered by priority. 
    6863 
    6964        """ 
     
    7267    def category(self, name): 
    7368        """ 
    74         Find and return a :class:`CategoryDescription` by its `name`. 
     69        Find a :class:`CategoryDescription` by its `name`. 
    7570 
    7671        .. note:: Categories are identified by `name` attribute in contrast 
     
    8782    def has_category(self, name): 
    8883        """ 
    89         Return ``True`` if a category with `name` exist in this registry. 
     84        Does a category with `name` exist in this registry. 
    9085 
    9186        Parameters 
     
    135130            Widget description qualified name 
    136131 
     132        See also 
     133        -------- 
     134        WidgetDescription 
     135 
    137136        """ 
    138137        return self._widgets_dict[qualified_name] 
     
    140139    def has_widget(self, qualified_name): 
    141140        """ 
    142         Return ``True`` if the widget with `qualified_name` exists in 
    143         this registry. 
    144  
     141        Does the widget with `qualified_name` exist in this registry. 
    145142        """ 
    146143        return qualified_name in self._widgets_dict 
  • Orange/OrangeCanvas/registry/description.py

    r11418 r11368  
    5353 
    5454class InputSignal(object): 
    55     """ 
    56     Description of an input channel. 
     55    """Description of an input channel. 
    5756 
    5857    Parameters 
     
    117116 
    118117class OutputSignal(object): 
    119     """ 
    120     Description of an output channel. 
     118    """Description of an output channel. 
    121119 
    122120    Parameters 
     
    184182 
    185183class WidgetDescription(object): 
    186     """ 
    187     Description of a widget. 
     184    """Description of a widget. 
    188185 
    189186    Parameters 
     
    210207    project_name : str, optional 
    211208        The distribution name that provides the widget. 
    212     inputs : list of :class:`InputSignal`, optional 
     209    inputs : list of `InputSignal`, optional 
    213210        A list of input channels provided by the widget. 
    214     outputs : list of :class:`OutputSignal`, optional 
     211    outputs : list of `OutputSignal`, optional 
    215212        A list of output channels provided by the widget. 
    216213    help : str, optional 
     
    288285    @classmethod 
    289286    def from_file(cls, filename, import_name=None): 
    290         """ 
    291         Widget description from old style (2.5 version) widget 
     287        """Widget description from old style (2.5 version) widget 
    292288        descriptions. 
    293289 
     
    359355    @classmethod 
    360356    def from_module(cls, module): 
    361         """ 
    362         Get the widget description from a module. 
     357        """Get the widget description from a module. 
    363358 
    364359        The module is inspected for global variables (upper case versions of 
     
    454449 
    455450class CategoryDescription(object): 
    456     """ 
    457     Description of a widget category. 
     451    """Description of a widget category. 
    458452 
    459453    Parameters 
     
    462456    name : str 
    463457        A human readable name. 
    464     version : str, optional 
    465         Version string. 
    466     description : str, optional 
    467         A short description of the category, suitable for a tool tip. 
    468     long_description : str, optional 
     458    version : str 
     459        Version string (optional). 
     460    description : str 
     461        A short description of the category, suitable for a tool 
     462        tip (optional). 
     463    long_description : str 
    469464        A longer description. 
    470     qualified_name : str, 
     465    qualified_name : str 
    471466        Qualified name 
    472467    project_name : str 
     
    475470        Priority (order in the GUI). 
    476471    icon : str 
    477         An icon filename (a resource name retrievable using `pkg_resources` 
    478         relative to `qualified_name`). 
     472        An icon filename 
    479473    background : str 
    480474        An background color for widgets in this category. 
     
    518512    @classmethod 
    519513    def from_package(cls, package): 
    520         """ 
    521         Get the CategoryDescription from a package. 
     514        """Get the CategoryDescription from a package. 
    522515 
    523516        Parameters 
  • Orange/OrangeCanvas/scheme/__init__.py

    r11419 r11367  
    66The scheme package implements and defines the underlying workflow model. 
    77 
    8 The :class:`.Scheme` class represents the workflow and is composed of a set 
    9 of :class:`.SchemeNode` connected with :class:`.SchemeLink`, defining an 
     8The :class:`Scheme` class represents the workflow and is composed of a set 
     9of :class:`SchemeNode` connected with :class:`SchemeLink`, defining an 
    1010directed acyclic graph (DAG). Additionally instances of 
    11 :class:`.SchemeArrowAnnotation` or :class:`.SchemeTextAnnotation` can be 
     11:class:`SchemeArrowAnnotation` or :class:`SchemeTextAnnotation` can be 
    1212inserted into the scheme. 
    1313 
  • Orange/OrangeCanvas/scheme/link.py

    r11419 r11367  
    7171    """ 
    7272 
    73     #: The link enabled state has changed 
    7473    enabled_changed = Signal(bool) 
    75  
    76     #: The link dynamic enabled state has changed. 
    7774    dynamic_enabled_changed = Signal(bool) 
    7875 
  • Orange/OrangeCanvas/scheme/node.py

    r11419 r11367  
    8080                         (name, self.description.name)) 
    8181 
    82     #: The title of the node has changed 
     82    # The title of the node has changed 
    8383    title_changed = Signal(unicode) 
    8484 
     
    9393    def title(self): 
    9494        """ 
    95         The node title. 
     95        Return the node title. 
    9696        """ 
    9797        return self.__title 
     
    9999    title = Property(unicode, fset=set_title, fget=title) 
    100100 
    101     #: Position of the node in the scheme has changed 
     101    # Position of the node in the scheme has changed 
    102102    position_changed = Signal(tuple) 
    103103 
     
    118118    position = Property(tuple, fset=set_position, fget=position) 
    119119 
    120     #: Node's progress value has changed. 
     120    # Node's progress value has changed. 
    121121    progress_changed = Signal(float) 
    122122 
     
    131131    def progress(self): 
    132132        """ 
    133         The current progress value. -1 if progress is not set. 
     133        Return the current progress value. -1 if progress is not set. 
    134134        """ 
    135135        return self.__progress 
     
    137137    progress = Property(float, fset=set_progress, fget=progress) 
    138138 
    139     #: Node's processing state has changed. 
     139    # Node's processing state has changed. 
    140140    processing_state_changed = Signal(int) 
    141141 
     
    150150    def processing_state(self): 
    151151        """ 
    152         The node processing state, 0 for not processing, 1 the node is busy. 
     152        Return the node processing state, 0 for not processing, 1 the 
     153        node is busy. 
     154 
    153155        """ 
    154156        return self.__processing_state 
  • Orange/OrangeCanvas/scheme/scheme.py

    r11419 r11391  
    3030from .readwrite import scheme_to_ows_stream, parse_scheme 
    3131 
    32 from ..registry import WidgetDescription, InputSignal, OutputSignal 
     32from ..registry import WidgetDescription 
    3333 
    3434log = logging.getLogger(__name__) 
     
    201201        See also 
    202202        -------- 
    203         .SchemeNode, Scheme.add_node 
     203        SchemeNode, Scheme.add_node 
    204204 
    205205        """ 
     
    275275                 sink_node, sink_channel): 
    276276        """ 
    277         Create a new :class:`.SchemeLink` from arguments and add it to 
    278         the scheme. The new link is returned. 
     277        Create a new SchemeLink and add it to the scheme. 
     278 
     279        Same as:: 
     280 
     281            scheme.add_link(SchemeLink(source_node, source_channel, 
     282                                       sink_node, sink_channel)) 
    279283 
    280284        Parameters 
     
    282286        source_node : :class:`.SchemeNode` 
    283287            Source node of the new link. 
    284         source_channel : :class:`.OutputSignal` 
     288        source_channel : :class:`OutputSignal` 
    285289            Source channel of the new node. The instance must be from 
    286             ``source_node.output_channels()`` 
     290            `source_node.output_channels()` 
    287291        sink_node : :class:`.SchemeNode` 
    288292            Sink node of the new link. 
    289         sink_channel : :class:`.InputSignal` 
     293        sink_channel : :class:`InputSignal` 
    290294            Sink channel of the new node. The instance must be from 
    291             ``sink_node.input_channels()`` 
     295            `sink_node.input_channels()` 
    292296 
    293297        See also 
    294298        -------- 
    295         .SchemeLink, Scheme.add_link 
     299        SchemeLink, Scheme.add_link 
    296300 
    297301        """ 
     
    324328    def check_connect(self, link): 
    325329        """ 
    326         Check if the `link` can be added to the scheme and raise an 
    327         appropriate exception. 
     330        Check if the `link` can be added to the scheme. 
    328331 
    329332        Can raise: 
    330333            - :class:`TypeError` if `link` is not an instance of 
    331334              :class:`.SchemeLink` 
    332             - :class:`.SchemeCycleError` if the `link` would introduce a cycle 
    333             - :class:`.IncompatibleChannelTypeError` if the channel types are 
     335            - :class:`SchemeCycleError` if the `link` would introduce a cycle 
     336            - :class:`IncompatibleChannelTypeError` if the channel types are 
    334337              not compatible 
    335             - :class:`.SinkChannelError` if a sink channel has a `Single` flag 
     338            - :class:`SinkChannelError` if a sink channel has a `Single` flag 
    336339              specification and the channel is already connected. 
    337             - :class:`.DuplicatedLinkError` if a `link` duplicates an already 
     340            - :class:`DuplicatedLinkError` if a `link` duplicates an already 
    338341              present link. 
    339342 
     
    372375    def creates_cycle(self, link): 
    373376        """ 
    374         Return `True` if `link` would introduce a cycle in the scheme. 
    375  
    376         Parameters 
    377         ---------- 
    378         link : :class:`.SchemeLink` 
    379  
     377        Would the `link` if added to the scheme introduce a cycle. 
    380378        """ 
    381379        check_type(link, SchemeLink) 
     
    387385    def compatible_channels(self, link): 
    388386        """ 
    389         Return `True` if the channels in `link` have compatible types. 
    390  
    391         Parameters 
    392         ---------- 
    393         link : :class:`.SchemeLink` 
    394  
     387        Do the channels in `link` have compatible types. 
    395388        """ 
    396389        check_type(link, SchemeLink) 
     
    398391 
    399392    def can_connect(self, link): 
    400         """ 
    401         Return `True` if `link` can be added to the scheme. 
    402  
    403         See also 
    404         -------- 
    405         Scheme.check_connect 
    406  
    407         """ 
    408         check_type(link, SchemeLink) 
    409393        try: 
    410394            self.check_connect(link) 
    411395            return True 
    412         except (SchemeCycleError, IncompatibleChannelTypeError, 
    413                 SinkChannelError, DuplicatedLinkError): 
     396        except (SchemeCycleError, IncompatibleChannelTypeError): 
    414397            return False 
     398        except Exception: 
     399            raise 
    415400 
    416401    def upstream_nodes(self, start_node): 
    417402        """ 
    418         Return a set of all nodes upstream from `start_node` (i.e. 
    419         all ancestor nodes). 
    420  
    421         Parameters 
    422         ---------- 
    423         start_node : :class:`.SchemeNode` 
    424  
     403        Return a set of all nodes upstream from `start_node`. 
    425404        """ 
    426405        visited = set() 
     
    440419        """ 
    441420        Return a set of all nodes downstream from `start_node`. 
    442  
    443         Parameters 
    444         ---------- 
    445         start_node : :class:`.SchemeNode` 
    446  
    447421        """ 
    448422        visited = set() 
     
    464438        of the child in the workflow). Both nodes must be in the scheme. 
    465439 
    466         Parameters 
    467         ---------- 
    468         node : :class:`.SchemeNode` 
    469         child : :class:`.SchemeNode` 
    470  
    471440        """ 
    472441        return child in self.downstream_nodes(node) 
     
    486455    def input_links(self, node): 
    487456        """ 
    488         Return a list of all input links (:class:`.SchemeLink`) connected 
    489         to the `node` instance. 
    490  
     457        Return all input links connected to the `node` instance. 
    491458        """ 
    492459        return self.find_links(sink_node=node) 
     
    494461    def output_links(self, node): 
    495462        """ 
    496         Return a list of all output links (:class:`.SchemeLink`) connected 
    497         to the `node` instance. 
    498  
     463        Return all output links connected to the `node` instance. 
    499464        """ 
    500465        return self.find_links(source_node=node) 
  • Orange/OrangeCanvas/scheme/widgetsscheme.py

    r11411 r11391  
    5050        self.node_for_widget = {} 
    5151        self.signal_manager = WidgetsSignalManager(self) 
    52         self.signal_manager.processingStarted[SchemeNode].connect( 
    53             self.__on_processing_started 
    54         ) 
    55         self.signal_manager.processingFinished[SchemeNode].connect( 
    56             self.__on_processing_finished 
    57         ) 
    5852 
    5953    def add_node(self, node): 
     
    7064        # widget_for_node, etc. to be up to date. 
    7165        widget = self.create_widget_instance(node) 
     66 
    7267        Scheme.add_node(self, node) 
    7368 
     
    204199            QCoreApplication.sendEvent(self, event) 
    205200 
    206     def __on_processing_started(self, node): 
    207         node.set_processing_state(1) 
    208  
    209     def __on_processing_finished(self, node): 
    210         node.set_processing_state(0) 
    211  
    212201 
    213202class WidgetsSignalManager(SignalManager): 
  • Orange/OrangeCanvas/styles/orange.qss

    r11412 r11352  
    300300 
    301301PreviewDialog PreviewBrowser TextLabel#path-text { 
    302     font-size: 12px; 
     302    font-size: 12px; 
    303303} 
    304304 
    305305PreviewDialog PreviewBrowser QLabel#path-label { 
    306     font-size: 12px; 
    307 } 
    308  
    309 PreviewDialog DropShadowFrame { 
    310     qproperty-radius_: 10; 
    311     qproperty-color_: rgb(0, 0, 0, 100); 
     306    font-size: 12px; 
    312307} 
    313308 
  • docs/canvas/document.rst

    r11420 r11390  
    99 
    1010   document.schemeedit 
    11    document.quickmenu 
  • docs/canvas/scheme.link.rst

    r11419 r11367  
    1010.. autoclass:: SchemeLink 
    1111   :members: 
    12    :exclude-members: 
    13       enabled_changed, 
    14       dynamic_enabled_changed 
    1512   :member-order: bysource 
    1613   :show-inheritance: 
    17  
    18    .. autoattribute:: enabled_changed(enabled) 
    19  
    20    .. autoattribute:: dynamic_enabled_changed(enabled) 
  • docs/canvas/scheme.node.rst

    r11419 r11367  
    1010.. autoclass:: SchemeNode 
    1111   :members: 
    12    :exclude-members: 
    13       title_changed, 
    14       position_changed, 
    15       progress_changed, 
    16       processing_state_changed 
    1712   :member-order: bysource 
    1813   :show-inheritance: 
     
    2116 
    2217   .. autoattribute:: position_changed((x, y)) 
    23  
    24    .. autoattribute:: progress_changed(progress) 
    25  
    26    .. autoattribute:: processing_state_changed(state) 
  • docs/canvas/scheme.scheme.rst

    r11419 r11367  
    4343 
    4444      Signal emitted when a `annotation` is removed from the scheme. 
    45  
    46  
    47 .. autoclass:: SchemeCycleError 
    48    :show-inheritance: 
    49  
    50  
    51 .. autoclass:: IncompatibleChannelTypeError 
    52    :show-inheritance: 
    53  
    54  
    55 .. autoclass:: SinkChannelError 
    56    :show-inheritance: 
    57  
    58  
    59 .. autoclass:: DuplicatedLinkError 
    60    :show-inheritance: 
Note: See TracChangeset for help on using the changeset viewer.