Changeset 3495:b5bb5783ab55 in orange


Ignore:
Timestamp:
04/04/07 13:46:04 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
4b6a79bb18233df902f7efdfbe00228ce3d86292
Message:
  • changed output dirs for files
  • bugfix: when connecting another widget, removal of existing link was not done correctly
Location:
orange/OrangeCanvas
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeCanvas/orngCanvas.pyw

    r3453 r3495  
    1717 
    1818        self.__dict__.update(orngRegistry.directoryNames) 
    19         orngRegistry.addWidgetDirectories() 
    2019 
    2120        #self.setFocusPolicy(QWidget.StrongFocus) 
     
    2928        if os.path.exists(canvasIconName): 
    3029            self.setIcon(QPixmap(canvasIconName)) 
    31          
     30 
    3231        if not self.widgetDir in sys.path: 
    3332            sys.path.append(self.widgetDir) 
     
    4847            self.widgetIcons = None 
    4948            print "Unable to load all necessary icons. Please reinstall Orange." 
    50          
     49 
    5150        self.workspace = WidgetWorkspace(self) 
    5251        #self.workspace.setBackgroundColor(QColor(255,255,255)) 
     
    5453        self.statusBar = MyStatusBar(self) 
    5554        self.connect(self.workspace, SIGNAL("windowActivated(QWidget*)"), self.focusDocument) 
    56          
     55 
    5756        self.settings = {} 
    5857        self.widgetInfo = {} # this is a dictionary with items: category-widget_name : {info about widget (inList, outList, description...} 
    59          
     58 
    6059        self.rebuildSignals()    # coloring of signals - unused! 
    6160        self.useLargeIcons = False 
     
    6362 
    6463        self.loadSettings() 
    65          
     64 
    6665        self.useLargeIcons = self.settings["useLargeIcons"] 
    6766        self.snapToGrid = self.settings["snapToGrid"] 
    68          
     67 
    6968        self.widgetSelectedColor = QColor(self.settings["widgetSelectedColor"][0], self.settings["widgetSelectedColor"][1], self.settings["widgetSelectedColor"][2]) 
    7069        self.widgetActiveColor   = QColor(self.settings["widgetActiveColor"][0], self.settings["widgetActiveColor"][1], self.settings["widgetActiveColor"][2]) 
    7170        self.lineColor           = QColor(self.settings["lineColor"][0], self.settings["lineColor"][1], self.settings["lineColor"][2]) 
    72          
     71 
    7372        self.toolbar = QToolBar(self, 'Toolbar') 
    7473        self.widgetsToolBar = QToolBar( self, 'Widgets') 
    75          
    76         self.iDocIndex = 1  
     74 
     75        self.iDocIndex = 1 
    7776 
    7877        canvasPicsDir  = os.path.join(self.canvasDir, "icons") 
     
    9089        self.toolNew  = QToolButton(QIconSet(QPixmap(self.file_new)), "New schema" , QString.null, self.menuItemNewSchema, self.toolbar, 'new schema') 
    9190        #self.toolNew.setUsesTextLabel (True) 
    92         self.toolOpen = QToolButton(QIconSet(QPixmap(self.file_open)), "Open schema" , QString.null, self.menuItemOpen , self.toolbar, 'open schema')  
     91        self.toolOpen = QToolButton(QIconSet(QPixmap(self.file_open)), "Open schema" , QString.null, self.menuItemOpen , self.toolbar, 'open schema') 
    9392        self.toolSave = QToolButton(QIconSet(QPixmap(self.file_save)), "Save schema" ,QString.null, self.menuItemSave, self.toolbar, 'save schema') 
    9493        self.toolbar.addSeparator() 
    9594        toolPrint = QToolButton(QIconSet(QPixmap(self.file_print)), "Print" ,QString.null, self.menuItemPrinter, self.toolbar, 'print') 
    96          
     95 
    9796        # qt version compatibility 
    9897        if hasattr(self, "addDockWindow"): self.addDockWindow(self.toolbar, "Toolbar", Qt.DockTop, True) 
    9998        else:                  self.addToolBar(self.toolbar, "Toolbar", QMainWindow.Top, True) 
    100          
    101         # read widgets     
    102         if hasattr(self.widgetsToolBar, "setHorizontalStretchable"): self.widgetsToolBar.setHorizontalStretchable(True)         
     99 
     100        # read widgets 
     101        if hasattr(self.widgetsToolBar, "setHorizontalStretchable"): self.widgetsToolBar.setHorizontalStretchable(True) 
    103102        else: self.widgetsToolBar.setHorizontallyStretchable(True) 
    104103        self.createWidgetsToolbar(not os.path.exists(self.registryFileName)) 
    105104 
     105        orngRegistry.addWidgetDirectories() 
    106106        self.readShortcuts() 
    107          
     107 
    108108        # read recent files 
    109109        self.recentDocs = [] 
     
    113113        height = self.settings.get("canvasHeight", 600) 
    114114        self.resize(width, height) 
    115          
     115 
    116116        # center window in the desktop 
    117117        deskH = app.desktop().height() 
     
    120120        w = max(0, deskW/2 - width/2) 
    121121        self.move(w,h) 
    122          
     122 
    123123        # apply output settings 
    124124        self.output = orngOutput.OutputWindow(self, self.workspace, "", Qt.WDestructiveClose) 
     
    134134        self.output.setWriteLogFile(self.settings["writeLogFile"]) 
    135135        self.output.setVerbosity(self.settings["outputVerbosity"]) 
    136          
     136 
    137137        self.show() 
    138          
     138 
    139139        # create new schema 
    140140        win = self.menuItemNewSchema() 
     
    156156        self.widgetsToolBar.clear() 
    157157        self.tabs = orngTabs.WidgetTabs(self.widgetInfo, self.widgetsToolBar, 'tabs') 
    158          
     158 
    159159        if hasattr(self, "addDockWindow") : self.addDockWindow(self.widgetsToolBar, "Widgets", Qt.DockTop, True) 
    160160        else:                               self.addToolBar(self.widgetsToolBar, "Widgets", QMainWindow.Top, True) 
    161          
     161 
    162162        self.tabs.setCanvasDlg(self) 
    163          
     163 
    164164        # if registry doesn't exist yet, we create it 
    165165        ## the registry is now build already in the orngRegistry when setting up the directory names 
     
    167167            parse = orngRegistry.WidgetsToXML() 
    168168            parse.ParseWidgetRoot(self.widgetDir, self.outputDir) 
    169              
     169 
    170170        # if registry still doesn't exist then something is very wrong... 
    171171        if not os.path.exists(self.registryFileName): 
     
    177177        else: 
    178178            widgetTabList = ["Data", "Classify", "Evaluate", "Visualize", "Associate", "Genomics", "Other"] 
    179              
     179 
    180180        for tab in widgetTabList: 
    181181            self.tabs.insertWidgetTab(tab) 
    182                  
     182 
    183183        # read widget registry file and create tab with buttons 
    184184        self.tabs.readInstalledWidgets(self.registryFileName, self.widgetDir, self.picsDir, self.defaultPic, self.useLargeIcons) 
     
    189189            widgetTabList.append(str(self.tabs.tabLabel(tab))) 
    190190        self.settings["WidgetTabs"] = widgetTabList 
    191              
     191 
    192192 
    193193    def readShortcuts(self): 
    194194        self.widgetShortcuts = {} 
    195         shfn = os.path.join(self.canvasDir, "shortcuts.txt") 
     195        shfn = os.path.join(self.outputDir, "shortcuts.txt") 
    196196        if os.path.exists(shfn): 
    197197            for t in file(shfn).readlines(): 
     
    202202                else: 
    203203                    print "Warning: invalid shortcut %s (%s)" % (key, button) 
    204          
     204 
    205205    def initMenu(self): 
    206206        # ################### 
     
    208208        # ################### 
    209209        self.menuRecent = QPopupMenu(self) 
    210          
     210 
    211211        self.menuFile = QPopupMenu( self ) 
    212212        self.menuFile.insertItem(QIconSet(QPixmap(self.file_new)), "&New",  self.menuItemNewSchema, Qt.CTRL+Qt.Key_N ) 
     
    214214        #self.menuFile.insertItem( "New from wizard",  self.menuItemNewWizard) 
    215215        self.menuFile.insertItem(QIconSet(QPixmap(self.file_open)), "&Open...", self.menuItemOpen, Qt.CTRL+Qt.Key_O ) 
    216         if os.path.exists(os.path.join(self.canvasDir, "_lastSchema.ows")): 
     216        if os.path.exists(os.path.join(self.outputDir, "_lastSchema.ows")): 
    217217            self.menuFile.insertItem("&Reload Last Schema", self.menuItemOpenLastSchema, Qt.CTRL + Qt.Key_R) 
    218218        self.menuFile.insertItem( "Close", self.menuItemClose ) 
     
    248248        # uncomment this only for debugging 
    249249        #self.menuOptions.insertItem("Dump widget variables", self.dumpVariables) 
    250          
     250 
    251251        self.menuOptions.insertSeparator() 
    252252        #self.menuOptions.insertItem( "Channel preferences",  self.menuItemPreferences) 
     
    256256        self.menuOptions.insertSeparator() 
    257257        self.menuOptions.insertItem( "Canvas &Options...",  self.menuItemCanvasOptions) 
    258          
    259         self.menuWindow = QPopupMenu( self )         
     258 
     259        self.menuWindow = QPopupMenu( self ) 
    260260        self.menuWindow.insertItem("&Cascade", self.workspace.cascade) 
    261261        self.menuWindow.insertItem("&Tile", self.workspace.tile) 
    262262        self.menuWindow.insertSeparator() 
    263          
     263 
    264264        self.connect(self.menuWindow, SIGNAL("aboutToShow()"), self.showWindows) 
    265265 
     
    275275        if not self.showWidgetToolbar: self.widgetsToolBar.hide() 
    276276        self.menuWindow.setItemChecked(self.menupopupShowWidgetToolbarID, self.showWidgetToolbar) 
    277          
     277 
    278278        self.menuWindow.insertSeparator() 
    279279        self.menuOutput = QPopupMenu(self) 
     
    295295            if os.path.exists(os.path.join(self.orangeDir, r"doc/reference/default.htm")): self.menuHelp.insertItem("Orange Help", self.menuOpenLocalOrangeHelp) 
    296296            if os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): self.menuHelp.insertItem("Orange Canvas Help", self.menuOpenLocalCanvasHelp) 
    297          
     297 
    298298        self.menuHelp.insertItem("Orange Online Help", self.menuOpenOnlineOrangeHelp) 
    299299        #self.menuHelp.insertItem("Orange Canvas Online Help", self.menuOpenOnlineCanvasHelp) 
    300          
     300 
    301301        if os.path.exists(os.path.join(self.orangeDir, r"updateOrange.py")): 
    302302            self.menuHelp.insertSeparator() 
     
    305305        #self.menuHelp.insertSeparator() 
    306306        #self.menuHelp.insertItem("About Orange Canvas", self.menuHelpAbout) 
    307          
    308         self.menuBar = QMenuBar( self )  
     307 
     308        self.menuBar = QMenuBar( self ) 
    309309        self.menuBar.insertItem( "&File", self.menuFile ) 
    310310        #self.menuBar.insertItem( "&Edit", self.menuEdit ) 
     
    313313        self.menuBar.insertItem("&Help", self.menuHelp) 
    314314 
    315         self.printer = QPrinter()  
     315        self.printer = QPrinter() 
    316316 
    317317 
     
    353353 
    354354    def menuItemOpenLastSchema(self): 
    355         if os.path.exists(os.path.join(self.canvasDir, "_lastSchema.ows")): 
     355        if os.path.exists(os.path.join(self.outputDir, "_lastSchema.ows")): 
    356356            win = self.menuItemNewSchema(0) 
    357             win.loadDocument(os.path.join(self.canvasDir, "_lastSchema.ows"), str(win.caption())) 
     357            win.loadDocument(os.path.join(self.outputDir, "_lastSchema.ows"), str(win.caption())) 
    358358 
    359359    def menuItemClose(self): 
    360360        win = self.workspace.activeWindow() 
    361361        win.close() 
    362          
     362 
    363363    def menuItemSave(self): 
    364364        win = self.workspace.activeWindow() 
     
    381381        win = self.workspace.activeWindow() 
    382382        if isinstance(win, orngDoc.SchemaDoc): 
    383             win.saveDocumentAsApp(asTabs = 1)     
     383            win.saveDocumentAsApp(asTabs = 1) 
    384384 
    385385    def menuItemPrinter(self): 
     
    394394        sizeDlg = OWDlgs.OWChooseImageSizeDlg(win.canvas) 
    395395        sizeDlg.exec_loop() 
    396          
     396 
    397397 
    398398    def readRecentFiles(self): 
     
    408408        recentDocs = recentDocs[:9] 
    409409        self.settings["RecentFiles"] = recentDocs 
    410          
     410 
    411411        for i in range(len(recentDocs)): 
    412412            shortName = "&" + str(i+1) + " " + os.path.basename(recentDocs[i]) 
     
    426426        # convert to a valid file name 
    427427        name = os.path.realpath(name) 
    428          
     428 
    429429        if name in recentDocs: 
    430430            recentDocs.remove(name) 
     
    477477    def menuItemGrid(self): 
    478478        return 
    479          
     479 
    480480    def menuItemShowGrid(self): 
    481481        return 
    482          
     482 
    483483    def updateSnapToGrid(self): 
    484484        if self.snapToGrid == True: 
     
    493493    def updateUseLargeIcons(self): 
    494494        self.createWidgetsToolbar(0) 
    495                  
     495 
    496496    def menuItemEnableAll(self): 
    497497        win = self.workspace.activeWindow() 
    498498        if isinstance(win, orngDoc.SchemaDoc): 
    499499            win.enableAllLines() 
    500          
     500 
    501501    def menuItemDisableAll(self): 
    502502        win = self.workspace.activeWindow() 
     
    559559    def menuItemRebuildWidgetRegistry(self): 
    560560        self.createWidgetsToolbar(True) 
    561          
     561 
    562562    def menuItemEditWidgetShortcuts(self): 
    563563        dlg = orngDlgs.WidgetRegistryDlg(self, None, "", True) 
     
    566566 
    567567            self.widgetShortcuts = dict([(y, x) for x, y in dlg.invDict.items()]) 
    568             shf = file(os.path.join(self.canvasDir, "shortcuts.txt"), "wt") 
     568            shf = file(os.path.join(self.outputDir, "shortcuts.txt"), "wt") 
    569569            for k, v in self.widgetShortcuts.items(): 
    570570                shf.write("%s: %s\n" % (k, v.nameKey)) 
     
    574574        for win in wins: 
    575575            win.close() 
    576              
     576 
    577577    def menuMinimizeAll(self): 
    578578        wins = self.workspace.windowList() 
    579579        for win in wins: 
    580580            win.showMinimized() 
    581              
     581 
    582582    def menuRestoreAll(self): 
    583583        wins = self.workspace.windowList() 
     
    607607 
    608608    def menuHelpAbout(self): 
    609         pass     
     609        pass 
    610610 
    611611    def rebuildSignals(self): 
     
    628628            return [symbName, str(1), "blue"] 
    629629 
    630     def focusDocument(self, w):     
     630    def focusDocument(self, w): 
    631631        if w: w.setFocus() 
    632632 
     
    644644##        dlg.autoLoadSchemasOnStartCB.setChecked(self.settings["autoLoadSchemasOnStart"]) 
    645645        dlg.showSignalNamesCB.setChecked(self.settings["showSignalNames"]) 
    646          
     646 
    647647        dlg.heightEdit.setText(str(self.settings.get("canvasHeight", 600))) 
    648648        dlg.widthEdit.setText(str(self.settings.get("canvasWidth", 700))) 
     
    675675            h = int(str(dlg.heightEdit.text())); 
    676676            w = int(str(dlg.widthEdit.text())) 
    677                          
     677 
    678678            # save general settings 
    679679            if self.snapToGrid != dlg.snapToGridCB.isChecked(): 
     
    686686                self.settings["useLargeIcons"] = self.useLargeIcons 
    687687                self.updateUseLargeIcons() 
    688                      
     688 
    689689            # save exceptions settings 
    690690            #self.settings["catchException"] = dlg.catchExceptionCB.isChecked() 
     
    703703            self.settings["owWarning"] = dlg.owWarning.isChecked() 
    704704            self.settings["owError"] = dlg.owError.isChecked() 
    705                          
     705 
    706706            self.settings["writeLogFile"] = dlg.writeLogFileCB.isChecked() 
    707707            self.settings["canvasHeight"] = int(str(dlg.heightEdit.text())) 
     
    713713            self.settings["useContexts"] = dlg.useContextsCB.isChecked() 
    714714##            self.settings["autoLoadSchemasOnStart"] = dlg.autoLoadSchemasOnStartCB.isChecked() 
    715              
     715 
    716716            self.settings["widgetSelectedColor"] = (dlg.selectedWidgetIcon.color.red(), dlg.selectedWidgetIcon.color.green(), dlg.selectedWidgetIcon.color.blue()) 
    717717            self.settings["widgetActiveColor"]   = (dlg.activeWidgetIcon.color.red(), dlg.activeWidgetIcon.color.green(), dlg.activeWidgetIcon.color.blue()) 
     
    729729                    widget.instance._owInfo      = self.settings["owInfo"] 
    730730                    widget.instance._owWarning   = self.settings["owWarning"] 
    731                     widget.instance._owError     = self.settings["owError"]  
     731                    widget.instance._owError     = self.settings["owError"] 
    732732                    widget.instance.setStatusBarVisible(self.settings["owShow"]) 
    733733 
     
    741741                    line.showSignalNames = show 
    742742                    line.updateTooltip() 
    743                  
     743 
    744744            #self.output.catchException(self.settings["catchException"]) 
    745745            #self.output.catchOutput(self.settings["catchOutput"]) 
     
    775775        text = text.replace("<br>", ""); text = text.replace("&nbsp", "") 
    776776        self.statusBar.message(QString("Last event: " + str(text))) 
    777          
     777 
    778778    ####################### 
    779779    # SETTINGS 
    780780    ####################### 
    781781 
    782     # Loads settings from the widget's .ini file     
     782    # Loads settings from the widget's .ini file 
    783783    def loadSettings(self): 
    784784        filename = os.path.join(self.outputDir, "orngCanvas.ini") 
     
    797797        self.settings.setdefault("saveWidgetsPosition", 0) 
    798798##        self.settings.setdefault("autoLoadSchemasOnStart", 0) 
    799          
     799 
    800800        self.settings.setdefault("widgetSelectedColor", (0, 255, 0)) 
    801801        self.settings.setdefault("widgetActiveColor", (0,0,255)) 
     
    804804        #if not self.settings.has_key("catchException"): self.settings["catchException"] = 1 
    805805        #if not self.settings.has_key("catchOutput"): self.settings["catchOutput"] = 1 
    806          
     806 
    807807        self.settings.setdefault("saveSchemaDir", self.outputDir) 
    808808        self.settings.setdefault("saveApplicationDir", self.outputDir) 
     
    812812        self.settings.setdefault("canvasWidth", 700) 
    813813        self.settings.setdefault("canvasHeight", 600) 
    814          
     814 
    815815        self.settings.setdefault("focusOnCatchException", 1) 
    816816        self.settings.setdefault("focusOnCatchOutput" , 0) 
     
    827827        self.settings.setdefault("owError", 1) 
    828828 
    829                  
     829 
    830830    # Saves settings to this widget's .ini file 
    831831    def saveSettings(self): 
     
    850850            ce.accept() 
    851851            QMainWindow.closeEvent(self, ce) 
    852         
     852 
    853853 
    854854    def keyPressEvent(self, e): 
     
    930930    if arg == "-reload": 
    931931        dlg.menuItemOpenLastSchema() 
    932 app.exec_loop()  
     932app.exec_loop() 
  • orange/OrangeCanvas/orngCanvasItems.py

    r3422 r3495  
    3030        self.hide() 
    3131        self.setCanvas(None) 
    32                         
     32 
    3333    # draw the line 
    3434    def drawShape(self, painter): 
    3535        (startX, startY) = (self.startPoint().x(), self.startPoint().y()) 
    3636        (endX, endY)  = (self.endPoint().x(), self.endPoint().y()) 
    37          
     37 
    3838        painter.setPen(QPen(self.canvasDlg.lineColor, 1, Qt.SolidLine)) 
    3939        painter.drawLine(QPoint(startX, startY), QPoint(endX, endY)) 
    4040 
    41          
     41 
    4242    # we don't print temp lines 
    4343    def printShape(self, painter): 
     
    4949    def updateTooltip(self): 
    5050        pass 
    51      
     51 
    5252    # redraw the line 
    5353    def repaintLine(self, canvasView): 
     
    7373        self.view = view 
    7474        self.setZ(-10) 
    75         self.signals = [] 
    7675        self.colors = [] 
    7776        outPoint = outWidget.getRightEdgePoint() 
     
    8786        self.text.setTextFlags(Qt.AlignHCenter + Qt.AlignBottom) 
    8887        self.text.setColor(QColor(100,100,100)) 
    89          
     88 
    9089    def remove(self): 
    9190        self.hide() 
     
    9897    def getEnabled(self): 
    9998        signals = self.signalManager.findSignals(self.outWidget.instance, self.inWidget.instance) 
    100         if signals!= [] and self.signalManager.isSignalEnabled(self.outWidget.instance, self.inWidget.instance, signals[0][0], signals[0][1]): 
    101             return 1 
    102         else: return 0 
     99        if not signals: return 0 
     100        return int(self.signalManager.isSignalEnabled(self.outWidget.instance, self.inWidget.instance, signals[0][0], signals[0][1])) 
    103101 
    104102    def setEnabled(self, enabled): 
    105         if enabled: self.setPen(QPen(self.canvasDlg.lineColor, 5, Qt.SolidLine)) 
    106         else:       self.setPen(QPen(self.canvasDlg.lineColor, 5, Qt.DashLine)) 
     103        self.setPen(QPen(self.canvasDlg.lineColor, 5, enabled and Qt.SolidLine or Qt.DashLine)) 
    107104        self.updateTooltip() 
    108105 
    109  
    110     def setSignals(self, signals): 
    111         self.signals = signals 
    112         self.updateTooltip() 
    113  
    114106    def getSignals(self): 
    115         return self.signals 
    116      
    117     # show only colors that belong to 3 most important signals 
    118     def setRightColors(self): 
    119         self.colors = [] 
    120         tempList = [] 
    121         for signal in self.signals: 
    122             tempList.append(self.canvasDlg.getChannelInfo(signal)) 
    123         for i in range(3): 
    124             if tempList != []: 
    125                 # find signal with highest priority 
    126                 top = 0 
    127                 index = 0 
    128                 for i in range(len(tempList)): 
    129                     if int(tempList[i][1]) > top: 
    130                         top = int(tempList[i][1]) 
    131                         index = i 
    132                 self.colors.append(tempList[index][2]) 
    133                 tempList.pop(index) 
     107        signals = [] 
     108        for (inWidgetInstance, outName, inName, X) in self.signalManager.links.get(self.outWidget.instance, []): 
     109            if inWidgetInstance == self.inWidget.instance: 
     110                signals.append((outName, inName)) 
     111        return signals 
    134112 
    135113    def drawShape(self, painter): 
     
    138116 
    139117        if self.getEnabled(): lineStyle = Qt.SolidLine 
    140         else:                 lineStyle = Qt.DashLine  
     118        else:                 lineStyle = Qt.DashLine 
    141119 
    142120        painter.setPen(QPen(self.canvasDlg.lineColor, 5 , lineStyle)) 
    143121        painter.drawLine(QPoint(startX, startY), QPoint(endX, endY)) 
    144          
    145          
     122 
     123 
    146124    """ 
    147125    # draw the line 
     
    151129 
    152130        if self.getEnabled(): lineStyle = Qt.SolidLine 
    153         else:                 lineStyle = Qt.DashLine  
     131        else:                 lineStyle = Qt.DashLine 
    154132 
    155133        painter.setPen(QPen(QColor("green"), 1, lineStyle)) 
     
    171149            painter.setPen(QPen(QColor(self.colors[0]), 2, lineStyle)) 
    172150            painter.drawLine(QPoint(startX, startY-3), QPoint(endX, endY-3)) 
    173      
     151 
    174152    # draw the line on the printer 
    175153    def printShape(self, painter): 
     
    178156 
    179157        fact = 10 
    180          
     158 
    181159        if self.getEnabled(): 
    182160            lineStyle = Qt.SolidLine 
    183161        else: 
    184             lineStyle = Qt.DotLine  
     162            lineStyle = Qt.DotLine 
    185163 
    186164        if len(self.colors) == 1: 
     
    205183        x2 = self.endPoint().x(); y2 = self.endPoint().y() 
    206184        self.setPoints(x1 + dx, y1 + dy, x2 + dx, y2 + dy) 
    207          
     185 
    208186    # set the line positions based on the position of input and output widgets 
    209187    def updateLinePos(self): 
     
    231209        p1 = self.startPoint() 
    232210        p2 = self.endPoint() 
     211        signals = self.getSignals() 
    233212 
    234213        string = "<nobr><b>" + self.outWidget.caption + "</b> --> <b>" + self.inWidget.caption + "</b></nobr><br><hr>Signals:<br>" 
    235         for (outSignal, inSignal) in self.signals: 
     214        for (outSignal, inSignal) in signals: 
    236215            string += "<nobr> &nbsp &nbsp - " + outSignal + " --> " + inSignal + "</nobr><br>" 
    237216        string = string[:-4] 
     
    245224            x2 = p1.x() + ((i+1)/float(count))*xDiff + 5 
    246225            y2 = p1.y() + ((i+1)/float(count))*yDiff + 5 
    247              
     226 
    248227            rect = QRect(min(x1, x2), min(y1,y2), abs(x1-x2), abs(y1-y2)) 
    249228            self.tooltipRects.append(rect) 
     
    253232        caption = "" 
    254233        if self.showSignalNames: 
    255             for (outSignal, inSignal) in self.signals: 
     234            for (outSignal, inSignal) in signals: 
    256235                caption += outSignal + "\n" 
    257236        self.text.hide() 
     
    272251        self.parent = parent 
    273252        self.setSize(100, 30) 
    274          
     253 
    275254        self.infoTexts = [] 
    276255        self.warningTexts = [] 
     
    283262 
    284263    def updateState(self, widgetState): 
    285         self.infoTexts = widgetState["Info"].values()  
    286         self.warningTexts = widgetState["Warning"].values()  
    287         self.errorTexts = widgetState["Error"].values()  
     264        self.infoTexts = widgetState["Info"].values() 
     265        self.warningTexts = widgetState["Warning"].values() 
     266        self.errorTexts = widgetState["Error"].values() 
    288267        self.updateWidgetState() 
    289268 
     
    291270        for (x,y,rect, pixmap, text) in self.activeItems: 
    292271            painter.drawPixmap(x, y, pixmap) 
    293         
     272 
    294273    def addWidgetIcon(self, x, y, texts, iconName): 
    295274        if not texts: 
     
    309288        self.removeTooltips() 
    310289        self.activeItems = [] 
    311         if not self.showIcons: return 
     290        if not self.showIcons or not self.widgetIcons: return 
     291 
    312292        count = int(self.infoTexts != []) + int(self.warningTexts != []) + int(self.errorTexts != []) 
    313         if not self.widgetIcons or count == 0: return 
    314          
    315293        startX = self.parent.x() + (self.parent.width()/2) - (count*self.widgetIcons["Info"].width()/2) 
    316294        y = self.parent.y() - 25 
    317295        self.move(startX, y) 
     296 
     297        if count == 0: 
     298            self.view.repaintContents(QRect(startX, y, 100, 40)) 
     299            return 
     300 
    318301        off  = 0 
    319302        if self.showInfo: 
     
    323306        if self.showError: 
    324307            off += self.addWidgetIcon(startX+off, y, self.errorTexts, "Error") 
    325         self.view.repaintContents(QRect(startX, y, 100, 30)) 
    326          
    327          
     308        self.view.repaintContents(QRect(startX, y, 100, 40)) 
     309 
     310 
    328311 
    329312# ####################################### 
     
    343326        if os.path.exists(os.path.join(canvasDlg.picsDir,"WidgetEdge.png")): 
    344327            self.imageEdge = QPixmap(os.path.join(canvasDlg.picsDir,"WidgetEdge.png")) 
    345              
     328 
    346329        self.setSize(68, 68) 
    347330        self.selected = False 
     
    361344        self.widgetStateRect = CanvasWidgetState(self, canvas, view, self.canvasDlg.widgetIcons) 
    362345        self.widgetStateRect.show() 
    363          
     346 
    364347        # import widget class and create a class instance 
    365348        code = compile("import " + widget.getFileName(), ".", "single") 
     
    410393        self.widgetStateRect.showError = self.canvasDlg.settings["ocError"] 
    411394        self.refreshWidgetState() 
    412          
     395 
    413396    def refreshWidgetState(self): 
    414397        self.widgetStateRect.updateState(self.instance.widgetState) 
    415          
     398 
    416399 
    417400    # get the list of connected signal names 
     
    419402        signals = [] 
    420403        for line in self.inLines: 
    421             for (outSignal, inSignal) in line.signals: 
     404            for (outSignal, inSignal) in line.getSignals(): 
    422405                if inSignal not in signals: signals.append(inSignal) 
    423406        return signals 
     
    427410        signals = [] 
    428411        for line in self.outLines: 
    429             for (outSignal, inSignal) in line.signals: 
     412            for (outSignal, inSignal) in line.getSignals(): 
    430413                if outSignal not in signals: signals.append(outSignal) 
    431414        return signals 
    432          
     415 
    433416    def remove(self): 
    434417        self.progressBarRect.hide() 
     
    443426        self.hide() 
    444427        self.setCanvas(None)    # hide the widget 
    445          
     428 
    446429        # save settings 
    447430        if (self.instance != None): 
     
    452435        self.removeTooltip() 
    453436        self.text.hide() 
    454          
     437 
    455438    def savePosition(self): 
    456439        self.oldXPos = self.xPos 
     
    459442    def restorePosition(self): 
    460443        self.setCoords(self.oldXPos, self.oldYPos) 
    461          
     444 
    462445    def updateTextCoords(self): 
    463446        self.text.move(self.xPos + 34, self.yPos + 60) 
     
    517500        elif isinstance(pos, QRect) and LBox.intersects(pos): return True 
    518501        else: return False 
    519          
     502 
    520503    # is mouse position inside the right signal channel 
    521504    def mouseInsideRightChannel(self, pos): 
     
    526509        elif isinstance(pos, QRect) and RBox.intersects(pos): return True 
    527510        else: return False 
    528              
     511 
    529512 
    530513    # we know that the mouse was pressed inside a channel box. We only need to find 
     
    543526        return QPoint(self.x()+ 68, self.y() + 26) 
    544527 
    545     # draw the widget         
     528    # draw the widget 
    546529    def drawShape(self, painter): 
    547530        if self.isProcessing: 
     
    559542            painter.drawRect(self.x()+7, self.y(), 54, 54) 
    560543 
    561          
     544 
    562545        painter.drawPixmap(self.x()+2+8, self.y()+3, self.image) 
    563546 
     
    576559 
    577560        painter.setBrush(QBrush(self.black)) 
    578          
     561 
    579562        if self.imageEdge != None: 
    580563            if self.widget.getInputs() != []:    painter.drawPixmap(self.x(), self.y() + 18, self.imageEdge) 
     
    590573        #painter.drawText(self.x()+34-rect.width()/2, self.y()+52+2, rect.width(), rect.height(), 0, self.caption) 
    591574        #painter.drawPixmap(self.x()+2+8, self.y()+2, self.image) 
    592     """  
     575    """ 
    593576 
    594577    def addOutLine(self, line): 
     
    607590 
    608591        self.updateTooltip() 
    609                  
     592 
    610593 
    611594    def setAllLinesFinished(self, finished): 
     
    672655        #QToolTip.remove(self.view, self.rect()) 
    673656        QToolTip.remove(self.view, self.lastRect) 
    674          
     657 
    675658 
    676659    def showProgressBar(self): 
     
    698681        self.canvas.update() 
    699682        self.repaintWidget() 
    700          
     683 
    701684    def rtti(self): 
    702685        return 1001 
  • orange/OrangeCanvas/orngDlgs.py

    r3448 r3495  
    1010from orngCanvasItems import * 
    1111from qttable import * 
    12 #from orngSignalManager import ExampleTable, ExampleTableWithClass 
    13 #from orngSignalManager import * 
    1412 
    1513def indentedCheckBox(text, parent): 
     
    1816    sep.setFixedSize(10, 10) 
    1917    return QCheckBox(text, b) 
    20      
     18 
    2119 
    2220class QCanvasIcon(QCanvasRectangle): 
     
    6664        xSignalSize = 20    # width of the signal box 
    6765        xIconOff = 10 
    68          
     66 
    6967        count = max(len(inputs), len(outputs)) 
    7068        height = max ((count)*ySignalSpace, 70) 
    71          
     69 
    7270 
    7371        # calculate needed sizes of boxes to show text 
     
    131129        self.texts.append(MyCanvasText(self.dlg.canvas, outName, xWidgetOff + width/2.0, yWidgetOffTop + height + 5, Qt.AlignHCenter + Qt.AlignTop, bold =1, show=1)) 
    132130        self.texts.append(MyCanvasText(self.dlg.canvas, inName, xWidgetOff + width* 1.5 + xSpaceBetweenWidgets, yWidgetOffTop + height + 5, Qt.AlignHCenter + Qt.AlignTop, bold =1, show=1)) 
    133                  
     131 
    134132        return (2*xWidgetOff + 2*width + xSpaceBetweenWidgets, yWidgetOffTop + height + yWidgetOffBottom) 
    135133 
     
    148146        self.bMouseDown = 1 
    149147        activeItems = self.canvas().collisions(QRect(ev.pos().x()-1, ev.pos().y()-1,2,2)) 
    150         
     148 
    151149        if activeItems == []: return 
    152150        box = self.findItem(activeItems, QCanvasRectangle) 
     
    159157            self.tempLine.show() 
    160158            return 
    161          
     159 
    162160        line = self.findItem(activeItems, QCanvasLine) 
    163161        if line: 
     
    166164                    self.dlg.removeLink(outName, inName) 
    167165                    return 
    168          
     166 
    169167    # ################################################################### 
    170168    # mouse button was released ######################################### 
     
    194192                    if box == inBox: inName = name 
    195193                if outName != None and inName != None: self.dlg.addLink(outName, inName) 
    196              
     194 
    197195            self.tempLine.hide() 
    198196            self.tempLine.setCanvas(None) 
    199197            self.canvas().update() 
    200          
     198 
    201199 
    202200    def findItem(self, items, wantedType): 
     
    221219        self.canvas().update() 
    222220        self.lines.append((line, outName, inName, outBox, inBox)) 
    223          
     221 
    224222 
    225223    def removeLink(self, outName, inName): 
     
    254252        self.canvasGroup = QHGroupBox("", self) 
    255253        self.canvas = QCanvas(1000,1000) 
    256         self.canvasView = SignalCanvasView(self, self.canvas, self.canvasGroup)  
     254        self.canvasView = SignalCanvasView(self, self.canvas, self.canvasGroup) 
    257255        self.grid.addWidget(self.canvasGroup, 1,1) 
    258          
     256 
    259257 
    260258        LayoutWidget = QWidget(self,'Layout1') 
     
    268266        #self.buttonHelp.setAutoDefault(1) 
    269267        #Layout1.addWidget(self.buttonHelp) 
    270          
     268 
    271269        self.buttonClearAll = QPushButton("Clear &All", LayoutWidget) 
    272270        Layout1.addWidget(self.buttonClearAll) 
     
    309307                if issubclass(outInstance.getOutputType(outS.name), inInstance.getInputType(inS.name)): count+= 1 
    310308 
    311         return count                
     309        return count 
    312310 
    313311    def existsABetterLink(self, outSignal, inSignal, outSignals, inSignals): 
    314312        existsBetter = 0 
    315         
     313 
    316314        betterOutSignal = None; betterInSignal = None 
    317315        for outS in outSignals: 
     
    404402        self.multiplePossibleConnections = (same[can.index(1)] != 1 and sum(can) > 1) 
    405403        return len(all) > 0 
    406          
     404 
    407405 
    408406 
     
    420418            if inputs[i].name == inName: inSignal = inputs[i] 
    421419 
    422         # if inName is a single signal and connection already exists -> delete it         
     420        # if inName is a single signal and connection already exists -> delete it 
    423421        for (outN, inN) in self._links: 
    424422            if inN == inName and inSignal.single: 
    425423                self.removeLink(outN, inN) 
    426                                  
     424 
    427425        self._links.append((outName, inName)) 
    428426        self.canvasView.addLink(outName, inName) 
     
    453451 
    454452    def showColorDialog(self): 
    455         color = QColorDialog.getColor(self.color, self.parent)         
     453        color = QColorDialog.getColor(self.color, self.parent) 
    456454        if color.isValid(): 
    457455            self.color = color 
     
    502500        self.widthEdit = QLineEdit(widthBox) 
    503501        self.widthEdit.setValidator(validator) 
    504          
     502 
    505503        heightBox = QHBox(canvasSizeBox) 
    506504        heightLabel = QLabel("Height: ", heightBox) 
     
    522520        self.lineIcon = ColorIcon(lineBox, canvasDlg.lineColor) 
    523521        lineLabel = QLabel(" Lines", lineBox) 
    524          
     522 
    525523 
    526524        # ################################################################# 
     
    530528        self.focusOnCatchExceptionCB = QCheckBox('Focus output window on catch', exceptions) 
    531529        self.printExceptionInStatusBarCB = QCheckBox('Print last exception in status bar', exceptions) 
    532          
     530 
    533531        output = QVGroupBox("System output", ExceptionsTab) 
    534532        #self.catchOutputCB = QCheckBox('Catch system output', output) 
     
    558556 
    559557        # ################################################################# 
    560         # WIDGET TAB ORDER  
     558        # WIDGET TAB ORDER 
    561559        caption = QLabel("Set order of widget categories", TabOrderTab) 
    562560        hbox1 = QHBox(TabOrderTab) 
     
    580578 
    581579        # OK, Cancel buttons 
    582          
     580 
    583581        hbox = QHBox(self) 
    584582        if hbox.layout(): 
     
    587585        sep = QWidget(hbox) 
    588586        sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, 0)) 
    589          
     587 
    590588        self.okButton = QPushButton("OK", hbox) 
    591589        self.cancelButton = QPushButton("Cancel", hbox) 
     
    620618        self.downButton.setEnabled(itemIndex < self.tabOrderList.count()-1) 
    621619        self.removeButton.setEnabled(not self.tabs.tabDict[str(self.tabOrderList.currentText())].builtIn) 
    622          
     620 
    623621    def removeCategory(self): 
    624622        curCat = str(self.tabOrderList.currentText()) 
     
    650648                del self.invInvDict[prevkey] 
    651649            return 
    652              
     650 
    653651        if e.key() not in range(32, 128): # + range(Qt.Key_F1, Qt.Key_F35+1): -- this wouldn't work, see the line below, and also writing to file etc. 
    654652            e.ignore() 
     
    660658        if assigned == self: 
    661659            return 
    662          
     660 
    663661        if assigned: 
    664662            dlg = QMessageBox("Confirmation", "'%s' is already assigned to '%s'. Override?" % (pressed, assigned.widget.nameKey), 
     
    667665            if dlg.result() == QMessageBox.No: 
    668666                return 
    669              
     667 
    670668        self.setText(pressed) 
    671669        self.invdict[self.widget] = pressed 
     
    674672            assigned.setText("<none>") 
    675673            del self.invdict[assigned.widget] 
    676          
    677          
     674 
     675 
    678676class WidgetRegistryDlg(QDialog): 
    679677    def __init__(self, canvasDlg, *args): 
     
    688686        self.invDict = dict([(y, x) for x, y in canvasDlg.widgetShortcuts.items()]) 
    689687        invInvDict = {} 
    690          
     688 
    691689        self.tabs = QTabWidget(self, 'tabWidget') 
    692690        for tab in canvasDlg.tabs.tabs: 
     
    702700            for i in range(0, 2*rows, 2): 
    703701                layout.addRowSpacing(i, 20) 
    704                  
     702 
    705703            for i, w in enumerate(widgets): 
    706704                y, x = 1 + 2 * (i % rows), 3 * (i/rows) 
     
    709707                label.setPixmap(pixmap) 
    710708                layout.addWidget(label, y, x) 
    711                  
     709 
    712710                optionsw = QVBox(wtab) 
    713711                layout.addWidget(optionsw, y, x+1, Qt.AlignLeft + Qt.AlignVCenter) 
     
    733731            hbox.layout().setSpacing(6) 
    734732            hbox.layout().setMargin(0) 
    735              
     733 
    736734        sep = QWidget(hbox) 
    737735        sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, 0)) 
    738          
     736 
    739737        self.okButton = QPushButton("OK", hbox) 
    740738        self.okButton.setFixedWidth(110) 
     
    760758        self.grid = QGridLayout( 5, 3 ) 
    761759        self.topLayout.addLayout( self.grid, 10 ) 
    762          
     760 
    763761        groupBox  = QGroupBox(self, "Channel_settings") 
    764762        groupBox.setTitle("Channel settings") 
     
    773771        cap3 = QLabel("Color:", groupBox) 
    774772        self.editFullName = QLineEdit(groupBox) 
    775         self.editPriority = QComboBox( False, groupBox, "priority" )  
     773        self.editPriority = QComboBox( False, groupBox, "priority" ) 
    776774        self.editColor    = QComboBox( False, groupBox, "color" ) 
    777775        #self.connect( self.editPriority, SIGNAL("activated(int)"), self.comboValueChanged ) 
    778         #self.connect( self.editColor, SIGNAL("activated(int)"), self.comboValueChanged )  
     776        #self.connect( self.editColor, SIGNAL("activated(int)"), self.comboValueChanged ) 
    779777 
    780778        propGrid.addWidget(cap1, 0,0, Qt.AlignVCenter+Qt.AlignHCenter) 
     
    787785        groupBox.setMinimumSize(180,150) 
    788786        groupBox.setMaximumSize(180,150) 
    789          
     787 
    790788        saveButton = QPushButton("Save changes", groupBox) 
    791789        addButton = QPushButton("Add new channel name", self) 
     
    794792        self.channelList = QListBox( self, "channels" ) 
    795793        self.channelList.setMinimumHeight(200) 
    796         self.connect( self.channelList, SIGNAL("highlighted(int)"), self.listItemChanged )  
     794        self.connect( self.channelList, SIGNAL("highlighted(int)"), self.listItemChanged ) 
    797795 
    798796        self.grid.addWidget(cap0,0,0, Qt.AlignLeft+Qt.AlignBottom) 
     
    882880                self.channelList.setCurrentItem(i) 
    883881                return 
    884              
     882 
    885883    def removeSignal(self): 
    886884        index = self.channelList.currentItem() 
     
    888886            tempDict = {} 
    889887            symbName = str(self.channelList.text(index)) 
    890              
     888 
    891889            for key in self.channels.keys(): 
    892890                if key != symbName: 
    893891                    tempDict[key] = self.channels[key] 
    894             self.channels = copy(tempDict)         
    895              
     892            self.channels = copy(tempDict) 
     893 
    896894        self.reloadList() 
    897895 
     
    918916        self.tab.setRowMovingEnabled(1) 
    919917        self.grid.addWidget(self.tab, 1,1) 
    920          
     918 
    921919        self.tab.setNumCols(2) 
    922920        self.tabHH = self.tab.horizontalHeader() 
     
    941939 
    942940        self.okButton = QPushButton('&OK', LayoutWidget) 
     941        self.okButton.setDefault(1) 
    943942        Layout1.addWidget(self.okButton) 
    944943        self.connect(self.okButton, SIGNAL("clicked()"), self.accept) 
     
    949948        self.connect(self.buttonCancel, SIGNAL('clicked()'), self, SLOT('reject()')) 
    950949 
    951         self.resize(200,250) 
     950        self.resize(250,250) 
    952951 
    953952    def accept(self): 
     
    959958            elif self.tab.text(i,1) != "[Separator]": 
    960959                self.hiddenWidgetList.append(self.tab.text(i,1)) 
    961         QDialog.accept(self)         
    962          
     960        QDialog.accept(self) 
     961 
    963962 
    964963    def insertSeparator(self): 
     
    977976        self.tab.setText(index, 1, name) 
    978977        #self.tab.adjustColumn(1) 
    979          
    980          
     978 
     979 
    981980    def swapCells(self, row1, row2): 
    982981        self.tab.swapCells( row1,0, row2, 0) 
     
    990989        for i in range(self.tab.numRows()): 
    991990            if self.tab.isSelected(i, 0) or self.tab.isSelected(i, 1): return i 
    992         return -1  
     991        return -1 
    993992 
    994993 
    995994if __name__=="__main__": 
    996     app = QApplication(sys.argv)  
     995    app = QApplication(sys.argv) 
    997996    dlg = CanvasOptionsDlg(app) 
    998997    app.setMainWidget(dlg) 
    999998    dlg.show() 
    1000     app.exec_loop()  
    1001  
     999    app.exec_loop() 
     1000 
  • orange/OrangeCanvas/orngDoc.py

    r3446 r3495  
    1 # Author: Gregor Leban (gregor.leban@fri.uni-lj.si) 
    21# Author: Gregor Leban (gregor.leban@fri.uni-lj.si) 
    32# Description: 
     
    2423        self.setCaption("Schema " + str(self.canvasDlg.iDocIndex)) 
    2524        self.canvasDlg.iDocIndex = self.canvasDlg.iDocIndex + 1 
    26          
     25 
    2726        self.enableSave(False) 
    2827        self.setIcon(QPixmap(canvasDlg.file_new)) 
     
    4241        self.setCentralWidget(self.canvasView) 
    4342        self.canvasView.show() 
    44          
     43 
    4544 
    4645    # we are about to close document 
     
    5251        self.synchronizeContexts() 
    5352        if self.canvasDlg.settings["autoSaveSchemasOnClose"] and self.widgets != []: 
    54             self.save(os.path.join(self.canvasDlg.canvasDir, "_lastSchema.ows")) 
     53            self.save(os.path.join(self.canvasDlg.outputDir, "_lastSchema.ows")) 
    5554 
    5655        if not self.canSave or self.canvasDlg.settings["dontAskBeforeClose"]: 
     
    6160            QMainWindow.closeEvent(self, ce) 
    6261            return 
    63          
     62 
    6463        #QMainWindow.closeEvent(self, ce) 
    6564        res = QMessageBox.information(self,'Orange Canvas','Do you want to save changes made to schema?','&Yes','&No','&Cancel',0) 
     
    110109            dialog.setOutInWidgets(outWidget, inWidget) 
    111110            connectStatus = dialog.addDefaultLinks() 
    112          
     111 
    113112        if connectStatus == 0: 
    114113            QMessageBox.information( None, "Orange Canvas", "Selected widgets don't share a common signal type. Unable to connect.", QMessageBox.Ok + QMessageBox.Default ) 
     
    117116            QMessageBox.critical( None, "Orange Canvas", "Error while connecting widgets. Please rebuild  widget registry (menu Options/Rebuild widget registry) and restart Orange Canvas. Some of the widgets have now different signals.", QMessageBox.Ok + QMessageBox.Default ) 
    118117            return 
    119          
     118 
    120119 
    121120        # if there are multiple choices, how to connect this two widget, then show the dialog 
     
    124123            if dialog.result() == QDialog.Rejected: 
    125124                return 
    126              
     125 
    127126        self.signalManager.setFreeze(1) 
     127        linkCount = 0 
    128128        for (outName, inName) in dialog.getLinks(): 
    129             self.addLink(outWidget, inWidget, outName, inName, enabled) 
    130          
     129            linkCount += self.addLink(outWidget, inWidget, outName, inName, enabled) 
     130 
    131131        self.signalManager.setFreeze(0, outWidget.instance) 
    132132 
     
    148148            if line.outWidget == outWidget and line.inWidget == inWidget: 
    149149                signals = line.getSignals() 
    150              
     150 
    151151        if newSignals == None: 
    152152            dialog = SignalDialog(self.canvasDlg, None, "", True) 
     
    159159            res = dialog.exec_loop() 
    160160            if dialog.result() == QDialog.Rejected: return 
    161                  
     161 
    162162            newSignals = dialog.getLinks() 
    163              
     163 
    164164        for (outName, inName) in signals: 
    165165            if (outName, inName) not in newSignals: 
    166166                self.removeLink(outWidget, inWidget, outName, inName) 
    167167                signals.remove((outName, inName)) 
    168          
     168 
    169169        self.signalManager.setFreeze(1) 
    170170        for (outName, inName) in newSignals: 
     
    172172                self.addLink(outWidget, inWidget, outName, inName, enabled) 
    173173        self.signalManager.setFreeze(0, outWidget.instance) 
    174              
     174 
    175175        outWidget.updateTooltip() 
    176176        inWidget.updateTooltip() 
    177177 
    178178        self.enableSave(True) 
    179          
     179 
    180180 
    181181    # ##################################### 
     
    190190            for (outN, inN) in existingSignals: 
    191191                if inN == inSignalName: 
    192                     self.removeLink(widget, inWidget, outN, inSignalName) 
     192                    self.removeLink(widget, inWidget, outN, inN) 
     193                    line = self.getLine(widget, inWidget) 
     194                    if line: 
     195                        line.updateTooltip() 
    193196 
    194197        # if line does not exist yet, we must create it 
     
    207210 
    208211        ok = self.signalManager.addLink(outWidget.instance, inWidget.instance, outSignalName, inSignalName, enabled) 
    209         if not ok: print "orngDoc.addLink - Error. Unable to add link." 
    210         line.setSignals(line.getSignals() + [(outSignalName, inSignalName)]) 
     212        if not ok: 
     213            self.removeLink(outWidget, inWidget, outSignalName, inSignalName) 
     214            QMessageBox.warning( None, "Orange Canvas", "Unable to add link. Please rebuild widget registry and restart Orange Canvas for changes to take effect.", QMessageBox.Ok + QMessageBox.Default ) 
     215            return 0 
     216        line.updateTooltip() 
     217        return 1 
    211218 
    212219    # #################################### 
     
    215222        #print "<extra> orngDoc.py - removeLink() - ", outWidget, inWidget, outSignalName, inSignalName 
    216223        self.signalManager.removeLink(outWidget.instance, inWidget.instance, outSignalName, inSignalName) 
    217          
     224 
    218225        otherSignals = 0 
    219         for (widget, signalFrom, signalTo, enabled) in self.signalManager.links[outWidget.instance]: 
    220             if widget == inWidget.instance: otherSignals = 1 
     226        if self.signalManager.links.has_key(outWidget.instance): 
     227            for (widget, signalFrom, signalTo, enabled) in self.signalManager.links[outWidget.instance]: 
     228                if widget == inWidget.instance: 
     229                    otherSignals = 1 
    221230        if not otherSignals: 
    222231            self.removeLine(outWidget, inWidget) 
     
    227236    # remove line line 
    228237    def removeLine1(self, line): 
    229         for (outName, inName) in line.signals: 
     238        for (outName, inName) in line.getSignals(): 
    230239            self.signalManager.removeLink(line.outWidget.instance, line.inWidget.instance, outName, inName)   # update SignalManager 
    231240 
     
    237246        line.hide() 
    238247        line.remove() 
    239         self.enableSave(True)         
     248        self.enableSave(True) 
    240249 
    241250    # #################################### 
     
    245254        line = self.getLine(outWidget, inWidget) 
    246255        if line: self.removeLine1(line) 
    247          
     256 
    248257    # #################################### 
    249258    # add new widget 
     
    265274            return None 
    266275        qApp.restoreOverrideCursor() 
    267          
     276 
    268277        if x==-1 or y==-1: 
    269278            x = self.canvasView.contentsX() + 10 
     
    277286 
    278287        if caption == "": caption = newwidget.caption 
    279          
     288 
    280289        if self.getWidgetByCaption(caption): 
    281290            i = 2 
     
    301310            sys.excepthook(type, val, traceback)  # we pretend that we handled the exception, so that it doesn't crash canvas 
    302311        qApp.restoreOverrideCursor() 
    303          
     312 
    304313        self.widgets.append(newwidget) 
    305314        self.enableSave(True) 
    306         self.canvas.update()     
     315        self.canvas.update() 
    307316        return newwidget 
    308317 
     
    314323        while widget.inLines != []: self.removeLine1(widget.inLines[0]) 
    315324        while widget.outLines != []:  self.removeLine1(widget.outLines[0]) 
    316                  
     325 
    317326        self.signalManager.removeWidget(widget.instance) 
    318327        self.widgets.remove(widget) 
     
    353362                return widget 
    354363        return None 
    355                      
     364 
    356365    def getWidgetCaption(self, widgetInstance): 
    357366        for widget in self.widgets: 
     
    365374    def getLine(self, outWidget, inWidget): 
    366375        for line in self.lines: 
    367             if line.outWidget == outWidget and line.inWidget == inWidget: return line 
     376            if line.outWidget == outWidget and line.inWidget == inWidget: 
     377                return line 
    368378        return None 
    369379 
     
    396406        self.setCaption(self.documentname) 
    397407        self.documentnameValid = True 
    398         self.save()         
    399  
    400     # #################################### 
    401     # save the file             
     408        self.save() 
     409 
     410    # #################################### 
     411    # save the file 
    402412    def save(self, filename = None): 
    403413        self.enableSave(False) 
     
    442452        else: 
    443453            file = open(os.path.join(self.documentpath, self.documentname), "wt") 
    444          
     454 
    445455        file.write(xmlText) 
    446456        file.flush() 
     
    450460        #self.saveWidgetSettings(os.path.join(self.documentpath, os.path.splitext(self.documentname)[0]) + ".sav") 
    451461        if not filename: 
    452             self.canvasDlg.addToRecentMenu(os.path.join(self.documentpath, self.documentname))         
     462            self.canvasDlg.addToRecentMenu(os.path.join(self.documentpath, self.documentname)) 
    453463 
    454464    def saveWidgetSettings(self, filename): 
     
    462472 
    463473 
    464     # ####################################                     
     474    # #################################### 
    465475    # load a scheme with name "filename" 
    466476    def loadDocument(self, filename, caption = None): 
     
    487497            settingsDict = eval(str(settings[0].getAttribute("settingsDictionary"))) 
    488498            self.loadedSettingsDict = settingsDict 
     499            self.canvasDlg.settings["saveApplicationDir"] = self.applicationpath 
    489500 
    490501            # read widgets 
     
    500511                qApp.processEvents() 
    501512 
    502             #read lines                         
     513            #read lines 
    503514            lineList = lines.getElementsByTagName("channel") 
    504515            for line in lineList: 
     
    529540 
    530541            # do we want to restore last position and size of the widget 
    531             if self.canvasDlg.settings["saveWidgetsPosition"]:   
     542            if self.canvasDlg.settings["saveWidgetsPosition"]: 
    532543                for widget in self.widgets: 
    533544                    widget.instance.restoreWidgetStatus() 
     
    535546            # set cursor 
    536547            qApp.setOverrideCursor(QWidget.arrowCursor) 
    537      
     548 
    538549 
    539550    # ########################################### 
     
    561572        shownWidgetList = saveDlg.shownWidgetList 
    562573        hiddenWidgetList = saveDlg.hiddenWidgetList 
    563          
     574 
    564575        (self.applicationpath, self.applicationname) = os.path.split(str(qname)) 
    565576        fileName = os.path.splitext(self.applicationname)[0] 
     
    572583DEBUG_MODE = 0   #set to 1 to output debugging info to file 'signalManagerOutput.txt' 
    573584orngRegistry.addWidgetDirectories()\n""" 
    574          
     585 
    575586        captions = "# set widget captions\n" +t+t 
    576587        instancesT = "# create widget instances\n" +t+t 
     
    597608 
    598609                name = widget.caption 
    599                 name = name.replace(" ", "_") 
    600                 name = name.replace("(", "") 
    601                 name = name.replace(")", "") 
     610                name = name.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    602611                imports += "from %s import *\n" % (widget.widget.getFileName()) 
    603612                instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
     
    620629                buttons += "frameSpace%s = QFrame(self);  frameSpace%s.setMinimumHeight(10); frameSpace%s.setMaximumHeight(10)\n" % (str(sepCount), str(sepCount), str(sepCount)) +t+t 
    621630                sepCount += 1 
    622                  
     631 
    623632        instancesT += n+t+t + "# create instances of hidden widgets\n\n" +t+t 
    624633        instancesB += n+t+t + "# create instances of hidden widgets\n\n" +t+t 
    625          
     634 
    626635        # gui for hidden widgets 
    627636        for widgetName in hiddenWidgetList: 
     
    631640 
    632641            name = widget.caption 
    633             name = name.replace(" ", "_") 
    634             name = name.replace("(", "") 
    635             name = name.replace(")", "") 
     642            name = name.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    636643            imports += "from %s import *\n" % (widget.widget.getFileName()) 
    637644            instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
     
    644651            saveSett += """strSettings["%s"] = self.ow%s.saveSettingsStr()\n""" % (widget.caption, name) +t+t 
    645652            widgetInstanceList += "self.ow%s, " % (name) 
    646          
     653 
    647654        for line in self.lines: 
    648655            if not line.getEnabled(): continue 
    649656 
    650657            outWidgetName = line.outWidget.caption 
    651             outWidgetName = outWidgetName.replace(" ", "_") 
    652             outWidgetName = outWidgetName.replace("(", "") 
    653             outWidgetName = outWidgetName.replace(")", "") 
     658            outWidgetName = outWidgetName.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    654659            inWidgetName = line.inWidget.caption 
    655             inWidgetName = inWidgetName.replace(" ", "_") 
    656             inWidgetName = inWidgetName.replace("(", "") 
    657             inWidgetName = inWidgetName.replace(")", "") 
    658      
    659             for (outName, inName) in line.getSignals():             
     660            inWidgetName = inWidgetName.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
     661 
     662            for (outName, inName) in line.getSignals(): 
    660663                links += "self.signalManager.addLink( self.ow" + outWidgetName + ", self.ow" + inWidgetName + ", '" + outName + "', '" + inName + "', 1)\n" +t+t 
    661664 
    662         widgetInstanceList += "]"     
     665        widgetInstanceList += "]" 
    663666        links += "self.signalManager.setFreeze(0)\n" +t+t 
    664667        buttons += "frameSpace = QFrame(self);  frameSpace.setMinimumHeight(20); frameSpace.setMaximumHeight(20)\n"+t+t 
     
    691694        if self.verbosity >= eventVerbosity: 
    692695            self.status.setText(text) 
    693          
     696 
    694697    def progressHandler(self, widget, val): 
    695698        if val < 0: 
     
    701704        else: 
    702705            self.progress.setProgress(val) 
    703             self.update()"""     
     706            self.update()""" 
    704707 
    705708        loadSettings = """ 
    706          
     709 
    707710    def loadSettings(self): 
    708711        try: 
     
    716719 
    717720        saveSettings = """ 
    718          
     721 
    719722    def saveSettings(self): 
    720723        if DEBUG_MODE: return 
     
    725728        file.close() 
    726729        """ % (fileName + ".sav") 
    727          
    728                  
     730 
     731 
    729732        finish = """ 
    730 if __name__ == "__main__":  
     733if __name__ == "__main__": 
    731734    application = QApplication(sys.argv) 
    732735    ow = GUIApplication() 
     
    746749        else: 
    747750            whole = imports + "\n\n" + "class GUIApplication(QVBox):" + classinit + "\n\n"+t+t+ instancesB + signals + n+n+t+t+ widgetInstanceList +n+t+t + captions + n+t+t+ icons + n+t+t + manager + n+t+t + buttons + n + progress + n +t+t+  buttonsConnect + n +t+t + links + "\n\n" + handlerFunct + "\n\n" + loadSettings + saveSettings + "\n\n" + finish 
    748          
     751 
    749752        #save app 
    750753        fileApp = open(os.path.join(self.applicationpath, self.applicationname), "wt") 
     
    756759        # save settings 
    757760        self.saveWidgetSettings(os.path.join(self.applicationpath, fileName) + ".sav") 
    758          
     761 
    759762    def dumpWidgetVariables(self): 
    760763        for widget in self.widgets: 
     
    783786        else: 
    784787            QMainWindow.keyPressEvent(self, e) 
    785          
    786  
    787 if __name__=='__main__':  
     788 
     789 
     790if __name__=='__main__': 
    788791    app = QApplication(sys.argv) 
    789792    dlg = SchemaDoc() 
    790793    app.setMainWidget(dlg) 
    791794    dlg.show() 
    792     app.exec_loop()  
     795    app.exec_loop() 
  • orange/OrangeCanvas/orngRegistry.py

    r3453 r3495  
    99 
    1010    # read all installed widgets, build a registry and store widgets.pth with directory names in python dir 
    11     def ParseWidgetRoot(self, widgetDirName, canvasDir): 
     11    def ParseWidgetRoot(self, widgetDirName, outputDir): 
    1212        widgetDirName = os.path.realpath(widgetDirName) 
    13         canvasDir = os.path.realpath(canvasDir) 
    14          
     13        outputDir = os.path.realpath(outputDir) 
     14 
    1515        # create xml document 
    1616        doc = xml.dom.minidom.Document() 
     
    2525                self.ParseDirectory(doc, categories, full_filename, filename) 
    2626 
    27         additionalFile = os.path.join(canvasDir, "additionalCategories") 
     27        additionalFile = os.path.join(outputDir, "additionalCategories") 
    2828        if os.path.exists(additionalFile): 
    2929            for lne in open(additionalFile, "rt"): 
     
    3333                except: 
    3434                    pass 
    35                  
     35 
    3636 
    3737        # we put widgets that are in the root dir of widget directory to category "Other" 
    3838        self.ParseDirectory(doc, categories, widgetDirName, "Other") 
    39          
     39 
    4040        xmlText = doc.toprettyxml() 
    41         file = open(os.path.join(canvasDir, "widgetregistry.xml"), "wt") 
     41        file = open(os.path.join(outputDir, "widgetregistry.xml"), "wt") 
    4242        file.write(xmlText) 
    4343        file.flush() 
     
    4949        if sys.path.count(full_dirname) == 0:       # add directory to orange path 
    5050            sys.path.append(full_dirname)          # this doesn't save the path when you close the canvas, so we have to save also to widgets.pth 
    51          
     51 
    5252        for filename in os.listdir(full_dirname): 
    5353            full_filename = os.path.join(full_dirname, filename) 
     
    7575            if (name == None):      # if the file doesn't have a name, we treat it as a non-widget file 
    7676                continue 
    77              
     77 
    7878            # create XML node for the widget 
    7979            child = categories.firstChild 
    8080            while (child != None and child.attributes.get("name").nodeValue != categoryName): 
    8181                child= child.nextSibling 
    82      
     82 
    8383            if (child == None): 
    8484                child = doc.createElement("category") 
     
    8787                    child.setAttribute("directory", full_dirname) 
    8888                categories.appendChild(child) 
    89      
     89 
    9090            widget = doc.createElement("widget") 
    9191            widget.setAttribute("file", filename[:-3]) 
     
    9797            widget.setAttribute("author", author) 
    9898            widget.setAttribute("contact", contact) 
    99              
    100             # description             
     99 
     100            # description 
    101101            if (description != ""): 
    102102                desc = doc.createElement("description") 
     
    123123        if (search == None): 
    124124            return None 
    125          
     125 
    126126        text = search.group(0) 
    127127        text = text[text.find(">")+1:-text[::-1].find("<")-1]    #delete the <...> </...> 
    128128        return text.strip() 
    129129 
    130          
     130 
    131131    def GetAllInputs(self, data): 
    132132        #result = re.search('self.inputs *= *[[].*]', data) 
     
    165165 
    166166 
    167 canvasDir = os.path.dirname(__file__) 
    168  
    169167def rebuildRegistry(): 
     168    dirs = __getDirectoryNames() 
    170169    parse = WidgetsToXML() 
    171     widgetDir = os.path.join(canvasDir, "../OrangeWidgets") 
    172     parse.ParseWidgetRoot(widgetDir, canvasDir)     
    173      
     170    widgetDir = os.path.join(dirs["canvasDir"], "../OrangeWidgets") 
     171    parse.ParseWidgetRoot(widgetDir, dirs["outputDir"]) 
     172 
    174173def readAdditionalCategories(): 
    175     return [tuple([x.strip() for x in lne.split("\t")]) for lne in open(os.path.join(canvasDir, "additionalCategories"), "r")] 
     174    dirs = __getDirectoryNames() 
     175    return [tuple([x.strip() for x in lne.split("\t")]) for lne in open(os.path.join(dirs["outputDir"], "additionalCategories"), "r")] 
    176176 
    177177def writeAdditionalCategories(categories): 
    178     open(os.path.join(canvasDir, "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
     178    dirs = __getDirectoryNames() 
     179    open(os.path.join(dirs["canvasDir"], "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
    179180 
    180181def addWidgetCategory(category, directory, add = True): 
     
    184185    rebuildRegistry() 
    185186 
    186 #addWidgetCategory 
    187187 
    188188 
     
    195195        orangeDir = os.path.split(os.path.abspath(orange.__file__))[0] 
    196196        canvasDir = os.path.join(orangeDir, "OrangeCanvas") 
    197      
     197 
    198198    widgetDir = os.path.join(orangeDir, "OrangeWidgets") 
    199199    if not os.path.exists(widgetDir): 
    200200        print "Error. Directory %s not found. Unable to locate widgets." % widgetDir 
    201      
     201 
    202202    reportsDir = os.path.join(orangeDir, "report") 
    203203    if not os.path.exists(reportsDir): 
     
    209209 
    210210    if os.name == "nt": 
    211         outputDir = canvasDir 
     211        outputDir = os.path.join(os.path.join(user.home, "Application Data"), "Orange")                  # directory for saving settings and stuff 
    212212    else: 
    213213        outputDir = os.path.join(user.home, "Orange")                  # directory for saving settings and stuff 
    214         if not os.path.exists(outputDir): 
    215                 os.mkdir(outputDir) 
    216         outputDir = os.path.join(outputDir, "OrangeCanvas") 
    217         if not os.path.exists(outputDir): 
    218             os.mkdir(outputDir) 
    219      
     214    if not os.path.exists(outputDir): 
     215        os.mkdir(outputDir) 
     216    outputDir = os.path.join(outputDir, "OrangeCanvas") 
     217    if not os.path.exists(outputDir): 
     218        os.mkdir(outputDir) 
     219 
    220220    registryFileName = os.path.join(outputDir, "widgetregistry.xml") 
    221221    if not os.path.exists(registryFileName): 
     
    223223   
    224224    return dict([(name, vars()[name]) for name in ["canvasDir", "orangeDir", "widgetDir", "reportsDir", "picsDir", "outputDir", "registryFileName"]]) 
    225    
     225 
    226226 
    227227def addWidgetDirectories(): 
     
    229229        for name in os.listdir(widgetDir): 
    230230            fullName = os.path.join(widgetDir, name) 
    231             if os.path.isdir(fullName):  
    232                 print "A", fullName 
     231            if os.path.isdir(fullName): 
    233232                sys.path.append(fullName) 
    234233 
  • orange/OrangeCanvas/orngSignalManager.py

    r3424 r3495  
    1818        self.type = signalType 
    1919        self.handler = handler 
    20          
     20 
    2121        if type(parameters) == str: parameters = eval(parameters)   # in registry, parameters are stored as strings 
    2222        # if we have the old definition of parameters then transform them 
     
    2525            self.default = not oldParam 
    2626            return 
    27          
     27 
    2828        if not (parameters & Single or parameters & Multiple): parameters += Single 
    2929        if not (parameters & Default or parameters & NonDefault): parameters += NonDefault 
     
    3535        self.name = name 
    3636        self.type = signalType 
    37          
     37 
    3838        if type(parameters) == str: parameters = eval(parameters) 
    3939        if parameters in [0,1]: # old definition of parameters 
    4040            self.default = not parameters 
    4141            return 
    42          
     42 
    4343        if not (parameters & Default or parameters & NonDefault): parameters += NonDefault 
    4444        self.default = parameters & Default 
     
    7676        self.verbosity = verbosity 
    7777        self.stderr = sys.stderr 
     78        #self.stdout = sys.stdout 
    7879        if debugMode: 
    7980            self.debugFile = open(debugFileName, "wt") 
    8081            sys.excepthook = self.exceptionHandler 
    8182            sys.stderr = self.debugFile 
     83            #sys.stdout = self.debugFile 
    8284 
    8385    def setDebugMode(self, debugMode = 0, debugFileName = "signalManagerOutput.txt", verbosity = 1): 
     
    8587        if self.debugFile: 
    8688            sys.stderr = self.stderr 
     89            #sys.stdout = self.stdout 
    8790            self.debugFile.close() 
    8891        if debugMode: 
     
    9093            sys.excepthook = self.exceptionHandler 
    9194            sys.stderr = self.debugFile 
     95            #sys.stdout = self.debugFile 
    9296 
    9397    # ---------------------------------------------------------- 
     
    99103            self.debugFile.close() 
    100104            sys.stderr = self.stderr 
    101  
    102     #  
     105            #sys.stdout = self.stdout 
     106 
     107    # 
    103108    def addEvent(self, strValue, object = None, eventVerbosity = 1): 
    104109        if not self.debugFile: return 
    105110        if self.verbosity < eventVerbosity: return 
    106                         
     111 
    107112        self.debugFile.write(strValue) 
    108113        if type(object) == orange.ExampleTable: 
     
    135140        self.debugFile.write(totalSpace[:-1] + "Exception value: " + str(value)+ "\n") 
    136141        self.debugFile.flush() 
    137          
     142 
    138143    # ---------------------------------------------------------- 
    139144    # ---------------------------------------------------------- 
     
    150155        if self.verbosity >= 2: 
    151156            self.addEvent("added widget " + widget.title, eventVerbosity = 2) 
    152              
     157 
    153158        if widget not in self.widgets: 
    154159            #self.widgets.insert(0, widget) 
     
    160165            self.addEvent("remove widget " + widget.title, eventVerbosity = 2) 
    161166        self.widgets.remove(widget) 
    162          
     167 
    163168 
    164169    # send list of widgets, that send their signal to widget's signalName 
     
    180185        return widgets 
    181186 
    182     # can we connect widgetFrom with widgetTo, so that there is no cycle?     
     187    # can we connect widgetFrom with widgetTo, so that there is no cycle? 
    183188    def canConnect(self, widgetFrom, widgetTo): 
    184         return not self.existsPath(widgetTo, widgetFrom)         
     189        return not self.existsPath(widgetTo, widgetFrom) 
    185190 
    186191    def addLink(self, widgetFrom, widgetTo, signalNameFrom, signalNameTo, enabled): 
    187192        if self.verbosity >= 2: 
    188193            self.addEvent("add link from " + widgetFrom.title + " to " + widgetTo.title, eventVerbosity = 2) 
    189          
     194 
    190195        if not self.canConnect(widgetFrom, widgetTo): return 0 
    191196        # check if signal names still exist 
     
    225230            for key in widgetFrom.linksOut[signalNameFrom].keys(): 
    226231                widgetTo.updateNewSignalData(widgetFrom, signalNameTo, widgetFrom.linksOut[signalNameFrom][key], key, signalNameFrom) 
    227              
     232 
    228233        # reorder widgets if necessary 
    229234        if self.widgets.index(widgetFrom) > self.widgets.index(widgetTo): 
     
    259264                return enabled 
    260265        return 0 
    261      
     266 
    262267    def removeLink(self, widgetFrom, widgetTo, signalNameFrom, signalNameTo): 
    263268        if self.verbosity >= 2: 
    264269            self.addEvent("remove link from " + widgetFrom.title + " to " + widgetTo.title, eventVerbosity = 2) 
    265          
     270 
    266271        # no need to update topology, just remove the link 
    267         for (widget, signalFrom, signalTo, enabled) in self.links[widgetFrom]: 
    268             if widget == widgetTo and signalFrom == signalNameFrom and signalTo == signalNameTo: 
    269                 for key in widgetFrom.linksOut[signalFrom].keys(): 
    270                     widgetTo.updateNewSignalData(widgetFrom, signalNameTo, None, key, signalNameFrom) 
    271                 self.links[widgetFrom].remove((widget, signalFrom, signalTo, enabled)) 
    272                 if not self.freezing and not self.signalProcessingInProgress: self.processNewSignals(widgetFrom) 
     272        if self.links.has_key(widgetFrom): 
     273            for (widget, signalFrom, signalTo, enabled) in self.links[widgetFrom]: 
     274                if widget == widgetTo and signalFrom == signalNameFrom and signalTo == signalNameTo: 
     275                    for key in widgetFrom.linksOut[signalFrom].keys(): 
     276                        widgetTo.updateNewSignalData(widgetFrom, signalNameTo, None, key, signalNameFrom) 
     277                    self.links[widgetFrom].remove((widget, signalFrom, signalTo, enabled)) 
     278                    if not self.freezing and not self.signalProcessingInProgress: self.processNewSignals(widgetFrom) 
    273279        widgetTo.removeInputConnection(widgetFrom, signalNameTo) 
    274280 
     
    290296        if enabled: self.processNewSignals(widgetTo) 
    291297 
    292      
     298 
    293299    def getLinkEnabled(self, widgetFrom, widgetTo): 
    294300        for (widget, nameFrom, nameTo, enabled) in self.links[widgetFrom]:      # it is enough that we find one signal connected from widgetFrom to widgetTo 
     
    309315                #print "signal from ", widgetFrom, " to ", widgetTo, " signal: ", signalNameFrom, " value: ", value, " id: ", id 
    310316                widgetTo.updateNewSignalData(widgetFrom, signalTo, value, id, signalNameFrom) 
    311                  
     317 
    312318 
    313319        if not self.freezing and not self.signalProcessingInProgress: 
     
    315321            self.processNewSignals(widgetFrom) 
    316322 
    317     # when a new link is created, we have to  
     323    # when a new link is created, we have to 
    318324    def sendOnNewLink(self, widgetFrom, widgetTo, signals): 
    319325        for (outName, inName) in signals: 
     
    325331        if len(self.widgets) == 0: return 
    326332        if self.signalProcessingInProgress: return 
    327          
    328         if self.verbosity >= 2: 
    329             self.addEvent("process new signals from " + firstWidget.title, eventVerbosity = 2)   
    330          
     333 
     334        if self.verbosity >= 2: 
     335            self.addEvent("process new signals from " + firstWidget.title, eventVerbosity = 2) 
     336 
    331337        if firstWidget not in self.widgets: 
    332338            firstWidget = self.widgets[0]   # if some window that is not a widget started some processing we have to process new signals from the first widget 
     
    351357        # is there a direct link 
    352358        if not self.links.has_key(widgetFrom): return 0 
    353          
     359 
    354360        for (widget, signalFrom, signalTo, enabled) in self.links[widgetFrom]: 
    355361            if widget == widgetTo: return 1 
  • orange/OrangeCanvas/orngView.py

    r3426 r3495  
    4747        self.linePopup.insertItem( "Reset Signals",  self.resetLineSignals) 
    4848        self.linePopup.insertItem( "Remove",  self.deleteSelectedLine) 
    49         self.linePopup.insertSeparator()  
    50  
    51     
     49        self.linePopup.insertSeparator() 
     50 
     51 
    5252    # ########################################### 
    5353    # POPUP MENU - WIDGET actions 
     
    6161                self.tempWidget.instance.showNormal() 
    6262 
    63     # popMenuAction - user selected to rename active widget             
     63    # popMenuAction - user selected to rename active widget 
    6464    def renameActiveWidget(self): 
    6565        exName = str(self.tempWidget.caption) 
     
    118118        self.selectedLine = None 
    119119        self.canvas().update() 
    120      
     120 
    121121    def deleteLine(self, line): 
    122122        if line != None: 
     
    126126    def resendSignals(self): 
    127127        if self.selectedLine != None: 
    128             self.doc.signalManager.setLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance, newState) 
     128            self.doc.signalManager.setLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance, 1, justSend = 1) 
    129129 
    130130    def resetLineSignals(self): 
     
    138138        for item in self.selWidgets: item.setSelected(0) 
    139139        self.selWidgets = [] 
    140      
    141     # ########################################### 
    142     # ########################################### 
    143      
     140 
     141    # ########################################### 
     142    # ########################################### 
     143 
    144144    # return number of items in "items" of type "type" 
    145145    def findItemTypeCount(self, items, type): 
     
    173173                pass 
    174174        return ret 
    175          
     175 
    176176 
    177177    # ########################################### 
     
    186186            self.tempRect.setCanvas(None) 
    187187            self.tempRect = None 
    188          
     188 
    189189        for item in self.doc.widgets: 
    190190            if item not in self.selWidgets: item.setSelected(0) 
     
    192192            #item.show() 
    193193 
    194         rect = QRect(ev.pos().x()-5, ev.pos().y()-5,10,10)         
     194        rect = QRect(ev.pos().x()-5, ev.pos().y()-5,10,10) 
    195195        activeItems = self.canvas().collisions(rect) 
    196196        if activeItems == []: 
     
    199199            self.bMultipleSelection = True 
    200200            self.unselecteAllWidgets() 
    201              
    202         # we clicked on a widget or on a line             
     201 
     202        # we clicked on a widget or on a line 
    203203        elif activeItems != []: 
    204204            widget = self.findFirstItemType(activeItems, orngCanvasItems.CanvasWidget) 
     
    219219                        self.unselecteAllWidgets() 
    220220                        self.canvas().update() 
    221                      
     221 
    222222                # we clicked inside the widget and we start dragging it 
    223223                elif ev.button() == QMouseEvent.LeftButton: 
     
    242242                        w.setAllLinesFinished(False) 
    243243                        w.repaintAllLines() 
    244                      
     244 
    245245                # is we clicked the right mouse button we show the popup menu for widgets 
    246246                elif ev.button() == QMouseEvent.RightButton: 
     
    255255                    self.unselecteAllWidgets() 
    256256                    self.selectedLine = line 
    257                     self.linePopup.setItemChecked(self.menupopupLinkEnabledID, self.selectedLine.getEnabled())  
     257                    self.linePopup.setItemChecked(self.menupopupLinkEnabledID, self.selectedLine.getEnabled()) 
    258258                    self.linePopup.popup(ev.globalPos()) 
    259259                elif ev.button() == QMouseEvent.LeftButton: 
     
    288288                    item.moveToGrid() 
    289289                else: 
    290                     item.setCoords(item.xPos, item.yPos)                     
     290                    item.setCoords(item.xPos, item.yPos) 
    291291 
    292292                items = self.canvas().collisions(item.rect()) 
     
    295295                else:         item.invalidPosition = False 
    296296                item.updateLineCoords() 
    297              
     297 
    298298        elif self.bLineDragging: 
    299299            if self.tempLine: self.tempLine.setPoints(self.tempLine.startPoint().x(), self.tempLine.startPoint().y(), ev.pos().x(), ev.pos().y()) 
     
    321321    # ################################################################### 
    322322    # mouse button was released ######################################### 
    323     def contentsMouseReleaseEvent(self, ev):         
     323    def contentsMouseReleaseEvent(self, ev): 
    324324        if self.tempRect: 
    325325            self.tempRect.hide() 
    326326            self.tempRect.setCanvas(None) 
    327327            self.tempRect = None 
    328          
     328 
    329329        # if we are moving a widget 
    330330        if self.bWidgetDragging: 
     
    346346                item.repaintWidget() 
    347347                item.repaintAllLines() 
    348                  
     348 
    349349            self.doc.enableSave(True) 
    350350 
     
    373373                    line = self.doc.addLine(outWidget, inWidget) 
    374374                    if line: line.repaintLine(self) 
    375                  
     375 
    376376            if self.tempLine != None: 
    377377                self.tempLine.setPoints(0,0,0,0) 
     
    379379                self.tempLine.setCanvas(None) 
    380380                self.tempLine = None 
    381                  
     381 
    382382        self.canvas().update() 
    383383        self.bMouseDown = False 
     
    386386 
    387387    def contentsMouseDoubleClickEvent(self, ev): 
    388         rect = QRect(ev.pos().x()-3, ev.pos().y()-3,6,6)         
    389         activeItems = self.canvas().collisions(rect)     
     388        rect = QRect(ev.pos().x()-3, ev.pos().y()-3,6,6) 
     389        activeItems = self.canvas().collisions(rect) 
    390390        widget = self.findFirstItemType(activeItems, orngCanvasItems.CanvasWidget) 
    391391        line   = self.findFirstItemType(activeItems, orngCanvasItems.CanvasLine) 
     
    426426                self.repaint() 
    427427                return 
    428              
     428 
    429429 
    430430#    def drawContents(self, painter): 
     
    436436# 
    437437#    def drawContents(self, painter, x, y, w, h): 
    438 #        rect = QRect(x,y,w,h)         
     438#        rect = QRect(x,y,w,h) 
    439439#        activeItems = self.canvas().collisions(rect) 
    440440#        for item in activeItems: 
Note: See TracChangeset for help on using the changeset viewer.