Changeset 4963:2010d8017235 in orange


Ignore:
Timestamp:
07/14/08 13:38:11 (6 years ago)
Author:
gregor <gregor@…>
Branch:
default
Convert:
26ea5d3f76ec4ff28fbc70d813d70e2ca0f1aca8
Message:
  • added icon size 40x40
  • removed moveToGrid
  • code cleanup
  • changed saving schemes to applications
Location:
orange/OrangeCanvas
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeCanvas/orngCanvas.pyw

    r4897 r4963  
    1717        self.recentDocs = [] 
    1818        self.iDocIndex = 1 
    19         self.iconSizeList = ["32 x 32", "48 x 48", "60 x 60"] 
     19        self.iconSizeList = ["32 x 32", "40 x 40", "48 x 48", "60 x 60"] 
    2020        self.iconSizeDict = dict((val, int(val[:2])) for val in self.iconSizeList) 
    2121        self.originalPalette = QApplication.palette() 
     
    565565                for widget in win.widgets: 
    566566                    widget.setCoords(widget.x(), widget.y()) 
    567                     widget.moveToGrid() 
    568567                    widget.repaintAllLines() 
    569568                win.canvas.update() 
     
    864863        else: 
    865864            QApplication.setPalette(self.originalPalette) 
    866          
     865 
    867866 
    868867    def setStatusBarEvent(self, text): 
  • orange/OrangeCanvas/orngCanvasItems.py

    r4911 r4963  
    5353        self.colors = [] 
    5454        self.caption = "" 
    55         outPoint = outWidget.getRightEdgePoint() 
    56         inPoint = inWidget.getLeftEdgePoint() 
    57         #self.setLine(outPoint.x(), outPoint.y(), inPoint.x(), inPoint.y()) 
    58         #self.setPen(QPen(self.canvasDlg.lineColor, 5, Qt.SolidLine)) 
    5955        self.updateLinePos() 
    6056 
     
    8278 
    8379    def paint(self, painter, option, widget = None): 
    84         x1, x2 = self.line().x1(), self.line().x2() + 4 
     80        x1, x2 = self.line().x1(), self.line().x2() 
    8581        y1, y2 = self.line().y1(), self.line().y2() 
    8682 
     
    8884        else:                 lineStyle = Qt.DashLine 
    8985 
    90         painter.setPen(QPen(self.canvasDlg.lineColor, 5 , lineStyle)) 
     86        painter.setPen(QPen(self.canvasDlg.lineColor, 4 , lineStyle)) 
    9187        painter.drawLine(x1, y1, x2, y2) 
    9288 
     
    9995    # set the line positions based on the position of input and output widgets 
    10096    def updateLinePos(self): 
    101         x1 = self.outWidget.x() + 68 - 2 
    102         y1 = self.outWidget.y() + 26 
    103         x2 = self.inWidget.x() + 2 
    104         y2 = self.inWidget.y() + 26 
    105         self.setLine(x1, y1, x2, y2) 
    106         self.updateTooltip() 
     97        p1 = self.outWidget.getRightEdgePoint() 
     98        p2 = self.inWidget.getLeftEdgePoint() 
     99        self.setLine(p1.x(), p1.y(), p2.x(), p2.y()) 
     100        #self.updateTooltip() 
    107101 
    108102    def updateTooltip(self): 
     
    119113 
    120114 
    121 IOBoxWidth = 11 
    122 IOBoxHeight = 22 
    123 WidgetIconHeight = 48 
    124 WidgetIconWidth = 48 
    125 WidgetWidth = WidgetIconWidth + 2*IOBoxWidth + 2 
    126 WidgetHeight = WidgetIconHeight + 2 + 14 
    127 RectWidth = 3 
    128  
    129  
    130115# ####################################### 
    131116# # CANVAS WIDGET 
    132117# ####################################### 
    133118class CanvasWidget(QGraphicsRectItem): 
    134     def __init__(self, signalManager, canvas, view, widget, defaultPic, canvasDlg): 
     119    def __init__(self, signalManager, canvas, view, widget, defaultPic, canvasDlg, widgetSettings = {}): 
    135120        # import widget class and create a class instance 
    136         exec(compile("import " + widget.getFileName(), ".", "single")) 
    137         self.instance = eval(compile(widget.getFileName() + "." + widget.getFileName() + "(signalManager = signalManager)", ".", "eval")) 
     121        m = __import__(widget.getFileName()) 
     122        self.instance = m.__dict__[widget.getFileName()].__new__(m.__dict__[widget.getFileName()], _owInfo = canvasDlg.settings["owInfo"], _owWarning = canvasDlg.settings["owWarning"], _owError = canvasDlg.settings["owError"], _owShowStatus = canvasDlg.settings["owShow"], _useContexts = canvasDlg.settings["useContexts"], _category = widget.getCategory(), _settingsFromSchema = widgetSettings) 
     123        self.instance.__init__(signalManager=signalManager) 
     124 
    138125        self.instance.setProgressBarHandler(view.progressBarHandler)   # set progress bar event handler 
    139126        self.instance.setProcessingHandler(view.processingHandler) 
    140127        self.instance.setWidgetStateHandler(self.updateWidgetState) 
    141         self.instance._owInfo = canvasDlg.settings["owInfo"] 
    142         self.instance._owWarning = canvasDlg.settings["owWarning"] 
    143         self.instance._owError = canvasDlg.settings["owError"] 
    144         self.instance._owShowStatus = canvasDlg.settings["owShow"] 
     128        self.instance.setEventHandler(canvasDlg.output.widgetEvents) 
     129        self.instance.setWidgetIcon(widget.getFullIconName()) 
    145130        #self.instance.updateStatusBarState() 
    146         self.instance._useContexts = canvasDlg.settings["useContexts"] 
    147131 
    148132        QGraphicsRectItem.__init__(self, None, canvas) 
     
    154138        self.image = QPixmap(widget.getFullIconName()) 
    155139 
    156         self.imageLeftEdge = QPixmap(os.path.join(canvasDlg.picsDir,"leftEdge.png")) 
    157         self.imageRightEdge = QPixmap(os.path.join(canvasDlg.picsDir,"rightEdge.png")) 
    158         self.imageFrame = QPixmap(os.path.join(canvasDlg.picsDir,"frame.png")) 
    159         self.imageCircle = QPixmap(os.path.join(canvasDlg.picsDir,"circle.png")) 
    160  
    161         self.setRect(0,0, WidgetWidth, WidgetHeight) 
     140        canvasPicsDir  = os.path.join(canvasDlg.canvasDir, "icons") 
     141        self.imageLeftEdge = QPixmap(os.path.join(canvasPicsDir,"leftEdge.png")) 
     142        self.imageRightEdge = QPixmap(os.path.join(canvasPicsDir,"rightEdge.png")) 
     143        self.imageLeftEdgeG = QPixmap(os.path.join(canvasPicsDir,"leftEdgeG.png")) 
     144        self.imageRightEdgeG = QPixmap(os.path.join(canvasPicsDir,"rightEdgeG.png")) 
     145        self.imageLeftEdgeR = QPixmap(os.path.join(canvasPicsDir,"leftEdgeR.png")) 
     146        self.imageRightEdgeR = QPixmap(os.path.join(canvasPicsDir,"rightEdgeR.png")) 
     147        self.shownLeftEdge, self.shownRightEdge = self.imageLeftEdge, self.imageRightEdge 
     148        self.imageFrame = QPixmap(os.path.join(canvasPicsDir, "frame.png")) 
     149        self.widgetSize = QSizeF(self.imageFrame.size()) 
     150        self.edgeSize = QSizeF(self.imageLeftEdge.size()) 
     151 
     152        self.setRect(0,0, self.widgetSize.width(), self.widgetSize.height()) 
    162153        self.selected = False 
    163154        self.invalidPosition = False    # is the widget positioned over other widgets 
     
    166157        self.caption = widget.name 
    167158        self.progressBarShown = 0 
    168         self.xPos = 0 
    169         self.yPos = 0 
    170         self.oldXPos = 0 
    171         self.oldYPos = 0 
    172         self.viewXPos = 0 # this two variables are used as offset for 
    173         self.viewYPos = 0 # tooltip placement inside canvasView 
    174         self.lastRect = QRect(0,0,0,0) 
     159        self.oldPos = self.pos()         
    175160        self.isProcessing = 0   # is this widget currently processing signals 
    176161        self.widgetState = {} 
     
    186171            self.instance.restoreWidgetPosition() 
    187172 
    188         # set icon 
    189         if os.path.exists(widget.getFullIconName()): 
    190             self.instance.setWidgetIcon(widget.getFullIconName()) 
    191         elif os.path.exists(os.path.join(canvasDlg.widgetDir, widget.getIconName())): 
    192             self.instance.setWidgetIcon(os.path.join(canvasDlg.widgetDir, widget.getIconName())) 
    193         elif os.path.exists(os.path.join(canvasDlg.picsDir, widget.getIconName())): 
    194             self.instance.setWidgetIcon(os.path.join(canvasDlg.picsDir, widget.getIconName())) 
    195         else: 
    196             self.instance.setWidgetIcon(defaultPic) 
    197  
    198173    # get the list of connected signal names 
    199174    def getInConnectedSignalNames(self): 
     
    214189    def remove(self): 
    215190        self.hide() 
     191        self.errorIcon.hide() 
     192        self.warningIcon.hide() 
     193        self.infoIcon.hide() 
    216194 
    217195        # save settings 
     
    228206 
    229207    def savePosition(self): 
    230         self.oldXPos = self.xPos 
    231         self.oldYPos = self.yPos 
     208        self.oldPos = self.pos() 
    232209 
    233210    def restorePosition(self): 
    234         self.setCoords(self.oldXPos, self.oldYPos) 
     211        self.setPos(self.oldPos) 
    235212 
    236213    def updateText(self, text): 
     
    248225        self.errorIcon.hide() 
    249226 
    250         yPos = self.y() - 18 - self.progressBarShown * 23 
     227        yPos = self.y() - 21 - self.progressBarShown * 20 
    251228        iconNum = sum([widgetState.get("Info", {}).values() != [],  widgetState.get("Warning", {}).values() != [], widgetState.get("Error", {}).values() != []]) 
    252229 
     
    277254    # set coordinates of the widget 
    278255    def setCoords(self, x, y): 
    279         if x > 0 and x < self.canvas.width():  self.xPos = x 
    280         if y > 0 and y < self.canvas.height() - 60: self.yPos = y 
    281         self.setPos(self.xPos, self.yPos) 
     256        if self.canvasDlg.settings["snapToGrid"]: 
     257            x = round(x/10)*10 
     258            y = round(y/10)*10 
     259        pos = self.pos() 
     260        if x > 0 and x < self.canvas.width():  pos.setX(x) 
     261        if y > 0 and y < self.canvas.height() - 60: pos.setY(y) 
     262        self.setPos(pos) 
    282263        self.updateLinePosition() 
    283264        self.updateWidgetState() 
    284265 
    285  
    286     # move existing coorinates by dx, dy 
    287     def setCoordsBy(self, dx, dy): 
    288         self.setCoords(self.xPos + dx, self.yPos + dy) 
    289  
    290     def moveToGrid(self): 
    291         (x,y) = (self.xPos, self.yPos) 
    292         self.setCoords(round(self.xPos/10)*10, round(self.yPos/10)*10) 
    293         self.xPos = x 
    294         self.yPos = y 
    295266 
    296267    # is mouse position inside the left signal channel 
     
    298269        if self.widget.getInputs() == []: return False 
    299270 
    300         LBox = QRectF(self.x()+6, self.y()+ (WidgetIconHeight-IOBoxHeight)/2 + RectWidth, IOBoxWidth, IOBoxHeight) 
    301         if isinstance(pos, QPointF) and LBox.contains(pos): return True 
    302         elif isinstance(pos, QRectF) and LBox.intersects(pos): return True 
     271        boxRect = QRectF(self.x()-self.edgeSize.width(), self.y() + (self.widgetSize.height()-self.edgeSize.height())/2, self.edgeSize.width(), self.edgeSize.height()) 
     272        boxRect.adjust(-4,-4,4,4)       # enlarge the rectangle 
     273        if isinstance(pos, QPointF) and boxRect.contains(pos): return True 
     274        elif isinstance(pos, QRectF) and boxRect.intersects(pos): return True 
    303275        else: return False 
    304276 
     
    307279        if self.widget.getOutputs() == []: return False 
    308280 
    309         RBox = QRectF(self.x() + IOBoxWidth + WidgetIconWidth + 2 - 8, self.y()+ (WidgetIconHeight-IOBoxHeight)/2 + RectWidth, IOBoxWidth+4, IOBoxHeight) 
    310         if isinstance(pos, QPointF) and RBox.contains(pos): return True 
    311         elif isinstance(pos, QRectF) and RBox.intersects(pos): return True 
     281        boxRect = QRectF(self.x()+self.widgetSize.width(), self.y() + (self.widgetSize.height()-self.edgeSize.height())/2, self.edgeSize.width(), self.edgeSize.height()) 
     282        boxRect.adjust(-4,-4,4,4)       # enlarge the rectangle 
     283        if isinstance(pos, QPointF) and boxRect.contains(pos): return True 
     284        elif isinstance(pos, QRectF) and boxRect.intersects(pos): return True 
    312285        else: return False 
    313286 
    314  
     287    def canConnect(self, outWidget, inWidget): 
     288        if outWidget == inWidget: return 
     289        outputs = [outWidget.instance.getOutputType(output.name) for output in outWidget.widget.getOutputs()] 
     290        inputs = [inWidget.instance.getInputType(input.name) for input in inWidget.widget.getInputs()] 
     291        canConnect = 0 
     292        for outtype in outputs: 
     293            if True in [issubclass(outtype, intype) for intype in inputs]: 
     294                canConnect = 1 
     295                break 
     296 
     297        if outWidget == self: 
     298            self.shownRightEdge = canConnect and self.imageRightEdgeG or self.imageRightEdgeR 
     299        else: 
     300            self.shownLeftEdge = canConnect and self.imageLeftEdgeG or self.imageLeftEdgeR         
     301 
     302    def resetLeftRightEdges(self): 
     303        self.shownLeftEdge = self.imageLeftEdge 
     304        self.shownRightEdge = self.imageRightEdge 
     305     
     306     
    315307    # we know that the mouse was pressed inside a channel box. We only need to find 
    316308    # inside which one it was 
    317309    def getEdgePoint(self, pos): 
    318310        if self.mouseInsideLeftChannel(pos): 
    319             return QPoint(self.x() + IOBoxWidth/2, self.y() + WidgetIconHeight/2 + RectWidth) 
     311            return self.getLeftEdgePoint() 
    320312        elif self.mouseInsideRightChannel(pos): 
    321             return QPoint(self.x()+ IOBoxWidth + WidgetIconWidth + 2 + IOBoxWidth/2, self.y() + WidgetIconHeight/2 + RectWidth) 
    322  
     313            return self.getRightEdgePoint() 
    323314 
    324315    def getLeftEdgePoint(self): 
    325         return QPoint(self.x(), self.y() + WidgetIconHeight/2 + RectWidth) 
     316        return QPointF(self.x()- self.edgeSize.width(), self.y() + self.widgetSize.height()/2) 
    326317 
    327318    def getRightEdgePoint(self): 
    328         return QPoint(self.x()+ IOBoxWidth + WidgetIconWidth + 2 + IOBoxWidth/2, self.y() + WidgetIconHeight/2 + RectWidth) 
     319        return QPointF(self.x()+ self.widgetSize.width() + self.edgeSize.width(), self.y() + self.widgetSize.height()/2) 
    329320 
    330321    # draw the widget 
     
    339330            painter.setPen(QPen(color)) 
    340331#            painter.setBrush(QBrush(color)) 
    341             painter.drawRect(IOBoxWidth+1-RectWidth, 0, WidgetIconWidth+2*RectWidth, WidgetIconHeight+2*RectWidth) 
    342  
    343  
    344 #        if self.widget.getInputs() != []:    painter.drawPixmap(8, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth + 5, self.imageCircle) 
    345 #        if self.widget.getOutputs() != []:   painter.drawPixmap(IOBoxWidth + WidgetIconWidth - 7, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth + 5, self.imageCircle) 
    346         painter.drawPixmap(IOBoxWidth + 1, RectWidth, self.imageFrame) 
    347         painter.drawPixmap(IOBoxWidth + 1, RectWidth, self.image) 
    348  
    349 #        if self.widget.getInputs() != []:    painter.drawPixmap(0, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth, self.imageLeftEdge) 
    350 #        if self.widget.getOutputs() != []:   painter.drawPixmap(IOBoxWidth + WidgetIconWidth + 2, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth, self.imageRightEdge) 
    351         if self.widget.getInputs() != []:    painter.drawPixmap(5, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth + 5, self.imageLeftEdge) 
    352         if self.widget.getOutputs() != []:   painter.drawPixmap(IOBoxWidth + WidgetIconWidth-6, (WidgetIconHeight-IOBoxHeight)/2 + RectWidth + 5, self.imageRightEdge) 
     332            painter.drawRect(-3, -3, self.widgetSize.width()+6, self.widgetSize.height()+6) 
     333 
     334 
     335        painter.drawPixmap(0, 0, self.imageFrame) 
     336        painter.drawPixmap(0, 0, self.image) 
     337 
     338        if self.widget.getInputs() != []:    painter.drawPixmap(-self.edgeSize.width(), (self.widgetSize.height()-self.edgeSize.height())/2, self.shownLeftEdge) 
     339        if self.widget.getOutputs() != []:   painter.drawPixmap(self.widgetSize.width(), (self.widgetSize.height()-self.edgeSize.height())/2, self.shownRightEdge) 
    353340 
    354341        # draw the label 
    355342        painter.setPen(QPen(QColor(0,0,0))) 
    356         midX, midY = WidgetWidth/2., 2 + WidgetIconHeight + 5 
     343        midX, midY = self.widgetSize.width()/2., self.widgetSize.height() + 5 
    357344        painter.drawText(midX-200/2, midY, 200, 20, Qt.AlignTop | Qt.AlignHCenter, self.caption) 
    358345 
    359         yPos = -20 
     346        yPos = -22 
    360347        if self.progressBarShown: 
    361             rect = QRectF(IOBoxWidth, yPos, WidgetIconWidth+2, 16) 
     348            rect = QRectF(0, yPos, self.widgetSize.width(), 16) 
    362349            painter.setPen(QPen(QColor(0,0,0))) 
    363350            painter.setBrush(QBrush(QColor(255,255,255))) 
     
    365352 
    366353            painter.setBrush(QBrush(QColor(0,128,255))) 
    367             painter.drawRect(QRectF(IOBoxWidth, -20, (WidgetIconWidth+2)*self.progressBarValue/100., 16)) 
     354            painter.drawRect(QRectF(0, yPos, self.widgetSize.width()*self.progressBarValue/100., 16)) 
    368355            painter.drawText(rect, Qt.AlignCenter, "%d %%" % (self.progressBarValue)) 
    369356 
     
    391378 
    392379    def updateLineCoords(self): 
    393         for line in self.inLines: 
     380        for line in self.inLines + self.outLines: 
    394381            line.updateLinePos() 
    395             #line.repaintLine(self.view) 
    396         for line in self.outLines: 
    397             line.updateLinePos() 
    398             #line.repaintLine(self.view) 
    399  
    400 ##    def repaintWidget(self): 
    401 ##        (x,y,w,h) = ( self.x(), self.y(), self.rect().width(), self.rect().height() ) 
    402 ##        self.view.repaint(x-20, y-20, w+40,h+40) 
    403  
    404 ##    def repaintAllLines(self): 
    405 ##        for line in self.inLines: 
    406 ##            line.repaintLine(self.view) 
    407 ##        for line in self.outLines: 
    408 ##            line.repaintLine(self.view) 
     382         
    409383 
    410384    def updateTooltip(self): 
  • orange/OrangeCanvas/orngDlgs.py

    r4877 r4963  
    3030        self.setRenderHint(QPainter.Antialiasing) 
    3131 
    32     def addSignalList(self, outName, inName, outputs, inputs, outIconName, inIconName): 
    33         for item in self.scene().items(): item.hide() 
     32    def addSignalList(self, outWidget, inWidget): 
     33        self.scene().clear() 
     34        outputs, inputs = outWidget.widget.getOutputs(), inWidget.widget.getInputs() 
     35        outIconName, inIconName = outWidget.widget.getFullIconName(), inWidget.widget.getFullIconName() 
    3436        self.lines = [] 
    3537        self.outBoxes = [] 
     
    3739        self.texts = [] 
    3840        xSpaceBetweenWidgets = 100  # space between widgets 
    39         xWidgetOff = 10     # offset for widget position 
    40         yWidgetOffTop = 10     # offset for widget position 
    41         yWidgetOffBottom = 30     # offset for widget position 
    42         ySignalOff = 10     # space between the top of the widget and first signal 
    43         ySignalSpace = 50   # space between two neighbouring signals 
    44         ySignalSize = 20    # height of the signal box 
    45         xSignalSize = 20    # width of the signal box 
     41        xWidgetOff = 10             # offset for widget position 
     42        yWidgetOffTop = 10          # offset for widget position 
     43        yWidgetOffBottom = 30       # offset for widget position 
     44        ySignalOff = 10             # space between the top of the widget and first signal 
     45        ySignalSpace = 50           # space between two neighbouring signals 
     46        ySignalSize = 20            # height of the signal box 
     47        xSignalSize = 20            # width of the signal box 
    4648        xIconOff = 10 
    4749 
    4850        count = max(len(inputs), len(outputs)) 
    4951        height = max ((count)*ySignalSpace, 70) 
    50  
    5152 
    5253        # calculate needed sizes of boxes to show text 
     
    6869        self.outWidget.setBrush(brush) 
    6970        self.outWidget.setZValue(-100) 
    70 ##        self.outWidget.show() 
    7171 
    7272        self.inWidget = QGraphicsRectItem(xWidgetOff + width + xSpaceBetweenWidgets, yWidgetOffTop, width, height, None, self.dlg.canvas) 
    7373        self.inWidget.setBrush(brush) 
    7474        self.inWidget.setZValue(-100) 
    75 ##        self.inWidget.show() 
    7675 
    7776        # if icons -> show them 
    7877        if outIconName: 
     78            frame = QGraphicsPixmapItem(QPixmap(outWidget.imageFrame), None, self.dlg.canvas) 
     79            frame.setPos(xWidgetOff + xIconOff, yWidgetOffTop + height/2.0 - frame.pixmap().width()/2.0) 
    7980            self.outWidgetIcon = QGraphicsPixmapItem(QPixmap(outIconName), None, self.dlg.canvas) 
    8081            self.outWidgetIcon.setPos(xWidgetOff + xIconOff, yWidgetOffTop + height/2.0 - self.outWidgetIcon.pixmap().width()/2.0) 
    81 ##            self.outWidgetIcon.show() 
    8282        if inIconName : 
     83            frame = QGraphicsPixmapItem(QPixmap(inWidget.imageFrame), None, self.dlg.canvas) 
     84            frame.setPos(xWidgetOff + xSpaceBetweenWidgets + 2*width - xIconOff - frame.pixmap().width(), yWidgetOffTop + height/2.0 - frame.pixmap().width()/2.0) 
    8385            self.inWidgetIcon = QGraphicsPixmapItem(QPixmap(inIconName), None, self.dlg.canvas) 
    8486            self.inWidgetIcon.setPos(xWidgetOff + xSpaceBetweenWidgets + 2*width - xIconOff - self.inWidgetIcon.pixmap().width(), yWidgetOffTop + height/2.0 - self.inWidgetIcon.pixmap().width()/2.0) 
     
    107109            self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, inputs[i].type, xWidgetOff + width + xSpaceBetweenWidgets + 5, y + 7, Qt.AlignLeft | Qt.AlignVCenter, bold =0, show=1)) 
    108110 
    109         self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, outName, xWidgetOff + width/2.0, yWidgetOffTop + height + 5, Qt.AlignHCenter | Qt.AlignTop, bold =1, show=1)) 
    110         self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, inName, xWidgetOff + width* 1.5 + xSpaceBetweenWidgets, yWidgetOffTop + height + 5, Qt.AlignHCenter | Qt.AlignTop, bold =1, show=1)) 
     111        self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, outWidget.caption, xWidgetOff + width/2.0, yWidgetOffTop + height + 5, Qt.AlignHCenter | Qt.AlignTop, bold =1, show=1)) 
     112        self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, inWidget.caption, xWidgetOff + width* 1.5 + xSpaceBetweenWidgets, yWidgetOffTop + height + 5, Qt.AlignHCenter | Qt.AlignTop, bold =1, show=1)) 
    111113 
    112114        return (2*xWidgetOff + 2*width + xSpaceBetweenWidgets, yWidgetOffTop + height + yWidgetOffBottom) 
     
    187189        line.setPen(QPen(QColor(0,255,0), 6)) 
    188190        line.setZValue(100) 
    189 ##        line.show() 
    190191        self.scene().update() 
    191192        self.lines.append((line, outName, inName, outBox, inBox)) 
     
    239240        self.outWidget = outWidget 
    240241        self.inWidget = inWidget 
    241         (width, height) = self.canvasView.addSignalList(outWidget.caption, inWidget.caption, outWidget.widget.getOutputs(), inWidget.widget.getInputs(), outWidget.widget.getFullIconName(), inWidget.widget.getFullIconName()) 
     242        (width, height) = self.canvasView.addSignalList(outWidget, inWidget) 
    242243        self.canvas.setSceneRect(0, 0, width, height) 
    243244        self.resize(width+50, height+80) 
     
    624625            rows = (len(widgets)+2) / 3 
    625626            layout = QGridLayout(wtab) 
    626 ##            for i in range(2, 9, 3): 
    627 ##                layout.addItem(QSpacerItem(20, 0), 0, i) 
    628 ##            for i in range(0, 2*rows, 2): 
    629 ##                layout.addItem(QSpacerItem(0, 20), i, 0) 
    630627 
    631628            for i, w in enumerate(widgets): 
    632 ##                y, x = 1 + 2 * (i % rows), 3 * (i/rows) 
    633629                x = i / rows 
    634630                y = i % rows 
  • orange/OrangeCanvas/orngDoc.py

    r4877 r4963  
    7070 
    7171        QMdiSubWindow.closeEvent(self, ce) 
     72        self.canvasDlg.workspace.removeSubWindow(self) 
    7273 
    7374        # remove the temporary file if it exists 
     
    264265 
    265266    # add new widget 
    266     def addWidget(self, widget, x= -1, y=-1, caption = "", activateSettings = 1): 
     267    def addWidget(self, widget, x= -1, y=-1, caption = "", widgetSettings = {}): 
    267268        qApp.setOverrideCursor(Qt.WaitCursor) 
    268269        try: 
    269             newwidget = orngCanvasItems.CanvasWidget(self.signalManager, self.canvas, self.canvasView, widget, self.canvasDlg.defaultPic, self.canvasDlg) 
    270             newwidget.instance.category = widget.getCategory() 
    271             newwidget.instance.setEventHandler(self.canvasDlg.output.widgetEvents) 
     270            newwidget = orngCanvasItems.CanvasWidget(self.signalManager, self.canvas, self.canvasView, widget, self.canvasDlg.defaultPic, self.canvasDlg, widgetSettings) 
    272271        except: 
    273272            type, val, traceback = sys.exc_info() 
     
    275274            qApp.restoreOverrideCursor() 
    276275            return None 
    277         qApp.restoreOverrideCursor() 
    278276 
    279277        if x==-1 or y==-1: 
     
    301299 
    302300        # show the widget and activate the settings 
    303         qApp.setOverrideCursor(Qt.WaitCursor) 
    304301        try: 
    305302            self.signalManager.addWidget(newwidget.instance) 
     
    307304            newwidget.updateTooltip() 
    308305            newwidget.setProcessing(1) 
    309             if activateSettings: 
    310                 newwidget.instance.activateLoadedSettings() 
    311                 if self.canvasDlg.settings["saveWidgetsPosition"]: 
    312                     newwidget.instance.restoreWidgetPosition() 
     306            if self.canvasDlg.settings["saveWidgetsPosition"]: 
     307                newwidget.instance.restoreWidgetPosition() 
    313308            newwidget.setProcessing(0) 
    314309        except: 
    315310            type, val, traceback = sys.exc_info() 
    316311            sys.excepthook(type, val, traceback)  # we pretend that we handled the exception, so that it doesn't crash canvas 
     312 
    317313        qApp.restoreOverrideCursor() 
    318  
    319314        return newwidget 
    320315 
     
    354349 
    355350    # return a new widget instance of a widget with filename "widgetName" 
    356     def addWidgetByFileName(self, widgetName, x, y, caption, activateSettings = 1): 
     351    def addWidgetByFileName(self, widgetName, x, y, caption, widgetSettings = {}): 
    357352        for widget in self.canvasDlg.tabs.allWidgets: 
    358353            if widget.getFileName() == widgetName: 
    359                 return self.addWidget(widget, x, y, caption, activateSettings) 
     354                return self.addWidget(widget, x, y, caption, widgetSettings) 
    360355        return None 
    361356 
     
    466461        if not os.path.exists(filename): 
    467462            self.close() 
    468             QMessageBox.critical(self, 'Orange Canvas', 'Unable to find file "'+ filename,  QMessageBox.Ok + QMessageBox.Default) 
     463            QMessageBox.critical(self, 'Orange Canvas', 'Unable to locate file "'+ filename + '"',  QMessageBox.Ok) 
    469464            return 
    470465 
     
    493488            for widget in widgets.getElementsByTagName("widget"): 
    494489                name = widget.getAttribute("widgetName") 
    495                 tempWidget = self.addWidgetByFileName(name, int(widget.getAttribute("xPos")), int(widget.getAttribute("yPos")), widget.getAttribute("caption"), activateSettings = 0) 
     490                settings = cPickle.loads(settingsDict[widget.getAttribute("caption")]) 
     491                tempWidget = self.addWidgetByFileName(name, int(widget.getAttribute("xPos")), int(widget.getAttribute("yPos")), widget.getAttribute("caption"), settings) 
    496492                if not tempWidget: 
    497493                    #QMessageBox.information(self, 'Orange Canvas','Unable to create instance of widget \"'+ name + '\"',  QMessageBox.Ok + QMessageBox.Default) 
    498494                    failureText += '<nobr>Unable to create instance of a widget <b>%s</b></nobr><br>' %(name) 
    499495                    loadedOk = 0 
    500                 else: 
    501                     if tempWidget.caption in settingsDict.keys(): 
    502                         tempWidget.instance.loadSettingsStr(settingsDict[tempWidget.caption]) 
    503                         tempWidget.instance.activateLoadedSettings() 
    504496                qApp.processEvents() 
    505497 
     
    538530                QMessageBox.information(self, 'Schema Loading Failed', 'The following errors occured while loading the schema: <br><br>' + failureText,  QMessageBox.Ok + QMessageBox.Default) 
    539531 
    540  
    541532            if self.widgets: 
    542533                self.signalManager.processNewSignals(self.widgets[0].instance) 
     
    579570        n = "\n" 
    580571 
    581         start = """#This is automatically created file containing an Orange schema 
    582          
     572        start = """#This file is automatically created by Orange Canvas and containing an Orange schema 
     573 
    583574import orngOrangeFoldersQt4 
    584575import orngDebugging 
    585576import sys, os, cPickle, orange, orngSignalManager, OWGUI 
    586  
    587 """ 
    588  
    589         instancesT = "# create widget instances\n" +t+t 
    590         instancesB = "# create widget instances\n" +t+t 
    591         links = "#load settings before we connect widgets\n" +t+t+ "self.loadSettings()\n\n" +t+t + "# add widget signals\n"+t+t + "self.signalManager.setFreeze(1)\n" +t+t 
    592         loadSett = "" 
    593         saveSett = "" 
     577from OWBaseWidget import * 
     578 
     579class GUIApplication(OWBaseWidget): 
     580    def __init__(self,parent=None): 
     581        self.signalManager = orngSignalManager.SignalManager() 
     582        OWBaseWidget.__init__(self, title = '%s', signalManager = self.signalManager) 
     583        self.widgets = {} 
     584        self.loadSettings() 
     585        """ % (fileName) 
     586 
     587        if asTabs == 1: 
     588            start += """ 
     589        self.tabs = QTabWidget(self) 
     590        self.setLayout(QVBoxLayout()) 
     591        self.layout().addWidget(self.tabs) 
     592        self.resize(800,600)""" 
     593        else: 
     594            start += """ 
     595        self.setLayout(QVBoxLayout()) 
     596        self.box = OWGUI.widgetBox(self, 'Widgets')""" 
     597 
     598 
     599        links = "# add widget signals\n"+t+t + "self.signalManager.setFreeze(1)\n" +t+t 
    594600        widgetParameters = "" 
    595601 
     
    602608 
    603609                shown = widgetName in saveDlg.shownWidgetList 
    604                 name = widget.caption.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    605                 start += "from %s import *\n" % (widget.widget.getFileName()) 
    606                 instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
    607                 instancesB += "self.ow%s = %s(signalManager = self.signalManager)\n" %(name, widget.widget.getFileName()) +t+t 
    608                 widgetParameters += "self.setWidgetParameters(self.ow%s, '%s', '%s', %d)\n" % (name, widget.widget.getIconName(), widget.caption, shown) +t+t 
    609                 loadSett += """self.ow%s.loadSettingsStr(strSettings["%s"]); self.ow%s.activateLoadedSettings()\n""" % (name, widget.caption, name) +t+t+t 
    610                 saveSett += """strSettings["%s"] = self.ow%s.saveSettingsStr()\n""" % (widget.caption, name) +t+t 
     610                widgetParameters += "self.createWidget('%s', '%s', '%s', %d, self.signalManager)\n" % (widget.widget.getFileName(), widget.widget.getIconName(), widget.caption, shown) +t+t 
    611611            else: 
    612612                if not asTabs: 
     
    615615        for line in self.lines: 
    616616            if not line.getEnabled(): continue 
    617  
    618             outWidgetName = line.outWidget.caption.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    619             inWidgetName = line.inWidget.caption.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    620  
    621617            for (outName, inName) in line.getSignals(): 
    622                 links += "self.signalManager.addLink( self.ow" + outWidgetName + ", self.ow" + inWidgetName + ", '" + outName + "', '" + inName + "', 1)\n" +t+t 
     618                links += "self.signalManager.addLink( self.widgets['" + line.outWidget.caption+ "'], self.widgets['" + line.inWidget.caption+ "'], '" + outName + "', '" + inName + "', 1)\n" +t+t 
    623619 
    624620        links += "self.signalManager.setFreeze(0)\n" +t+t 
     
    628624        exitButton = OWGUI.button(box2, self, "Exit", callback = self.accept) 
    629625        self.layout().addStretch(100)""" 
    630          
     626 
     627        if asTabs: 
     628            guiText = "OWGUI.createTabPage(self.tabs, caption, widget)" 
     629        else: 
     630            guiText = "OWGUI.button(self.box, self, caption, callback = widget.reshow)" 
     631 
    631632        progress = """ 
    632633        statusBar = QStatusBar(self) 
     
    642643        statusBar.addWidget(self.status)""" 
    643644 
    644         if asTabs: 
    645             guiText = "OWGUI.createTabPage(self.tabs, caption, widget)" 
    646         else: 
    647             guiText = "OWGUI.button(self.box, self, caption, callback = widget.reshow)" 
    648  
    649  
    650645        handlerFuncts = """ 
    651     def setWidgetParameters(self, widget, iconName, caption, shown): 
     646    def createWidget(self, fname, iconName, caption, shown, signalManager): 
     647        widgetSettings = cPickle.loads(self.strSettings[caption]) 
     648        m = __import__(fname) 
     649        widget = m.__dict__[fname].__new__(m.__dict__[fname], _settingsFromSchema = widgetSettings) 
     650        widget.__init__(signalManager=signalManager) 
    652651        widget.setEventHandler(self.eventHandler) 
    653652        widget.setProgressBarHandler(self.progressHandler) 
     
    655654        widget.setWindowTitle(caption) 
    656655        self.signalManager.addWidget(widget) 
    657         self.widgets.append(widget) 
     656        self.widgets[caption] = widget 
    658657        if shown: %s 
    659658        for dlg in getattr(widget, "wdChildDialogs", []): 
    660             self.widgets.append(dlg) 
    661659            dlg.setEventHandler(self.eventHandler) 
    662660            dlg.setProgressBarHandler(self.progressHandler) 
    663          
     661 
    664662    def eventHandler(self, text, eventVerbosity = 1): 
    665663        if orngDebugging.orngVerbosity >= eventVerbosity: 
     
    680678        try: 
    681679            file = open("%s", "r") 
    682             strSettings = cPickle.load(file) 
     680            self.strSettings = cPickle.load(file) 
    683681            file.close() 
    684682 
    685             %s 
    686683        except: 
    687             print "unable to load settings"  
     684            print "unable to load settings" 
    688685            pass 
    689686 
     
    691688        OWBaseWidget.closeEvent(self, ev) 
    692689        if orngDebugging.orngDebuggingEnabled: return 
    693         for widget in self.widgets[::-1]: 
     690        strSettings = {} 
     691        for (name, widget) in self.widgets.items(): 
    694692            widget.synchronizeContexts() 
     693            strSettings[name] = widget.saveSettingsStr() 
    695694            widget.close() 
    696         strSettings = {} 
    697         %s 
    698695        file = open("%s", "w") 
    699696        cPickle.dump(strSettings, file) 
    700697        file.close() 
    701          
     698 
    702699if __name__ == "__main__": 
    703700    application = QApplication(sys.argv) 
     
    706703    # comment the next line if in debugging mode and are interested only in output text in 'signalManagerOutput.txt' file 
    707704    application.exec_() 
    708         """ % (guiText, fileName + ".sav", loadSett, saveSett, fileName + ".sav") 
    709  
    710         start += n+n + """ 
    711 class GUIApplication(OWBaseWidget): 
    712     def __init__(self,parent=None): 
    713         self.signalManager = orngSignalManager.SignalManager() 
    714         OWBaseWidget.__init__(self, title = '%s', signalManager = self.signalManager) 
    715         self.widgets = [] 
    716         """ % (fileName) 
    717  
    718         if asTabs == 1: 
    719             start += """ 
    720         self.tabs = QTabWidget(self) 
    721         self.setLayout(QVBoxLayout()) 
    722         self.layout().addWidget(self.tabs) 
    723         self.resize(800,600)""" 
    724         else: 
    725             start += """ 
    726         self.setLayout(QVBoxLayout()) 
    727         self.box = OWGUI.widgetBox(self, 'Widgets')""" 
    728  
    729         if asTabs: 
    730             whole = start + n+n+t+t+ instancesT + n+t+t + widgetParameters + n+t+t + progress + n+t+t + links + n + handlerFuncts 
    731         else: 
    732             whole = start + n+n+t+t+ instancesB + n+t+t + widgetParameters + n+t+t + progress + n+t+t+  links + n + handlerFuncts 
     705        """ % (guiText, fileName + ".sav", fileName + ".sav") 
     706 
    733707 
    734708        #save app 
    735709        fileApp = open(os.path.join(self.applicationpath, self.applicationname), "wt") 
    736710        self.canvasDlg.settings["saveApplicationDir"] = self.applicationpath 
    737         fileApp.write(whole) 
     711        fileApp.write(start + n+n+t+t+ widgetParameters + n+t+t + progress + n+n+t+t + links + n + handlerFuncts) 
    738712        fileApp.close() 
    739713 
  • orange/OrangeCanvas/orngView.py

    r4795 r4963  
    1717        self.movingWidget = None 
    1818        self.mouseDownPosition = QPoint(0,0) 
    19         self.lastMousePosition = QPoint(0,0) 
    2019        self.tempLine = None 
    2120        self.tempRect = None 
     
    2524        self.setAlignment(Qt.AlignLeft | Qt.AlignTop) 
    2625        self.ensureVisible(0,0,1,1) 
    27          
     26 
    2827        # create popup menus 
    2928        self.linePopup = QMenu("Link", self) 
     
    5554        if len(widgets) != 1: return 
    5655        widget = widgets[0] 
    57          
     56 
    5857        exName = str(widget.caption) 
    5958        (newName ,ok) = QInputDialog.getText(self, "Rename Widget", "Enter new name for the \"" + exName + "\" widget:", QLineEdit.Normal, exName) 
     
    130129        for item in self.doc.widgets: 
    131130            item.setSelected(0) 
    132          
     131 
     132    # get a tuple (outWidget, inWidget) that contains the widgets whose  
     133    # outputs and inputs are near position pos 
     134    def widgetChannelsAtPos(self, pos): 
     135        right = [item.mouseInsideRightChannel(pos) for item in self.doc.widgets] 
     136        left = [item.mouseInsideLeftChannel(pos) for item in self.doc.widgets] 
     137        outWidget, inWidget = None, None 
     138        if True in left: 
     139            inWidget = self.doc.widgets[left.index(1)] 
     140        if True in right: 
     141            outWidget = self.doc.widgets[right.index(1)] 
     142        return (outWidget, inWidget) 
     143 
     144    def getItemsAtPos(self, pos, itemType = None): 
     145        if type(pos) == QPointF: 
     146            pos = QGraphicsRectItem(QRectF(pos, QSizeF(1,1))) 
     147        items = self.scene().collidingItems(pos) 
     148        if itemType != None: 
     149            items = [item for item in items if type(item) == itemType] 
     150        return items 
    133151 
    134152    # ########################################### 
     
    144162            self.tempRect = None 
    145163 
     164        # do we start drawing a connection line 
     165        if ev.button() == Qt.LeftButton: 
     166            outWidget, inWidget = self.widgetChannelsAtPos(self.mouseDownPosition) 
     167            activeItem = outWidget or inWidget 
     168            self.tempWidget = activeItem 
     169            if activeItem: 
     170                activeItem.setSelected(1) 
     171                if not self.doc.signalManager.signalProcessingInProgress:   # if we are processing some signals, don't allow to add lines 
     172                    self.unselectAllWidgets() 
     173                    self.bLineDragging = True 
     174                    pos = activeItem.getEdgePoint(self.mouseDownPosition) 
     175                    self.tempLine = orngCanvasItems.TempCanvasLine(self.doc.canvasDlg, self.scene()) 
     176                    self.tempLine.setLine(pos.x(), pos.y(), pos.x(), pos.y()) 
     177                    self.tempLine.setPen(QPen(self.doc.canvasDlg.lineColor, 1)) 
     178                    if activeItem.mouseInsideLeftChannel(self.mouseDownPosition): 
     179                        for widget in self.doc.widgets: 
     180                            widget.canConnect(widget, activeItem) 
     181                    else: 
     182                        for widget in self.doc.widgets: 
     183                            widget.canConnect(activeItem, widget) 
     184                                                         
     185                self.scene().update() 
     186                self.doc.canvasDlg.widgetPopup.setEnabled(len(self.getSelectedWidgets()) == 1) 
     187                return 
     188             
    146189        activeItem = self.scene().itemAt(self.mouseDownPosition) 
    147190        if not activeItem: 
     
    158201                # did we click inside the boxes to draw connections 
    159202                if ev.button() == Qt.LeftButton: 
    160                     if activeItem.mouseInsideLeftChannel(self.mouseDownPosition) or activeItem.mouseInsideRightChannel(self.mouseDownPosition): 
     203                    self.bWidgetDragging = True 
     204                    if self.doc.ctrlPressed: 
     205                        activeItem.setSelected(not activeItem.isSelected()) 
     206                    elif activeItem.isSelected() == 0: 
     207                        self.unselectAllWidgets() 
    161208                        activeItem.setSelected(1) 
    162                         if not self.doc.signalManager.signalProcessingInProgress:   # if we are processing some signals, don't allow to add lines 
    163                             self.unselectAllWidgets() 
    164                             self.bLineDragging = True 
    165                             pos = activeItem.getEdgePoint(self.mouseDownPosition) 
    166                             self.tempLine = orngCanvasItems.TempCanvasLine(self.doc.canvasDlg, self.scene()) 
    167                             self.tempLine.setLine(pos.x(), pos.y(), pos.x(), pos.y()) 
    168                             self.tempLine.setPen(QPen(self.doc.canvasDlg.lineColor, 1)) 
    169                             #self.scene().update() 
    170                     else:   # we clicked inside the widget and we start dragging it 
    171                         self.bWidgetDragging = True 
    172                         if self.doc.ctrlPressed: 
    173                             activeItem.setSelected(not activeItem.isSelected()) 
    174                         elif activeItem.isSelected() == 0: 
    175                             self.unselectAllWidgets() 
    176                             activeItem.setSelected(1) 
    177                             self.bMultipleSelection = False 
    178  
    179                         for w in self.getSelectedWidgets(): 
    180                             w.setCoords(w.x(), w.y()) 
    181                             w.savePosition() 
    182                             w.setAllLinesFinished(False) 
     209                        self.bMultipleSelection = False 
     210 
     211                    for w in self.getSelectedWidgets(): 
     212                        #w.setCoords(w.x(), w.y()) 
     213                        w.savePosition() 
     214                        w.setAllLinesFinished(False) 
    183215 
    184216                # is we clicked the right mouse button we show the popup menu for widgets 
    185217                elif ev.button() == Qt.RightButton: 
    186                     #self.widgetPopup.popup(ev.globalPos()) 
     218                    self.unselectAllWidgets() 
     219                    activeItem.setSelected(1) 
     220                    self.bMultipleSelection = False 
    187221                    self.doc.canvasDlg.widgetPopup.popup(ev.globalPos()) 
    188222                else: 
     
    200234 
    201235        self.scene().update() 
    202         self.lastMousePosition = self.mapToScene(ev.pos()) 
    203236        self.doc.canvasDlg.widgetPopup.setEnabled(len(self.getSelectedWidgets()) == 1) 
    204237 
     
    206239    # mouse button was pressed and mouse is moving ###################### 
    207240    def mouseMoveEvent(self, ev): 
    208         #if not self.bLineDragging and (ev.x() < 0 or ev.x() > self.contentsX() + self.visibleWidth() or ev.y() < 0 or ev.y() > self.contentsY() + self.visibleHeight()): 
    209         #    self.contentsMouseReleaseEvent(ev) 
    210         #    return 
    211241        point = self.mapToScene(ev.pos()) 
    212242        if self.tempRect: 
     
    216246        if self.bWidgetDragging: 
    217247            for item in self.getSelectedWidgets(): 
    218                 ex_pos = QPoint(item.x(), item.y()) 
    219                 item.setCoordsBy(point.x() - self.lastMousePosition.x(), point.y() - self.lastMousePosition.y()) 
    220                 if self.doc.canvasDlg.settings["snapToGrid"]: 
    221                     item.moveToGrid() 
    222                 else: 
    223                     item.setCoords(item.xPos, item.yPos) 
    224  
    225                 items = self.scene().collidingItems(item) 
    226                 item.invalidPosition = (self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) > 0) 
     248                newPos = item.oldPos + (point-self.mouseDownPosition) 
     249                item.setCoords(newPos.x(), newPos.y()) 
     250                item.invalidPosition = (self.findItemTypeCount(self.scene().collidingItems(item), orngCanvasItems.CanvasWidget) > 0) 
    227251                item.updateLineCoords() 
     252            self.scene().update() 
    228253 
    229254        elif self.bLineDragging: 
    230255            if self.tempLine: 
    231256                self.tempLine.setLine(self.tempLine.line().x1(), self.tempLine.line().y1(), point.x(), point.y()) 
     257            self.scene().update() 
    232258 
    233259        elif self.bMultipleSelection: 
     
    237263 
    238264            # select widgets in rectangle 
    239             items = self.scene().collidingItems(self.tempRect) 
    240             widgets = self.findAllItemType(items, orngCanvasItems.CanvasWidget) 
    241  
     265            widgets = self.getItemsAtPos(self.tempRect, orngCanvasItems.CanvasWidget) 
    242266            for widget in self.doc.widgets: 
    243267                widget.setSelected(widget in widgets) 
    244 #                if widget in widgets: 
    245 #                    widget.savePosition() 
    246  
    247         self.scene().update() 
    248         self.lastMousePosition = point 
     268            self.scene().update() 
    249269 
    250270 
     
    275295        # if we are drawing line 
    276296        elif self.bLineDragging: 
    277             item = self.scene().itemAt(QPointF(point)) 
     297            # show again the empty input/output boxes 
     298            for widget in self.doc.widgets: 
     299              widget.resetLeftRightEdges()       
     300            widgets = self.getItemsAtPos(point, orngCanvasItems.CanvasWidget) 
     301            item = len(widgets) > 0 and widgets[0] or None 
     302            if not item: 
     303                outWidget, inWidget = self.widgetChannelsAtPos(point) 
     304                item = inWidget or outWidget 
     305 
     306            p1 = self.tempLine.line().p1() 
     307            if self.tempLine != None: 
     308                self.tempLine.hide() 
     309                self.tempLine = None 
    278310 
    279311            # we must check if we have really conected some output to input 
    280             if type(item) == orngCanvasItems.CanvasWidget and self.tempWidget and self.tempLine and item != self.tempWidget: 
    281                 if self.tempWidget.mouseInsideLeftChannel(self.tempLine.line().p1()): 
     312            if type(item) == orngCanvasItems.CanvasWidget and self.tempWidget and item != self.tempWidget: 
     313                if self.tempWidget.mouseInsideLeftChannel(p1): 
    282314                    outWidget = item 
    283315                    inWidget  = self.tempWidget 
     
    286318                    inWidget  = item 
    287319 
    288                 # hide the temp line 
    289                 self.tempLine.hide() 
    290                 self.tempLine = None 
    291  
    292320                if self.doc.signalManager.signalProcessingInProgress: 
    293321                     QMessageBox.information( self, "Orange Canvas", "Unable to connect widgets while signal processing is in progress. Please wait.") 
    294322                else: 
    295323                    line = self.doc.addLine(outWidget, inWidget) 
    296  
    297             if self.tempLine != None: 
    298                 self.tempLine.setLine(0,0,0,0) 
    299                 self.tempLine.hide() 
    300                 self.tempLine = None 
    301324 
    302325        self.scene().update() 
     
    354377        return sum([type(item) == Type for item in items]) 
    355378 
    356     # find and return first item of type Type 
    357     def findFirstItemType(self, items, Type): 
    358         for item in items: 
    359             if type(item) == Type: 
    360                 return item 
    361         return None 
    362  
    363     # find and return all items of type "type" 
    364     def findAllItemType(self, items, Type): 
    365         return [item for item in items if type(item) == Type] 
    366  
     379 
Note: See TracChangeset for help on using the changeset viewer.