Changeset 4014:107cdd743fd2 in orange


Ignore:
Timestamp:
07/20/07 19:58:44 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
d8c9ae6ac8578726ecbcac0f5800dae367f58e1b
Message:

no message

Location:
orange/OrangeCanvas
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeCanvas/orngCanvas.pyw

    r3792 r4014  
    22# Description: 
    33#    main file, that creates the MDI environment 
    4 from PyQt4.QtCore import * 
    5 from PyQt4.QtGui import * 
    6 import sys, os, cPickle 
    7 import orngTabs, orngDoc, orngDlgs, orngOutput 
    8 import orange, user, orngMisc, orngRegistry, orngOrangeFoldersQt4 
     4 
     5from qt import * 
     6import sys, os, cPickle, user 
     7import orngTabs, orngDoc, orngDlgs, orngOutput, orngRegistry 
    98 
    109class OrangeCanvasDlg(QMainWindow): 
    11     def __init__(self, parent = None, flags = 0): 
    12         QMainWindow.__init__(self, parent) 
     10    def __init__(self,*args): 
     11        apply(QMainWindow.__init__,(self,) + args) 
     12        self.ctrlPressed = 0    # we have to save keystate, so that orngView can access information about keystate 
    1313        self.debugMode = 1        # print extra output for debuging 
    14         self.setWindowTitle("Qt Orange Canvas") 
     14        if (int(qVersion()[0]) >= 3): 
     15            self.setCaption("Orange Canvas") 
     16        else: 
     17            self.setCaption("Qt Orange Canvas") 
    1518        self.windows = []    # list of id for windows in Window menu 
    1619        self.windowsDict = {}    # dict. with id:menuitem for windows in Window menu 
    1720 
    18         self.__dict__.update(orngOrangeFoldersQt4.directoryNames) 
     21        self.__dict__.update(orngRegistry.directoryNames) 
    1922 
    2023        #self.setFocusPolicy(QWidget.StrongFocus) 
    2124         
     25##        import OWReport 
     26##        OWReport.IEFeeder(self.reportsDir) 
     27 
    2228        self.defaultPic = os.path.join(self.picsDir, "Unknown.png") 
    2329 
    2430        canvasIconName = os.path.join(self.canvasDir, "icons/CanvasIcon.png") 
    2531        if os.path.exists(canvasIconName): 
    26             self.setWindowIcon(QIcon(canvasIconName)) 
    27          
    28         orngOrangeFoldersQt4.addOrangeDirectoriesToPath(self.registryFileName) 
     32            self.setIcon(QPixmap(canvasIconName)) 
     33 
     34        if not self.orangeDir in sys.path: 
     35            sys.path.append(self.orangeDir) 
     36 
     37        if not self.widgetDir in sys.path: 
     38            sys.path.append(self.widgetDir) 
    2939 
    3040        # create error and warning icons 
     
    4353            self.widgetIcons = None 
    4454            print "Unable to load all necessary icons. Please reinstall Orange." 
    45          
     55 
    4656        self.workspace = WidgetWorkspace(self) 
    4757        #self.workspace.setBackgroundColor(QColor(255,255,255)) 
    4858        self.setCentralWidget(self.workspace) 
    4959        self.statusBar = MyStatusBar(self) 
    50         self.setStatusBar(self.statusBar) 
    5160        self.connect(self.workspace, SIGNAL("windowActivated(QWidget*)"), self.focusDocument) 
    52          
     61 
    5362        self.settings = {} 
    5463        self.widgetInfo = {} # this is a dictionary with items: category-widget_name : {info about widget (inList, outList, description...} 
    55          
     64 
    5665        self.rebuildSignals()    # coloring of signals - unused! 
    5766        self.useLargeIcons = False 
     
    5968 
    6069        self.loadSettings() 
    61          
     70 
    6271        self.useLargeIcons = self.settings["useLargeIcons"] 
    6372        self.snapToGrid = self.settings["snapToGrid"] 
    64          
     73 
    6574        self.widgetSelectedColor = QColor(self.settings["widgetSelectedColor"][0], self.settings["widgetSelectedColor"][1], self.settings["widgetSelectedColor"][2]) 
    6675        self.widgetActiveColor   = QColor(self.settings["widgetActiveColor"][0], self.settings["widgetActiveColor"][1], self.settings["widgetActiveColor"][2]) 
    6776        self.lineColor           = QColor(self.settings["lineColor"][0], self.settings["lineColor"][1], self.settings["lineColor"][2]) 
    6877 
    69         # create toolbar         
    70         self.toolbar = self.addToolBar("Toolbar") 
    71         self.toolbar.setOrientation(Qt.Horizontal) 
     78        self.toolbar = QToolBar(self, 'Toolbar') 
     79        self.widgetsToolBar = QToolBar( self, 'Widgets') 
    7280 
    7381        self.iDocIndex = 1 
     
    8391        self.move_right= os.path.join(canvasPicsDir, "moveright.png") 
    8492 
    85         # create menu 
    8693        self.initMenu() 
    8794 
    88         self.toolbar.addAction(QIcon(self.file_new), "New schema" , self.menuItemNewSchema) 
    89         self.toolbar.addAction(QIcon(self.file_open), "Open schema", self.menuItemOpen) 
    90         self.toolSave = self.toolbar.addAction(QIcon(self.file_save), "Save schema", self.menuItemSave) 
     95        self.toolNew  = QToolButton(QIconSet(QPixmap(self.file_new)), "New schema" , QString.null, self.menuItemNewSchema, self.toolbar, 'new schema') 
     96        #self.toolNew.setUsesTextLabel (True) 
     97        self.toolOpen = QToolButton(QIconSet(QPixmap(self.file_open)), "Open schema" , QString.null, self.menuItemOpen , self.toolbar, 'open schema') 
     98        self.toolSave = QToolButton(QIconSet(QPixmap(self.file_save)), "Save schema" ,QString.null, self.menuItemSave, self.toolbar, 'save schema') 
    9199        self.toolbar.addSeparator() 
    92         self.toolbar.addAction(QIcon(self.file_print), "Print", self.menuItemPrinter) 
    93  
    94         self.addToolBarBreak() 
    95          
    96         # read widgets     
    97         #if hasattr(self.widgetsToolBar, "setHorizontalStretchable"): self.widgetsToolBar.setHorizontalStretchable(True)         
    98         #else: self.widgetsToolBar.setHorizontallyStretchable(True) 
    99         self.widgetsToolBar = self.addToolBar("Widgets") 
    100         self.widgetsToolBar.setOrientation(Qt.Horizontal) 
     100        toolPrint = QToolButton(QIconSet(QPixmap(self.file_print)), "Print" ,QString.null, self.menuItemPrinter, self.toolbar, 'print') 
     101 
     102        # qt version compatibility 
     103        if hasattr(self, "addDockWindow"): self.addDockWindow(self.toolbar, "Toolbar", Qt.DockTop, True) 
     104        else:                  self.addToolBar(self.toolbar, "Toolbar", QMainWindow.Top, True) 
     105 
     106        # read widgets 
     107        if hasattr(self.widgetsToolBar, "setHorizontalStretchable"): self.widgetsToolBar.setHorizontalStretchable(True) 
     108        else: self.widgetsToolBar.setHorizontallyStretchable(True) 
    101109        self.createWidgetsToolbar(not os.path.exists(self.registryFileName)) 
    102                 
     110 
     111        orngRegistry.addWidgetDirectories() 
    103112        self.readShortcuts() 
    104          
     113 
    105114        # read recent files 
    106115        self.recentDocs = [] 
     
    110119        height = self.settings.get("canvasHeight", 600) 
    111120        self.resize(width, height) 
    112          
     121 
    113122        # center window in the desktop 
    114123        deskH = app.desktop().height() 
     
    118127        self.move(w,h) 
    119128 
    120          
    121129        # apply output settings 
    122         self.output = orngOutput.OutputWindow(self, self.workspace) 
     130        self.output = orngOutput.OutputWindow(self, self.workspace, "", Qt.WDestructiveClose) 
    123131        self.output.show() 
    124132        #self.output.catchException(self.settings["catchException"]) 
     
    134142 
    135143        self.show() 
    136                  
     144 
    137145        # create new schema 
    138146        win = self.menuItemNewSchema() 
     
    153161    def createWidgetsToolbar(self, rebuildRegistry): 
    154162        self.widgetsToolBar.clear() 
    155         self.tabs = orngTabs.WidgetTabs(self, self.widgetInfo, self.widgetsToolBar) 
    156         #self.tabs.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
    157         self.widgetsToolBar.addWidget(self.tabs) 
    158                  
     163        self.tabs = orngTabs.WidgetTabs(self.widgetInfo, self.widgetsToolBar, 'tabs') 
     164 
     165        if hasattr(self, "addDockWindow") : self.addDockWindow(self.widgetsToolBar, "Widgets", Qt.DockTop, True) 
     166        else:                               self.addToolBar(self.widgetsToolBar, "Widgets", QMainWindow.Top, True) 
     167 
     168        self.tabs.setCanvasDlg(self) 
     169 
     170        # if registry doesn't exist yet, we create it 
    159171        ## the registry is now build already in the orngRegistry when setting up the directory names 
    160172        if rebuildRegistry == 1: 
    161173            parse = orngRegistry.WidgetsToXML() 
    162             parse.ParseWidgetRoot(self.widgetDir, self.canvasSettingsDir) 
    163              
     174            parse.ParseWidgetRoot(self.widgetDir, self.outputDir) 
     175 
    164176        # if registry still doesn't exist then something is very wrong... 
    165177        if not os.path.exists(self.registryFileName): 
    166             QMessageBox.critical( self, "Orange Canvas", "Unable to locate widget registry. Exiting...") 
     178            QMessageBox.critical( None, "Orange Canvas", "Unable to locate widget registry. Exiting...", QMessageBox.Ok, QMessageBox.Cancel) 
    167179            self.quit() 
    168180 
     
    171183        else: 
    172184            widgetTabList = ["Data", "Classify", "Evaluate", "Visualize", "Associate", "Genomics", "Other"] 
    173              
    174         for tab in widgetTabList: self.tabs.insertWidgetTab(tab) 
    175                  
     185 
     186        for tab in widgetTabList: 
     187            self.tabs.insertWidgetTab(tab) 
     188 
    176189        # read widget registry file and create tab with buttons 
    177190        self.tabs.readInstalledWidgets(self.registryFileName, self.widgetDir, self.picsDir, self.defaultPic, self.useLargeIcons) 
     
    180193        widgetTabList = [] 
    181194        for tab in self.tabs.tabs: 
    182             widgetTabList.append(str(self.tabs.tabText(self.tabs.indexOf(tab)))) 
     195            widgetTabList.append(str(self.tabs.tabLabel(tab))) 
    183196        self.settings["WidgetTabs"] = widgetTabList 
    184              
     197 
    185198 
    186199    def readShortcuts(self): 
    187200        self.widgetShortcuts = {} 
    188         shfn = os.path.join(self.canvasSettingsDir, "shortcuts.txt") 
     201        shfn = os.path.join(self.outputDir, "shortcuts.txt") 
    189202        if os.path.exists(shfn): 
    190203            for t in file(shfn).readlines(): 
     
    195208                else: 
    196209                    print "Warning: invalid shortcut %s (%s)" % (key, button) 
    197          
     210 
    198211    def initMenu(self): 
    199212        # ################### 
    200213        # menu items 
    201214        # ################### 
    202         self.menuRecent = QMenu("Recent Schemas", self) 
    203          
    204         self.menuFile = QMenu("&File", self) 
    205         self.menuFile.addAction(QIcon(self.file_new), "&New",  self.menuItemNewSchema, Qt.CTRL+Qt.Key_N ) 
    206         #self.menuFile.addAction( "New from template",  self.menuItemNewFromTemplate) 
    207         #self.menuFile.addAction( "New from wizard",  self.menuItemNewWizard) 
    208         self.menuFile.addAction(QIcon(self.file_open), "&Open...", self.menuItemOpen, Qt.CTRL+Qt.Key_O ) 
    209         if os.path.exists(os.path.join(self.canvasSettingsDir, "_lastSchema.ows")): 
    210             self.menuFile.addAction("Reload Last Schema", self.menuItemOpenLastSchema, Qt.CTRL+Qt.Key_R) 
    211         self.menuFile.addAction( "&Close", self.menuItemClose ) 
    212         self.menuFile.addSeparator() 
    213         self.menuSaveID = self.menuFile.addAction(QIcon(self.file_save), "&Save", self.menuItemSave, Qt.CTRL+Qt.Key_S ) 
    214         self.menuSaveAsID = self.menuFile.addAction( "Save &As...", self.menuItemSaveAs) 
    215         self.menuFile.addAction( "&Save as Application (Tabs)...", self.menuItemSaveAsAppTabs) 
    216         self.menuFile.addAction( "&Save as Application (Buttons)...", self.menuItemSaveAsAppButtons) 
    217         self.menuFile.addSeparator() 
    218         self.menuFile.addAction(QIcon(self.file_print), "&Print Schema / Save image", self.menuItemPrinter, Qt.CTRL+Qt.Key_P ) 
    219         self.menuFile.addSeparator() 
    220         self.menuFile.addMenu(self.menuRecent) 
    221         self.menuFile.addSeparator() 
    222         #self.menuFile.addAction( "E&xit",  qApp, SLOT( "quit()" ), Qt.CTRL+Qt.Key_Q ) 
    223         self.menuFile.addAction( "E&xit",  self.close, Qt.CTRL+Qt.Key_Q ) 
    224  
    225         self.menuEdit = QMenu("&Edit", self) 
    226         self.menuEdit.addAction( "Cu&t",  self.menuItemCut, Qt.CTRL+Qt.Key_X ) 
    227         self.menuEdit.addAction( "&Copy",  self.menuItemCopy, Qt.CTRL+Qt.Key_C ) 
    228         self.menuEdit.addAction( "&Paste",  self.menuItemPaste, Qt.CTRL+Qt.Key_V ) 
    229         self.menuFile.addSeparator() 
    230         self.menuEdit.addAction( "Select &All",  self.menuItemSelectAll, Qt.CTRL+Qt.Key_A ) 
    231  
    232         self.menuOptions = QMenu("&Options", self) 
    233         #self.menuOptions.addAction( "Grid",  self.menuItemGrid ) 
    234         #self.menuOptions.addSeparator() 
    235         #self.menuOptions.addAction( "Show Grid",  self.menuItemShowGrid) 
    236  
    237         self.menuOptions.addAction( "Enable All Links",  self.menuItemEnableAll, Qt.CTRL+Qt.Key_E) 
    238         self.menuOptions.addAction( "Disable All Links",  self.menuItemDisableAll, Qt.CTRL+Qt.Key_D) 
    239         self.menuOptions.addAction( "Clear Scheme",  self.menuItemClearWidgets) 
     215        self.menuRecent = QPopupMenu(self) 
     216 
     217        self.menuFile = QPopupMenu( self ) 
     218        self.menuFile.insertItem(QIconSet(QPixmap(self.file_new)), "&New",  self.menuItemNewSchema, Qt.CTRL+Qt.Key_N ) 
     219        #self.menuFile.insertItem( "New from template",  self.menuItemNewFromTemplate) 
     220        #self.menuFile.insertItem( "New from wizard",  self.menuItemNewWizard) 
     221        self.menuFile.insertItem(QIconSet(QPixmap(self.file_open)), "&Open...", self.menuItemOpen, Qt.CTRL+Qt.Key_O ) 
     222        if os.path.exists(os.path.join(self.outputDir, "_lastSchema.ows")): 
     223            self.menuFile.insertItem("&Reload Last Schema", self.menuItemOpenLastSchema, Qt.CTRL + Qt.Key_R) 
     224        self.menuFile.insertItem( "Close", self.menuItemClose ) 
     225        self.menuFile.insertSeparator() 
     226        self.menuSaveID = self.menuFile.insertItem(QIconSet(QPixmap(self.file_save)), "&Save", self.menuItemSave, Qt.CTRL+Qt.Key_S ) 
     227        self.menuSaveAsID = self.menuFile.insertItem( "Save As...", self.menuItemSaveAs) 
     228        self.menuFile.insertItem( "Save as Application (Tabs)...", self.menuItemSaveAsAppTabs) 
     229        self.menuFile.insertItem( "Save as Application (Buttons)...", self.menuItemSaveAsAppButtons) 
     230        self.menuFile.insertSeparator() 
     231        self.menuFile.insertItem(QIconSet(QPixmap(self.file_print)), "Print Schema / Save image", self.menuItemPrinter) 
     232        self.menuFile.insertSeparator() 
     233        self.menuFile.insertItem( "&Recent Files", self.menuRecent) 
     234        self.menuFile.insertSeparator() 
     235        #self.menuFile.insertItem( "E&xit",  qApp, SLOT( "quit()" ), Qt.CTRL+Qt.Key_Q ) 
     236        self.menuFile.insertItem( "Exit",  self.close, Qt.CTRL+Qt.Key_Q ) 
     237 
     238##        self.menuEdit = QPopupMenu( self ) 
     239##        self.menuEdit.insertItem( "Cu&t",  self.menuItemCut, Qt.CTRL+Qt.Key_X ) 
     240##        self.menuEdit.insertItem( "&Copy",  self.menuItemCopy, Qt.CTRL+Qt.Key_C ) 
     241##        self.menuEdit.insertItem( "&Paste",  self.menuItemPaste, Qt.CTRL+Qt.Key_V ) 
     242##        self.menuFile.insertSeparator() 
     243##        self.menuEdit.insertItem( "Select &All",  self.menuItemSelectAll, Qt.CTRL+Qt.Key_A ) 
     244 
     245        self.menuOptions = QPopupMenu( self ) 
     246        #self.menuOptions.insertItem( "Grid",  self.menuItemGrid ) 
     247        #self.menuOptions.insertSeparator() 
     248        #self.menuOptions.insertItem( "Show Grid",  self.menuItemShowGrid) 
     249 
     250        self.menuOptions.insertItem( "&Enable All Links",  self.menuItemEnableAll, Qt.CTRL+Qt.Key_E) 
     251        self.menuOptions.insertItem( "&Disable All Links",  self.menuItemDisableAll, Qt.CTRL+Qt.Key_D) 
     252        self.menuOptions.insertItem( "Clear Scheme",  self.menuItemClearWidgets) 
    240253 
    241254        # uncomment this only for debugging 
    242         #self.menuOptions.addAction("Dump widget variables", self.dumpVariables) 
    243          
    244         self.menuOptions.addSeparator() 
    245         #self.menuOptions.addAction( "Channel preferences",  self.menuItemPreferences) 
    246         #self.menuOptions.addSeparator() 
    247         self.menuOptions.addAction( "&Rebuild Widget Registry",  self.menuItemRebuildWidgetRegistry) 
    248         self.menuOptions.addAction( "&Customize Shortcuts",  self.menuItemEditWidgetShortcuts) 
    249         self.menuOptions.addSeparator() 
    250         self.menuOptions.addAction( "Canvas &Options...",  self.menuItemCanvasOptions) 
    251          
    252         self.menuWindow = QMenu("&Window", self)  
    253         self.menuWindow.addAction("&Cascade", self.workspace.cascade) 
    254         self.menuWindow.addAction("&Tile", self.workspace.tile) 
    255         self.menuWindow.addSeparator() 
    256          
     255        #self.menuOptions.insertItem("Dump widget variables", self.dumpVariables) 
     256 
     257        self.menuOptions.insertSeparator() 
     258        #self.menuOptions.insertItem( "Channel preferences",  self.menuItemPreferences) 
     259        #self.menuOptions.insertSeparator() 
     260        self.menuOptions.insertItem( "&Rebuild Widget Registry",  self.menuItemRebuildWidgetRegistry) 
     261        self.menuOptions.insertItem( "&Customize Shortcuts",  self.menuItemEditWidgetShortcuts) 
     262        self.menuOptions.insertSeparator() 
     263        if sys.platform == "darwin": 
     264            self.menuOptions.insertItem("&Preferences...", self.menuItemCanvasOptions) 
     265        else: 
     266            self.menuOptions.insertItem( "Canvas &Options...",  self.menuItemCanvasOptions) 
     267 
     268        self.menuWindow = QPopupMenu( self ) 
     269        self.menuWindow.insertItem("&Cascade", self.workspace.cascade) 
     270        self.menuWindow.insertItem("&Tile", self.workspace.tile) 
     271        self.menuWindow.insertSeparator() 
     272 
    257273        self.connect(self.menuWindow, SIGNAL("aboutToShow()"), self.showWindows) 
    258274 
    259         self.menupopupShowToolbarID = self.menuWindow.addAction( "Toolbar",  self.menuItemShowToolbar ) 
    260         self.menupopupShowToolbarID.setCheckable(True)  
     275        self.menupopupShowToolbarID = self.menuWindow.insertItem( "Toolbar",  self.menuItemShowToolbar ) 
    261276        if self.settings.has_key("showToolbar"): self.showToolbar = self.settings["showToolbar"] 
    262277        else:                                    self.showToolbar = True 
    263278        if not self.showToolbar: self.toolbar.hide() 
    264         self.menupopupShowToolbarID.setChecked(self.showToolbar)  
    265          
    266         self.menupopupShowWidgetToolbarID = self.menuWindow.addAction( "Widget Toolbar",  self.menuItemShowWidgetToolbar) 
    267         self.menupopupShowWidgetToolbarID.setCheckable(True)  
     279        self.menuWindow.setItemChecked(self.menupopupShowToolbarID, self.showToolbar) 
     280 
     281        self.menupopupShowWidgetToolbarID = self.menuWindow.insertItem( "Widget Toolbar",  self.menuItemShowWidgetToolbar) 
    268282        if self.settings.has_key("showWidgetToolbar"): self.showWidgetToolbar = self.settings["showWidgetToolbar"] 
    269         else:                                          self.showWidgetToolbar = True 
     283        else:                                    self.showWidgetToolbar = True 
    270284        if not self.showWidgetToolbar: self.widgetsToolBar.hide() 
    271         self.menupopupShowWidgetToolbarID.setChecked(self.showWidgetToolbar) 
    272          
    273         self.menuWindow.addSeparator() 
    274         self.menuOutput = QMenu("Output", self) 
    275         self.menuWindow.addMenu(self.menuOutput) 
    276         self.menuOutput.addAction("Show Output Window", self.menuItemShowOutputWindow) 
    277         self.menuOutput.addAction("Clear Output Window", self.menuItemClearOutputWindow) 
    278         self.menuOutput.addSeparator() 
    279         self.menuOutput.addAction("Save Output Text...", self.menuItemSaveOutputWindow) 
    280         self.menuWindow.addSeparator() 
    281  
    282         self.menuWindow.addAction("&Minimize All", self.menuMinimizeAll) 
    283         self.menuWindow.addAction("Restore All", self.menuRestoreAll) 
    284         self.menuWindow.addAction("Close All", self.menuCloseAll) 
    285         self.menuWindow.addSeparator() 
     285        self.menuWindow.setItemChecked(self.menupopupShowWidgetToolbarID, self.showWidgetToolbar) 
     286 
     287        self.menuWindow.insertSeparator() 
     288        self.menuOutput = QPopupMenu(self) 
     289        self.menuWindow.insertItem( "Output &Window", self.menuOutput) 
     290        self.menuOutput.insertItem("Show Output Window", self.menuItemShowOutputWindow) 
     291        self.menuOutput.insertItem("Clear Output Window", self.menuItemClearOutputWindow) 
     292        self.menuOutput.insertSeparator() 
     293        self.menuOutput.insertItem("Save Output Text...", self.menuItemSaveOutputWindow) 
     294        self.menuWindow.insertSeparator() 
     295 
     296        self.menuWindow.insertItem("&Minimize All", self.menuMinimizeAll) 
     297        self.menuWindow.insertItem("Restore All", self.menuRestoreAll) 
     298        self.menuWindow.insertItem("Close All", self.menuCloseAll) 
     299        self.menuWindow.insertSeparator() 
    286300 
    287301        localHelp = 0 
    288         self.menuHelp = QMenu("&Help", self) 
     302        self.menuHelp = QPopupMenu( self ) 
    289303        if os.path.exists(os.path.join(self.orangeDir, r"doc/reference/default.htm")) or os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): 
    290             if os.path.exists(os.path.join(self.orangeDir, r"doc/reference/default.htm")): self.menuHelp.addAction("Orange Help", self.menuOpenLocalOrangeHelp) 
    291             if os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): self.menuHelp.addAction("Orange Canvas Help", self.menuOpenLocalCanvasHelp) 
    292          
    293         self.menuHelp.addAction("Orange Online Help", self.menuOpenOnlineOrangeHelp) 
    294         #self.menuHelp.addAction("Orange Canvas Online Help", self.menuOpenOnlineCanvasHelp) 
    295          
     304            if os.path.exists(os.path.join(self.orangeDir, r"doc/reference/default.htm")): self.menuHelp.insertItem("Orange Help", self.menuOpenLocalOrangeHelp) 
     305            if os.path.exists(os.path.join(self.orangeDir, r"doc/canvas/default.htm")): self.menuHelp.insertItem("Orange Canvas Help", self.menuOpenLocalCanvasHelp) 
     306 
     307        self.menuHelp.insertItem("Orange Online Help", self.menuOpenOnlineOrangeHelp) 
     308        #self.menuHelp.insertItem("Orange Canvas Online Help", self.menuOpenOnlineCanvasHelp) 
     309 
    296310        if os.path.exists(os.path.join(self.orangeDir, r"updateOrange.py")): 
    297             self.menuHelp.addSeparator() 
    298             self.menuHelp.addAction("Check for updates", self.menuCheckForUpdates) 
    299  
    300         #self.menuHelp.addSeparator() 
    301         #self.menuHelp.addAction("About Orange Canvas", self.menuHelpAbout) 
    302          
    303  
    304         self.menuBar = QMenuBar(self)  
    305         self.menuBar.addMenu(self.menuFile) 
    306         #self.menuBar.addMenu(self.menuEdit) 
    307         self.menuBar.addMenu(self.menuOptions) 
    308         self.menuBar.addMenu(self.menuWindow) 
    309         self.menuBar.addMenu(self.menuHelp) 
    310         self.setMenuBar(self.menuBar) 
    311  
    312         self.printer = QPrinter()  
     311            self.menuHelp.insertSeparator() 
     312            self.menuHelp.insertItem("Check for updates", self.menuCheckForUpdates) 
     313 
     314        #self.menuHelp.insertSeparator() 
     315        #self.menuHelp.insertItem("About Orange Canvas", self.menuHelpAbout) 
     316 
     317        self.menuBar = QMenuBar( self ) 
     318        self.menuBar.insertItem( "&File", self.menuFile ) 
     319        #self.menuBar.insertItem( "&Edit", self.menuEdit ) 
     320        self.menuBar.insertItem( "&Options", self.menuOptions ) 
     321        self.menuBar.insertItem("&Window", self.menuWindow) 
     322        self.menuBar.insertItem("&Help", self.menuHelp) 
     323 
     324        self.printer = QPrinter() 
    313325 
    314326 
    315327    def showWindows(self): 
    316328        for id in self.windowsDict.keys(): 
    317             self.menuWindow.removeAction(id) 
     329            self.menuWindow.removeItem(id) 
    318330        self.windowsDict = {} 
    319331        wins = self.workspace.windowList() 
    320332        for i in range(len(wins)): 
    321             txt = str(i+1) + ' ' + str(wins[i].windowTitle()) 
     333            txt = str(i+1) + ' ' + str(wins[i].caption()) 
    322334            if i<10: txt = "&" + txt 
    323             id = self.menuWindow.addAction(txt, wins[i].setFocus) 
     335            id = self.menuWindow.insertItem(txt, self.activateWindowById) 
    324336            self.windowsDict[id]=wins[i] 
    325337 
    326 ##    def actionEvent(self, event): 
    327 ##        if event.type() == QEvent.ActionChanged and event.action() in self.windowsDict.keys(): 
    328 ##            self.windowsDict[event.action()].parentWidget.setFocus() 
    329              
     338    def activateWindowById(self, id): 
     339        self.windowsDict[id].setFocus() 
    330340 
    331341    def menuItemNewSchema(self, forceNew = 1): 
     
    333343            for doc in self.workspace.getDocumentList(): 
    334344                if doc.widgets == []: return doc 
    335         win = orngDoc.SchemaDoc(self, self.workspace) 
     345        win = orngDoc.SchemaDoc(self, self.workspace, "", Qt.WDestructiveClose) 
    336346        self.workspace.setDefaultDocPosition(win) 
    337347        return win 
     
    344354 
    345355    def menuItemOpen(self): 
    346         name = QFileDialog.getOpenFileName(self, "Open File", self.settings["saveSchemaDir"], "Orange Widget Scripts (*.ows)") 
     356        name = QFileDialog.getOpenFileName( self.settings["saveSchemaDir"], "Orange Widget Scripts (*.ows)", self, "", "Open File") 
    347357        if name.isEmpty(): 
    348358            return 
     
    352362 
    353363    def menuItemOpenLastSchema(self): 
    354         if os.path.exists(os.path.join(self.canvasSettingsDir, "_lastSchema.ows")): 
     364        if os.path.exists(os.path.join(self.outputDir, "_lastSchema.ows")): 
    355365            win = self.menuItemNewSchema(0) 
    356             win.loadDocument(os.path.join(self.canvasSettingsDir, "_lastSchema.ows"), str(win.windowTitle())) 
     366            win.loadDocument(os.path.join(self.outputDir, "_lastSchema.ows"), str(win.caption())) 
    357367 
    358368    def menuItemClose(self): 
    359369        win = self.workspace.activeWindow() 
    360370        win.close() 
    361          
     371 
    362372    def menuItemSave(self): 
    363373        win = self.workspace.activeWindow() 
     
    380390        win = self.workspace.activeWindow() 
    381391        if isinstance(win, orngDoc.SchemaDoc): 
    382             win.saveDocumentAsApp(asTabs = 1)     
     392            win.saveDocumentAsApp(asTabs = 1) 
    383393 
    384394    def menuItemPrinter(self): 
     
    393403        sizeDlg = OWDlgs.OWChooseImageSizeDlg(win.canvas) 
    394404        sizeDlg.exec_loop() 
    395          
     405 
    396406 
    397407    def readRecentFiles(self): 
     
    407417        recentDocs = recentDocs[:9] 
    408418        self.settings["RecentFiles"] = recentDocs 
    409          
     419 
    410420        for i in range(len(recentDocs)): 
    411421            shortName = "&" + str(i+1) + " " + os.path.basename(recentDocs[i]) 
    412             self.menuRecent.addAction(shortName, eval("self.menuItemRecent"+str(i+1))) 
     422            self.menuRecent.insertItem(shortName, eval("self.menuItemRecent"+str(i+1))) 
    413423 
    414424    def openRecentFile(self, index): 
     
    425435        # convert to a valid file name 
    426436        name = os.path.realpath(name) 
    427          
     437 
    428438        if name in recentDocs: 
    429439            recentDocs.remove(name) 
     
    476486    def menuItemGrid(self): 
    477487        return 
    478          
     488 
    479489    def menuItemShowGrid(self): 
    480490        return 
    481          
     491 
    482492    def updateSnapToGrid(self): 
    483493        if self.snapToGrid == True: 
     
    492502    def updateUseLargeIcons(self): 
    493503        self.createWidgetsToolbar(0) 
    494                  
     504 
    495505    def menuItemEnableAll(self): 
    496506        win = self.workspace.activeWindow() 
    497507        if isinstance(win, orngDoc.SchemaDoc): 
    498508            win.enableAllLines() 
    499          
     509 
    500510    def menuItemDisableAll(self): 
    501511        win = self.workspace.activeWindow() 
     
    519529    def menuItemClearOutputWindow(self): 
    520530        self.output.textOutput.setText("") 
    521         self.statusBar.showMessage("") 
     531        self.statusBar.message("") 
    522532 
    523533    def menuItemSaveOutputWindow(self): 
    524         qname = QFileDialog.getSaveFileName(self, "Save Output To File", self.canvasSettingsDir + "/Output.htm", "HTML Document (*.htm)") 
     534        qname = QFileDialog.getSaveFileName( self.settings["saveSchemaDir"] + "/Output.htm", "HTML Document (*.htm)", self, "", "Save Output To File") 
    525535        if qname.isEmpty(): return 
    526536        name = str(qname) 
     
    537547        self.showToolbar = not self.showToolbar 
    538548        self.settings["showToolbar"] = self.showToolbar 
    539         self.menupopupShowToolbarID.setChecked(self.showToolbar) 
     549        self.menuWindow.setItemChecked(self.menupopupShowToolbarID, self.showToolbar) 
    540550        if self.showToolbar: self.toolbar.show() 
    541551        else: self.toolbar.hide() 
     
    544554        self.showWidgetToolbar = not self.showWidgetToolbar 
    545555        self.settings["showWidgetToolbar"] = self.showWidgetToolbar 
    546         self.menupopupShowWidgetToolbarID.setChecked(self.showWidgetToolbar) 
     556        self.menuWindow.setItemChecked(self.menupopupShowWidgetToolbarID, self.showWidgetToolbar) 
    547557        if self.showWidgetToolbar: self.widgetsToolBar.show() 
    548558        else: self.widgetsToolBar.hide() 
     
    558568    def menuItemRebuildWidgetRegistry(self): 
    559569        self.createWidgetsToolbar(True) 
    560          
     570 
    561571    def menuItemEditWidgetShortcuts(self): 
    562         dlg = orngDlgs.WidgetRegistryDlg(self) 
    563         if dlg.exec_() == QDialog.Accepted: 
     572        dlg = orngDlgs.WidgetRegistryDlg(self, None, "", True) 
     573        dlg.exec_loop() 
     574        if dlg.result() == QDialog.Accepted: 
     575 
    564576            self.widgetShortcuts = dict([(y, x) for x, y in dlg.invDict.items()]) 
    565             shf = file(os.path.join(self.canvasSettingsDir, "shortcuts.txt"), "wt") 
     577            shf = file(os.path.join(self.outputDir, "shortcuts.txt"), "wt") 
    566578            for k, v in self.widgetShortcuts.items(): 
    567579                shf.write("%s: %s\n" % (k, v.nameKey)) 
     
    571583        for win in wins: 
    572584            win.close() 
    573              
     585 
    574586    def menuMinimizeAll(self): 
    575587        wins = self.workspace.windowList() 
    576588        for win in wins: 
    577589            win.showMinimized() 
    578              
     590 
    579591    def menuRestoreAll(self): 
    580592        wins = self.workspace.windowList() 
     
    604616 
    605617    def menuHelpAbout(self): 
    606         pass     
     618        pass 
    607619 
    608620    def rebuildSignals(self): 
     
    625637            return [symbName, str(1), "blue"] 
    626638 
    627     def focusDocument(self, w):     
     639    def focusDocument(self, w): 
    628640        if w: w.setFocus() 
    629641 
    630642    def menuItemCanvasOptions(self): 
    631         dlg = orngDlgs.CanvasOptionsDlg(self, None) 
     643        dlg = orngDlgs.CanvasOptionsDlg(self, None, "", True) 
    632644 
    633645        # set general options settings 
     
    645657        dlg.widthEdit.setText(str(self.settings.get("canvasWidth", 700))) 
    646658 
    647         # set current exception settings 
     659        # exception tab 
    648660        dlg.focusOnCatchExceptionCB.setChecked(self.settings["focusOnCatchException"]) 
    649661        dlg.printExceptionInStatusBarCB.setChecked(self.settings["printExceptionInStatusBar"]) 
    650662        dlg.focusOnCatchOutputCB.setChecked(self.settings["focusOnCatchOutput"]) 
    651663        dlg.printOutputInStatusBarCB.setChecked(self.settings["printOutputInStatusBar"]) 
    652         dlg.verbosityCombo.setCurrentIndex(self.settings["outputVerbosity"]) 
     664        dlg.verbosityCombo.setCurrentItem(self.settings["outputVerbosity"]) 
    653665        dlg.ocShow.setChecked(self.settings["ocShow"]) 
    654666        dlg.ocInfo.setChecked(self.settings["ocInfo"]) 
     
    662674        # fill categories tab list 
    663675        oldTabList = [] 
    664         for i in range(self.tabs.count()): 
    665             text = str(self.tabs.tabText(i)) 
    666             dlg.tabOrderList.addItem(text) 
    667             oldTabList.append(text) 
    668                      
    669         if dlg.exec_() == QDialog.Accepted: 
     676        for tab in self.tabs.tabs: 
     677            dlg.tabs = self.tabs 
     678            dlg.tabOrderList.insertItem(self.tabs.tabLabel(tab)) 
     679            oldTabList.append(str(self.tabs.tabLabel(tab))) 
     680        dlg.removeTabs = [] 
     681 
     682        dlg.exec_loop() 
     683        if dlg.result() == QDialog.Accepted: 
    670684            h = int(str(dlg.heightEdit.text())); 
    671685            w = int(str(dlg.widthEdit.text())) 
    672                          
     686 
    673687            # save general settings 
    674688            if self.snapToGrid != dlg.snapToGridCB.isChecked(): 
     
    681695                self.settings["useLargeIcons"] = self.useLargeIcons 
    682696                self.updateUseLargeIcons() 
    683                      
     697 
    684698            # save exceptions settings 
    685699            #self.settings["catchException"] = dlg.catchExceptionCB.isChecked() 
     
    708722            self.settings["useContexts"] = dlg.useContextsCB.isChecked() 
    709723##            self.settings["autoLoadSchemasOnStart"] = dlg.autoLoadSchemasOnStartCB.isChecked() 
    710              
     724 
    711725            self.settings["widgetSelectedColor"] = (dlg.selectedWidgetIcon.color.red(), dlg.selectedWidgetIcon.color.green(), dlg.selectedWidgetIcon.color.blue()) 
    712726            self.settings["widgetActiveColor"]   = (dlg.activeWidgetIcon.color.red(), dlg.activeWidgetIcon.color.green(), dlg.activeWidgetIcon.color.blue()) 
     
    737751                    line.showSignalNames = show 
    738752                    line.updateTooltip() 
    739                  
     753 
    740754            #self.output.catchException(self.settings["catchException"]) 
    741755            #self.output.catchOutput(self.settings["catchOutput"]) 
     
    752766 
    753767            # save tab order settings 
    754             newTabList = [str(dlg.tabOrderList.item(i).text()) for i in range(dlg.tabOrderList.count())] 
     768            newTabList = [] 
     769            for i in range(dlg.tabOrderList.count()): 
     770                newTabList.append(str(dlg.tabOrderList.text(i))) 
    755771            if newTabList != oldTabList: 
    756772                self.settings["WidgetTabs"] = newTabList 
     
    760776    def setStatusBarEvent(self, text): 
    761777        if text == "" or text == None: 
    762             self.statusBar.showMessage("") 
     778            self.statusBar.message("") 
    763779            return 
    764780        elif text == "\n": return 
     
    768784        text = text.replace("<i>", ""); text = text.replace("</i>", "") 
    769785        text = text.replace("<br>", ""); text = text.replace("&nbsp", "") 
    770         self.statusBar.showMessage("Last event: " + str(text)) 
    771          
     786        self.statusBar.message(QString("Last event: " + str(text))) 
     787 
    772788    ####################### 
    773789    # SETTINGS 
    774790    ####################### 
    775791 
    776     # Loads settings from the widget's .ini file     
     792    # Loads settings from the widget's .ini file 
    777793    def loadSettings(self): 
    778         filename = os.path.join(self.canvasSettingsDir, "orngCanvas.ini") 
     794        filename = os.path.join(self.outputDir, "orngCanvas.ini") 
    779795        if os.path.exists(filename): 
    780796            file = open(filename, "rb") 
     
    791807        self.settings.setdefault("saveWidgetsPosition", 0) 
    792808##        self.settings.setdefault("autoLoadSchemasOnStart", 0) 
    793          
     809 
    794810        self.settings.setdefault("widgetSelectedColor", (0, 255, 0)) 
    795811        self.settings.setdefault("widgetActiveColor", (0,0,255)) 
     
    799815        #if not self.settings.has_key("catchOutput"): self.settings["catchOutput"] = 1 
    800816 
    801         self.settings.setdefault("saveSchemaDir", self.canvasSettingsDir) 
    802         self.settings.setdefault("saveApplicationDir", self.canvasSettingsDir) 
     817        if sys.platform == "darwin": 
     818            self.settings.setdefault("saveSchemaDir", user.home) 
     819            self.settings.setdefault("saveApplicationDir", user.home) 
     820        else: 
     821            self.settings.setdefault("saveSchemaDir", self.outputDir) 
     822            self.settings.setdefault("saveApplicationDir", self.outputDir) 
    803823        self.settings.setdefault("showSignalNames", 1) 
    804824        self.settings.setdefault("useContexts", 1) 
     
    806826        self.settings.setdefault("canvasWidth", 700) 
    807827        self.settings.setdefault("canvasHeight", 600) 
    808          
     828 
    809829        self.settings.setdefault("focusOnCatchException", 1) 
    810830        self.settings.setdefault("focusOnCatchOutput" , 0) 
     
    820840        self.settings.setdefault("ocError", 1) 
    821841        self.settings.setdefault("owError", 1) 
    822                  
     842 
    823843 
    824844    # Saves settings to this widget's .ini file 
    825845    def saveSettings(self): 
    826         filename = os.path.join(self.canvasSettingsDir, "orngCanvas.ini") 
     846        filename = os.path.join(self.outputDir, "orngCanvas.ini") 
    827847        file=open(filename, "wb") 
    828848        cPickle.dump(self.settings, file) 
     
    844864            ce.accept() 
    845865            QMainWindow.closeEvent(self, ce) 
    846         
     866 
     867 
     868    def keyPressEvent(self, e): 
     869        QMainWindow.keyPressEvent(self,e) 
     870        if e.state() & Qt.ControlButton != 0: 
     871            self.ctrlPressed = 1 
     872 
     873    def keyReleaseEvent(self, e): 
     874        QMainWindow.keyReleaseEvent(self,e) 
     875        self.ctrlPressed = 0 
     876 
    847877    def enableSave(self, enable): 
    848878        self.toolSave.setEnabled(enable) 
    849         self.menuSaveID.setEnabled(enable) 
    850         self.menuSaveAsID.setEnabled(enable) 
    851  
    852     def resizeEvent(self, e): 
    853         self.tabs.widget(self.tabs.currentIndex()).resizeEvent(e)       # show/hide left and right buttons 
    854         #self.tabs.widget(self.tabs.currentIndex()).repaint() 
    855  
    856          
     879        self.menuFile.setItemEnabled(self.menuSaveID, enable) 
     880        self.menuFile.setItemEnabled(self.menuSaveAsID, enable) 
    857881 
    858882class MyStatusBar(QStatusBar): 
    859     def __init__(self, parent): 
    860         QStatusBar.__init__(self, parent) 
     883    def __init__(self, parent, name = ""): 
     884        QStatusBar.__init__(self, parent, name) 
    861885        self.parentWidget = parent 
    862886 
     
    913937 
    914938app = QApplication(sys.argv) 
    915 dlg = OrangeCanvasDlg(None) 
     939dlg = OrangeCanvasDlg(None, "", Qt.WDestructiveClose) 
     940app.setMainWidget(dlg) 
    916941dlg.show() 
    917942for arg in sys.argv[1:]: 
    918943    if arg == "-reload": 
    919944        dlg.menuItemOpenLastSchema() 
    920 sys.exit(app.exec_()) 
     945app.exec_loop() 
  • orange/OrangeCanvas/orngCanvasItems.py

    r3792 r4014  
    33#    two main objects that are shown in the canvas; Line and Widget 
    44# 
    5 from PyQt4.QtCore import * 
    6 from PyQt4.QtGui import * 
     5from qt import * 
     6from qtcanvas import * 
    77import os, sys 
    88ERROR = 0 
    99WARNING = 1 
    1010 
    11 widgetWidth = 68 
    12 widgetHeight = 68 
    13  
    14  
    15 class TempCanvasLine(QGraphicsLineItem): 
    16     def __init__(self, canvasDlg, canvas): 
    17         QGraphicsLineItem.__init__(self, None, canvas) 
    18         self.setZValue(-10) 
     11class MyCanvasText(QCanvasText): 
     12    def __init__(self, canvas, text, x, y, flags=Qt.AlignLeft, bold=0, show=1): 
     13        apply(QCanvasText.__init__, (self, text, canvas)) 
     14        self.setTextFlags(flags) 
     15        self.move(x,y) 
     16        if bold: 
     17            font = self.font(); 
     18            font.setBold(1); 
     19            self.setFont(font) 
     20        if show: 
     21            self.show() 
     22 
     23class TempCanvasLine(QCanvasLine): 
     24    def __init__(self, canvasDlg, *args): 
     25        apply(QCanvasLine.__init__,(self,)+ args) 
     26        self.setZ(-10) 
    1927        self.canvasDlg = canvasDlg 
    2028 
    2129    def remove(self): 
    2230        self.hide() 
     31        self.setCanvas(None) 
    2332 
    2433    # draw the line 
     
    3544        pass 
    3645 
     46    def removeTooltip(self): 
     47        pass 
     48 
     49    def updateTooltip(self): 
     50        pass 
    3751 
    3852    # redraw the line 
    39 ##    def repaintLine(self, canvasView): 
    40 ##        p1 = self.startPoint() 
    41 ##        p2 = self.endPoint() 
    42 ##        #canvasView.repaintContents(QRect(min(p1.x(), p2.x())-5, min(p1.y(), p2.y())-5, abs(p1.x()-p2.x())+10,abs(p1.y()-p2.y())+10)) 
    43 ##        #canvasView.repaintContents(QRect(min(p1.x(), p2.x()), min(p1.y(), p2.y()), abs(p1.x()-p2.x()),abs(p1.y()-p2.y()))) 
     53    def repaintLine(self, canvasView): 
     54        p1 = self.startPoint() 
     55        p2 = self.endPoint() 
     56        #canvasView.repaintContents(QRect(min(p1.x(), p2.x())-5, min(p1.y(), p2.y())-5, abs(p1.x()-p2.x())+10,abs(p1.y()-p2.y())+10)) 
     57        canvasView.repaintContents(QRect(min(p1.x(), p2.x()), min(p1.y(), p2.y()), abs(p1.x()-p2.x()),abs(p1.y()-p2.y()))) 
     58 
     59    # we need this to separate line objects and widget objects 
     60    def rtti(self): 
     61        return 1000 
    4462 
    4563# ####################################### 
    4664# # CANVAS LINE 
    4765# ####################################### 
    48 class CanvasLine(QGraphicsLineItem): 
     66class CanvasLine(QCanvasLine): 
    4967    def __init__(self, signalManager, canvasDlg, view, outWidget, inWidget, canvas, *args): 
    50         QGraphicsLineItem.__init__(self, None, canvas) 
     68        apply(QCanvasLine.__init__,(self,canvas)+ args) 
    5169        self.signalManager = signalManager 
    5270        self.canvasDlg = canvasDlg 
     
    5472        self.inWidget = inWidget 
    5573        self.view = view 
    56         self.setZValue(-10) 
     74        self.setZ(-10) 
    5775        self.colors = [] 
    58         self.caption = "" 
    5976        outPoint = outWidget.getRightEdgePoint() 
    6077        inPoint = inWidget.getLeftEdgePoint() 
    61         #self.setLine(outPoint.x(), outPoint.y(), inPoint.x(), inPoint.y()) 
    62         #self.setPen(QPen(self.canvasDlg.lineColor, 5, Qt.SolidLine)) 
    63         self.updateLinePos() 
    64  
     78        self.setPoints(outPoint.x(), outPoint.y(), inPoint.x(), inPoint.y()) 
     79        self.setPen(QPen(self.canvasDlg.lineColor, 5, Qt.SolidLine)) 
     80        self.tooltipRects = [] 
     81 
     82        self.showSignalNames = canvasDlg.settings["showSignalNames"] 
     83        self.text = QCanvasText("", canvas) 
     84        self.text.setZ(-5) 
     85        self.text.show() 
     86        self.text.setTextFlags(Qt.AlignHCenter + Qt.AlignBottom) 
     87        self.text.setColor(QColor(100,100,100)) 
    6588 
    6689    def remove(self): 
    6790        self.hide() 
    68         self.setToolTip("") 
    69         #self.view.repaintContents(QRect(min(self.startPoint().x(), self.endPoint().x())-55, min(self.startPoint().y(), self.endPoint().y())-55, abs(self.startPoint().x()-self.endPoint().x())+100,abs(self.startPoint().y()-self.endPoint().y())+100)) 
     91        self.text.hide() 
     92        self.setCanvas(None) 
     93        self.text.setCanvas(None) 
     94        self.removeTooltip() 
     95        self.view.repaintContents(QRect(min(self.startPoint().x(), self.endPoint().x())-55, min(self.startPoint().y(), self.endPoint().y())-55, abs(self.startPoint().x()-self.endPoint().x())+100,abs(self.startPoint().y()-self.endPoint().y())+100)) 
    7096 
    7197    def getEnabled(self): 
     
    85111        return signals 
    86112 
    87     def paint(self, painter, option, widget = None): 
    88         painter.resetMatrix() 
    89         x1, x2 = self.line().x1(), self.line().x2() 
    90         y1, y2 = self.line().y1(), self.line().y2() 
     113    def drawShape(self, painter): 
     114        (startX, startY) = (self.startPoint().x(), self.startPoint().y()) 
     115        (endX, endY)  = (self.endPoint().x(), self.endPoint().y()) 
    91116 
    92117        if self.getEnabled(): lineStyle = Qt.SolidLine 
     
    94119 
    95120        painter.setPen(QPen(self.canvasDlg.lineColor, 5 , lineStyle)) 
    96         painter.drawLine(x1, y1, x2, y2) 
    97  
    98         if self.canvasDlg.settings["showSignalNames"]: 
    99             painter.setPen(QColor(100, 100, 100)) 
    100             x = (x1 + x2 - 200)/2.0 
    101             y = (y1 + y2 - 30)/2.0 
    102             painter.drawText(x, y, 200, 50, Qt.AlignTop | Qt.AlignHCenter, self.caption) 
     121        painter.drawLine(QPoint(startX, startY), QPoint(endX, endY)) 
    103122 
    104123    # set the line positions based on the position of input and output widgets 
     
    108127        x2 = self.inWidget.x() + 2 
    109128        y2 = self.inWidget.y() + 26 
    110         self.setLine(x1, y1, x2, y2) 
     129        self.setPoints(x1, y1, x2, y2) 
     130        self.text.move((self.startPoint().x() + self.endPoint().x())/2.0, (self.startPoint().y() + self.endPoint().y()+10)/2.0) 
    111131        self.updateTooltip() 
    112132 
     133    # redraw the line 
     134    def repaintLine(self, canvasView): 
     135        p1 = self.startPoint() 
     136        p2 = self.endPoint() 
     137        canvasView.repaintContents(QRect(min(p1.x(), p2.x())-55, min(p1.y(), p2.y())-55, abs(p1.x()-p2.x())+100,abs(p1.y()-p2.y())+100)) 
     138 
     139    def removeTooltip(self): 
     140        for rect in self.tooltipRects: 
     141            QToolTip.remove(self.view, rect) 
     142        self.tooltipRects = [] 
     143 
    113144    def updateTooltip(self): 
    114         string = "<nobr><b>" + self.outWidget.caption + "</b> --> <b>" + self.inWidget.caption + "</b></nobr><hr>Signals:<br>" 
    115         for (outSignal, inSignal) in self.getSignals(): 
    116             string += "<nobr> &nbsp; &nbsp; - " + outSignal + " --> " + inSignal + "</nobr><br>" 
     145        self.removeTooltip() 
     146        p1 = self.startPoint() 
     147        p2 = self.endPoint() 
     148        signals = self.getSignals() 
     149 
     150        string = "<nobr><b>" + self.outWidget.caption + "</b> --> <b>" + self.inWidget.caption + "</b></nobr><br><hr>Signals:<br>" 
     151        for (outSignal, inSignal) in signals: 
     152            string += "<nobr> &nbsp &nbsp - " + outSignal + " --> " + inSignal + "</nobr><br>" 
    117153        string = string[:-4] 
    118         self.setToolTip(string) 
     154 
     155        xDiff = p2.x() - p1.x() 
     156        yDiff = p2.y() - p1.y() 
     157        count = max(xDiff, yDiff) / 20 
     158        for i in range(count): 
     159            x1 = p1.x() + (i/float(count))*xDiff - 5 
     160            y1 = p1.y() + (i/float(count))*yDiff - 5 
     161            x2 = p1.x() + ((i+1)/float(count))*xDiff + 5 
     162            y2 = p1.y() + ((i+1)/float(count))*yDiff + 5 
     163 
     164            rect = QRect(min(x1, x2), min(y1,y2), abs(x1-x2), abs(y1-y2)) 
     165            self.tooltipRects.append(rect) 
     166            QToolTip.add(self.view, rect, string) 
    119167 
    120168        # print the text with the signals 
    121         self.caption = "\n".join([outSignal for (outSignal, inSignal) in self.getSignals()]) 
    122         l = self.line() 
    123         self.update(min(l.x1(), l.x2())-40, min(l.y1(),l.y2())-40, abs(l.x1()-l.x2())+80, abs(l.y1()-l.y2())+80) 
    124  
    125  
    126 class CanvasWidgetState(QGraphicsRectItem): 
     169        caption = "" 
     170        if self.showSignalNames: 
     171            for (outSignal, inSignal) in signals: 
     172                caption += outSignal + "\n" 
     173        self.text.hide() 
     174        self.text.setText(caption) 
     175        self.text.show() 
     176        self.text.move((self.startPoint().x() + self.endPoint().x())/2.0, (self.startPoint().y() + self.endPoint().y()+25)/2.0) 
     177 
     178    # we need this to separate line objects and widget objects 
     179    def rtti(self): 
     180        return 1002 
     181 
     182 
     183class CanvasWidgetState(QCanvasRectangle): 
    127184    def __init__(self, parent, canvas, view, widgetIcons): 
    128         QGraphicsRectItem.__init__(self, None, canvas) 
     185        QCanvasRectangle.__init__(self, canvas) 
    129186        self.widgetIcons = widgetIcons 
    130187        self.view = view 
    131188        self.parent = parent 
     189        self.setSize(100, 30) 
    132190 
    133191        self.infoTexts = [] 
     
    188246 
    189247 
     248 
    190249# ####################################### 
    191250# # CANVAS WIDGET 
    192251# ####################################### 
    193 class CanvasWidget(QGraphicsRectItem): 
     252class CanvasWidget(QCanvasRectangle): 
    194253    def __init__(self, signalManager, canvas, view, widget, defaultPic, canvasDlg): 
    195         # import widget class and create a class instance 
    196         exec(compile("import " + widget.getFileName(), ".", "single")) 
    197         self.instance = eval(compile(widget.getFileName() + "." + widget.getFileName() + "(signalManager = signalManager)", ".", "eval")) 
    198         self.instance.setProgressBarHandler(view.progressBarHandler)   # set progress bar event handler 
    199         self.instance.setProcessingHandler(view.processingHandler) 
    200         self.instance.setWidgetStateHandler(self.refreshWidgetState) 
    201         self.instance._owInfo = canvasDlg.settings["owInfo"] 
    202         self.instance._owWarning = canvasDlg.settings["owWarning"] 
    203         self.instance._owError = canvasDlg.settings["owError"] 
    204         self.instance._owShowStatus = canvasDlg.settings["owShow"] 
    205         #self.instance.updateStatusBarState() 
    206         self.instance._useContexts = canvasDlg.settings["useContexts"] 
    207  
    208         QGraphicsRectItem.__init__(self, None, canvas) 
     254        apply(QCanvasRectangle.__init__, (self,canvas)) 
    209255        self.signalManager = signalManager 
    210256        self.widget = widget 
     
    218264            self.imageEdge = QPixmap(os.path.join(canvasDlg.picsDir,"WidgetEdge.png")) 
    219265 
    220         self.setRect(0,0, widgetWidth, widgetHeight) 
     266        self.setSize(68, 68) 
    221267        self.selected = False 
    222268        self.invalidPosition = False    # is the widget positioned over other widgets 
     
    224270        self.outLines = []              # list of connected lines on output 
    225271        self.caption = widget.name 
    226         self.progressBarShown = 0 
    227272        self.xPos = 0 
    228273        self.yPos = 0 
     
    236281        self.widgetStateRect.show() 
    237282 
     283        # import widget class and create a class instance 
     284        code = compile("import " + widget.getFileName(), ".", "single") 
     285        exec(code) 
     286        code = compile(widget.getFileName() + "." + widget.getFileName() + "(signalManager = signalManager)", ".", "eval") 
     287        self.instance = eval(code) 
     288        self.instance.setProgressBarHandler(self.view.progressBarHandler)   # set progress bar event handler 
     289        self.instance.setProcessingHandler(self.view.processingHandler) 
     290        self.instance.setWidgetStateHandler(self.refreshWidgetState) 
     291        self.instance._owInfo = self.canvasDlg.settings["owInfo"] 
     292        self.instance._owWarning = self.canvasDlg.settings["owWarning"] 
     293        self.instance._owError = self.canvasDlg.settings["owError"] 
     294        self.instance._owShowStatus = self.canvasDlg.settings["owShow"] 
     295        #self.instance.updateStatusBarState() 
     296        self.instance._useContexts = self.canvasDlg.settings["useContexts"] 
     297 
    238298        # do we want to restore last position and size of the widget 
    239299        if self.canvasDlg.settings["saveWidgetsPosition"]: 
     
    250310            self.instance.setWidgetIcon(defaultPic) 
    251311 
     312        self.text = QCanvasText(self.caption, canvas) 
     313        self.text.show() 
     314        self.text.setTextFlags(Qt.AlignCenter) 
     315        self.updateTextCoords() 
     316 
     317        # create and hide progressbar items 
     318        self.progressBarRect = QCanvasRectangle(self.xPos+8, self.yPos - 20, self.width()-16, 16, canvas) 
     319        self.progressRect = QCanvasRectangle(self.xPos+8, self.yPos - 20, 0, 16, canvas) 
     320        self.progressRect.setBrush(QBrush(QColor(0,128,255))) 
     321        self.progressText = QCanvasText(canvas) 
     322        self.progressText.move(self.xPos + self.width()/2, self.yPos - 20 + 7) 
     323        self.progressText.setTextFlags(Qt.AlignCenter) 
     324        self.progressBarRect.setZ(-100) 
     325        self.progressRect.setZ(-50) 
     326        self.progressText.setZ(-10) 
     327 
     328        self.updateSettings() 
     329 
    252330    # read the settings if we want to show icons for info, warning, error 
    253331    def updateSettings(self): 
     
    261339        self.widgetStateRect.updateState(self.instance.widgetState) 
    262340 
     341 
    263342    # get the list of connected signal names 
    264343    def getInConnectedSignalNames(self): 
     
    278357 
    279358    def remove(self): 
     359        self.progressBarRect.hide() 
     360        self.progressRect.hide() 
     361        self.progressText.hide() 
    280362        self.widgetStateRect.hide() 
     363        self.progressBarRect.setCanvas(None) 
     364        self.progressRect.setCanvas(None) 
     365        self.progressText.setCanvas(None) 
     366        self.widgetStateRect.setCanvas(None) 
     367 
    281368        self.hide() 
     369        self.setCanvas(None)    # hide the widget 
    282370 
    283371        # save settings 
     
    285373            try:    self.instance.saveSettings() 
    286374            except: print "Unable to successfully save settings for %s widget" % (self.instance.title) 
    287             self.instance.close() 
     375            self.instance.hide() 
    288376            del self.instance 
     377        self.removeTooltip() 
     378        self.text.hide() 
    289379 
    290380    def savePosition(self): 
     
    295385        self.setCoords(self.oldXPos, self.oldYPos) 
    296386 
     387    def updateTextCoords(self): 
     388        self.text.move(self.xPos + 34, self.yPos + 60) 
     389 
    297390    def updateText(self, text): 
    298391        self.caption = str(text) 
     392        self.text.setText(text) 
    299393 
    300394    def updateLinePosition(self): 
     
    302396        for line in self.outLines: line.updateLinePos() 
    303397 
     398    def updateProgressBarPosition(self): 
     399        self.progressBarRect.move(self.xPos+8, self.yPos - 20) 
     400        self.progressRect.move(self.xPos+8, self.yPos - 20) 
     401        self.progressText.move(self.xPos + self.width()/2, self.yPos - 20 + 7) 
     402 
    304403    def setSelected(self, selected): 
    305404        self.selected = selected 
    306         #self.repaintWidget() 
     405        self.repaintWidget() 
     406 
    307407 
    308408    # set coordinates of the widget 
     
    310410        if x > 0 and x < self.canvas.width():  self.xPos = x 
    311411        if y > 0 and y < self.canvas.height() - 60: self.yPos = y 
    312         self.setPos(self.xPos, self.yPos) 
     412        self.move(self.xPos, self.yPos) 
     413        self.updateTextCoords() 
    313414        self.updateLinePosition() 
     415        self.updateProgressBarPosition() 
    314416 
    315417    def move(self, x, y): 
    316         QGraphicsRectItem.setPos(self, x, y) 
    317         self.widgetStateRect.updatePosition() 
     418        QCanvasRectangle.move(self, x, y) 
     419        self.widgetStateRect.updateWidgetState() 
     420 
    318421 
    319422    # move existing coorinates by dx, dy 
     
    321424        if self.xPos + dx > 0 and self.xPos + dx < self.canvas.width(): self.xPos = self.xPos + dx 
    322425        if self.yPos + dy > 0 and self.yPos + dy < self.canvas.height() - 60: self.yPos = self.yPos + dy 
    323         self.setPos(self.xPos, self.yPos) 
     426        self.move(self.xPos, self.yPos) 
     427        self.updateTextCoords() 
    324428        self.updateLinePosition() 
    325429 
     
    334438        if self.widget.getInputs() == []: return False 
    335439 
    336         LBox = QRectF(self.x(), self.y()+18,8,16) 
    337         if isinstance(pos, QPointF) and LBox.contains(pos): return True 
    338         elif isinstance(pos, QRectF) and LBox.intersects(pos): return True 
     440        LBox = QRect(self.x(), self.y()+18,8,16) 
     441        if isinstance(pos, QPoint) and LBox.contains(pos): return True 
     442        elif isinstance(pos, QRect) and LBox.intersects(pos): return True 
    339443        else: return False 
    340444 
     
    343447        if self.widget.getOutputs() == []: return False 
    344448 
    345         RBox = QRectF(self.x() + 60, self.y()+18,8,16) 
    346         if isinstance(pos, QPointF) and RBox.contains(pos): return True 
    347         elif isinstance(pos, QRectF) and RBox.intersects(pos): return True 
     449        RBox = QRect(self.x() + 60, self.y()+18,8,16) 
     450        if isinstance(pos, QPoint) and RBox.contains(pos): return True 
     451        elif isinstance(pos, QRect) and RBox.intersects(pos): return True 
    348452        else: return False 
    349453 
     
    365469 
    366470    # draw the widget 
    367     def paint(self, painter, option, widget = None): 
    368         painter.resetMatrix() 
     471    def drawShape(self, painter): 
    369472        if self.isProcessing: 
    370473            painter.setPen(QPen(self.canvasDlg.widgetActiveColor)) 
     
    373476            painter.drawRect(self.x()+7, self.y(), 54, 54) 
    374477        elif self.selected: 
    375             if self.invalidPosition: color = Qt.red 
     478            if self.invalidPosition: color = self.red 
    376479            else:                    color = self.canvasDlg.widgetSelectedColor 
    377480            painter.setPen(QPen(color)) 
    378481            painter.setBrush(QBrush(color)) 
     482            #painter.drawRect(self.x()+8+1, self.y()+1, 50, 50) 
     483            #painter.drawRect(self.x()+8, self.y(), 52, 52) 
    379484            painter.drawRect(self.x()+7, self.y(), 54, 54) 
     485 
    380486 
    381487        painter.drawPixmap(self.x()+2+8, self.y()+3, self.image) 
     
    383489        if self.imageEdge != None: 
    384490            if self.widget.getInputs() != []:    painter.drawPixmap(self.x(), self.y() + 18, self.imageEdge) 
    385             if self.widget.getOutputs() != []:   painter.drawPixmap(self.x()+widgetWidth-8, self.y() + 18, self.imageEdge) 
     491            if self.widget.getOutputs() != []:   painter.drawPixmap(self.x()+60, self.y() + 18, self.imageEdge) 
    386492        else: 
    387493            painter.setBrush(QBrush(self.blue)) 
    388494            if self.widget.getInputs() != []:    painter.drawRect(self.x(), self.y() + 18, 8, 16) 
    389             if self.widget.getOutputs() != []:   painter.drawRect(self.x()+widgetWidth-8, self.y() + 18, 8, 16) 
    390  
    391         # draw the label 
    392         painter.setPen(QPen(Qt.black)) 
    393         midX, midY = self.x()+widgetWidth/2., self.y()+self.image.height()+7 
    394         painter.drawText(midX-200/2, midY, 200, 20, Qt.AlignTop | Qt.AlignHCenter, self.caption) 
    395  
    396         if self.progressBarShown: 
    397             rect = QRectF(self.x()+8, self.y()-20, widgetWidth-16, 16) 
    398             painter.setBrush(QBrush(QColor(0,0,0))) 
    399             painter.drawRect(rect) 
    400             painter.setBrush(QBrush(QColor(0,128,255))) 
    401  
    402             painter.drawRect(QRectF(self.x()+8, self.y()-20, (widgetWidth-16)*self.progressBarValue/100., 16)) 
    403             painter.drawText(rect, Qt.AlignCenter, "%d %%" % (self.progressBarValue)) 
    404  
     495            if self.widget.getOutputs() != []:   painter.drawRect(self.x() + 60, self.y() + 18, 8, 16) 
     496 
     497    """ 
     498    def printShape(self, painter): 
     499        painter.setPen(QPen(self.black)) 
     500        painter.drawRect(self.x()+8, self.y(), 52, 52) 
     501 
     502        painter.setBrush(QBrush(self.black)) 
     503 
     504        if self.imageEdge != None: 
     505            if self.widget.getInputs() != []:    painter.drawPixmap(self.x(), self.y() + 18, self.imageEdge) 
     506            if self.widget.getOutputs() != []:   painter.drawPixmap(self.x()+60, self.y() + 18, self.imageEdge) 
     507        else: 
     508            painter.setBrush(QBrush(self.blue)) 
     509            if self.widget.getInputs() != []:    painter.drawRect(self.x(), self.y() + 18, 8, 16) 
     510            if self.widget.getOutputs() != []:   painter.drawRect(self.x() + 60, self.y() + 18, 8, 16) 
     511 
     512        #painter.setBrush(QBrush(self.NoBrush)) 
     513        #rect = painter.boundingRect(0,0,200,20,0,self.caption) 
     514        #painter.drawText(self.x()+34-rect.width()/2, self.y()+52+2, rect.width(), rect.height(), 0, self.caption) 
     515        #painter.drawPixmap(self.x()+2+8, self.y()+2, self.image) 
     516    """ 
    405517 
    406518    def addOutLine(self, line): 
     
    433545            #line.repaintLine(self.view) 
    434546 
    435 ##    def repaintWidget(self): 
    436 ##        (x,y,w,h) = ( self.x(), self.y(), self.rect().width(), self.rect().height() ) 
    437 ##        self.view.repaintContents(QRect(x-20,y-20,w+40,h+40)) 
    438  
    439 ##    def repaintAllLines(self): 
    440 ##        for line in self.inLines: 
    441 ##            line.repaintLine(self.view) 
    442 ##        for line in self.outLines: 
    443 ##            line.repaintLine(self.view) 
     547    def repaintWidget(self): 
     548        (x,y,w,h) = ( self.x(), self.y(), self.width(), self.height() ) 
     549        self.view.repaintContents(QRect(x-20,y-20,w+40,h+40)) 
     550 
     551    def repaintAllLines(self): 
     552        for line in self.inLines: 
     553            line.repaintLine(self.view) 
     554        for line in self.outLines: 
     555            line.repaintLine(self.view) 
    444556 
    445557    def updateTooltip(self): 
    446         string = "<nobr><b>" + self.caption + "</b></nobr><hr>Inputs:<br>" 
    447  
    448         if self.widget.getInputs() == []: string += "&nbsp; &nbsp; None<br>" 
     558        self.removeTooltip() 
     559        string = "<nobr><b>" + self.caption + "</b></nobr><br><hr>Inputs:<br>" 
     560 
     561        if self.widget.getInputs() == []: string += "&nbsp &nbsp None<br>" 
    449562        else: 
    450563            for signal in self.widget.getInputs(): 
    451564                widgets = self.signalManager.getLinkWidgetsIn(self.instance, signal.name) 
    452565                if len(widgets) > 0: 
    453                     string += "<nobr> &nbsp; &nbsp; - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (from " 
     566                    string += "<nobr> &nbsp &nbsp - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (from " 
    454567                    for i in range(len(widgets)-1): 
    455568                        string += self.view.doc.getWidgetCaption(widgets[i]) + ", " 
    456569                    string += self.view.doc.getWidgetCaption(widgets[-1]) + ")</nobr><br>" 
    457570                else: 
    458                     string += "<nobr> &nbsp; &nbsp; - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
    459  
    460         string = string[:-4] 
     571                    string += "<nobr> &nbsp &nbsp - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
     572 
    461573        string += "<hr>Outputs:<br>" 
    462         if self.widget.getOutputs() == []: string += "&nbsp; &nbsp; None<br>" 
     574        if self.widget.getOutputs() == []: string += "&nbsp &nbsp None<br>" 
    463575        else: 
    464576            for signal in self.widget.getOutputs(): 
    465577                widgets = self.signalManager.getLinkWidgetsOut(self.instance, signal.name) 
    466578                if len(widgets) > 0: 
    467                     string += "<nobr> &nbsp; &nbsp; - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (to " 
     579                    string += "<nobr> &nbsp &nbsp - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (to " 
    468580                    for i in range(len(widgets)-1): 
    469581                        string += self.view.doc.getWidgetCaption(widgets[i]) + ", " 
    470582                    string += self.view.doc.getWidgetCaption(widgets[-1]) + ")</nobr><br>" 
    471583                else: 
    472                     string += "<nobr> &nbsp; &nbsp; - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
     584                    string += "<nobr> &nbsp &nbsp - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
    473585        string = string[:-4] 
    474         self.setToolTip(string) 
     586        self.lastRect = QRect(self.x()-self.viewXPos, self.y()-self.viewYPos, self.width(), self.height()) 
     587        QToolTip.add(self.view, self.lastRect, string) 
     588 
     589 
     590    def setViewPos(self, x, y): 
     591        self.viewXPos = x 
     592        self.viewYPos = y 
     593 
     594    def removeTooltip(self): 
     595        #rect = QRect(self.x()-self.viewXPos, self.y()-self.viewYPos, self.width(), self.height()) 
     596        #QToolTip.remove(self.view, self.rect()) 
     597        QToolTip.remove(self.view, self.lastRect) 
     598 
    475599 
    476600    def showProgressBar(self): 
    477         self.progressBarShown = 1 
    478         self.progressBarValue = 0 
     601        self.progressRect.setSize(0, self.progressRect.height()) 
     602        self.progressText.setText("0 %") 
     603        self.progressBarRect.show() 
     604        self.progressRect.show() 
     605        self.progressText.show() 
    479606        self.canvas.update() 
    480607 
    481608    def hideProgressBar(self): 
    482         self.progressBarShown = 0 
     609        self.progressBarRect.hide() 
     610        self.progressRect.hide() 
     611        self.progressText.hide() 
    483612        self.canvas.update() 
    484613 
    485614    def setProgressBarValue(self, value): 
    486         self.progressBarValue = value 
     615        totalSize = self.progressBarRect.width() 
     616        self.progressRect.setSize(totalSize*(float(value)/100.0), self.progressRect.height()) 
     617        self.progressText.setText(str(int(value)) + " %") 
    487618        self.canvas.update() 
    488619 
     
    490621        self.isProcessing = value 
    491622        self.canvas.update() 
    492 ##        self.repaintWidget() 
    493  
     623        self.repaintWidget() 
     624 
     625    def rtti(self): 
     626        return 1001 
     627 
  • orange/OrangeCanvas/orngDlgs.py

    r3792 r4014  
    33#    signal dialog, canvas options dialog 
    44 
    5 from PyQt4.QtCore import * 
    6 from PyQt4.QtGui import * 
    7 #from orngCanvasItems import * 
    8 import orngGui 
     5from qt import * 
     6from qtcanvas import * 
     7from copy import copy 
     8from string import strip 
     9import sys 
     10from orngCanvasItems import * 
     11from qttable import * 
     12 
     13def indentedCheckBox(text, parent): 
     14    b = QHBox(parent) 
     15    sep = QWidget(b) 
     16    sep.setFixedSize(10, 10) 
     17    return QCheckBox(text, b) 
     18 
     19 
     20class QCanvasIcon(QCanvasRectangle): 
     21    def __init__(self, canvas, fileName): 
     22        QCanvasRectangle.__init__(self,canvas) 
     23        self.pixmap = QPixmap(fileName) 
     24        self.setZ(100) 
     25 
     26    def setCenterPos(self, x, y): 
     27        self.x = x - self.pixmap.width()/2.0 
     28        self.y = y - self.pixmap.height()/2.0 
     29 
     30    def drawShape(self, painter): 
     31        if self.pixmap: 
     32            painter.drawPixmap(self.x, self.y, self.pixmap) 
    933 
    1034# this class is needed by signalDialog to show widgets and lines 
    11 class SignalCanvasView(QGraphicsView): 
     35class SignalCanvasView(QCanvasView): 
    1236    def __init__(self, dlg, *args): 
    13         apply(QGraphicsView.__init__,(self,) + args) 
     37        apply(QCanvasView.__init__,(self,) + args) 
    1438        self.dlg = dlg 
    1539        self.bMouseDown = False 
     
    2448        self.inBoxes = [] 
    2549        self.texts = [] 
    26         self.ensureVisible(0,0,1,1) 
    27         self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) 
    28         self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) 
    29         self.setAlignment(Qt.AlignLeft | Qt.AlignTop) 
    30         self.setRenderHint(QPainter.Antialiasing) 
     50 
     51        #self.connect(self, SIGNAL("contentsMoving(int,int)"), self.contentsMoving) 
    3152 
    3253    def addSignalList(self, outName, inName, outputs, inputs, outIconName, inIconName): 
    33         for item in self.scene().items(): item.hide() 
    34         self.lines = [] 
    35         self.outBoxes = [] 
    36         self.inBoxes = [] 
    37         self.texts = [] 
     54        items = self.canvas().allItems() 
     55        for item in items: item.hide() 
     56        self.lines = []; self.outBoxes = []; self.inBoxes = []; self.texts = [] 
    3857        xSpaceBetweenWidgets = 100  # space between widgets 
    3958        xWidgetOff = 10     # offset for widget position 
     
    6584        # show boxes 
    6685        brush = QBrush(QColor(60,150,255)) 
    67         self.outWidget = QGraphicsRectItem(xWidgetOff, yWidgetOffTop, width, height, None, self.dlg.canvas) 
     86        self.outWidget = QCanvasRectangle(xWidgetOff, yWidgetOffTop, width, height, self.dlg.canvas) 
    6887        self.outWidget.setBrush(brush) 
    69         self.outWidget.setZValue(-100) 
    70 ##        self.outWidget.show() 
    71  
    72         self.inWidget = QGraphicsRectItem(xWidgetOff + width + xSpaceBetweenWidgets, yWidgetOffTop, width, height, None, self.dlg.canvas) 
     88        self.outWidget.setZ(-100) 
     89        self.outWidget.show() 
     90 
     91        self.inWidget = QCanvasRectangle(xWidgetOff + width + xSpaceBetweenWidgets, yWidgetOffTop, width, height, self.dlg.canvas) 
    7392        self.inWidget.setBrush(brush) 
    74         self.inWidget.setZValue(-100) 
    75 ##        self.inWidget.show() 
     93        self.inWidget.setZ(-100) 
     94        self.inWidget.show() 
    7695 
    7796        # if icons -> show them 
    7897        if outIconName: 
    79             self.outWidgetIcon = QGraphicsPixmapItem(QPixmap(outIconName), None, self.dlg.canvas) 
    80             self.outWidgetIcon.setPos(xWidgetOff + xIconOff, yWidgetOffTop + height/2.0 - self.outWidgetIcon.pixmap().width()/2.0) 
    81 ##            self.outWidgetIcon.show() 
     98            self.outWidgetIcon = QCanvasIcon(self.dlg.canvas, outIconName) 
     99            self.outWidgetIcon.setCenterPos(xWidgetOff + xIconOff + self.outWidgetIcon.pixmap.width()/2.0, yWidgetOffTop + height/2.0) 
     100            self.outWidgetIcon.show() 
    82101        if inIconName : 
    83             self.inWidgetIcon = QGraphicsPixmapItem(QPixmap(inIconName), None, self.dlg.canvas) 
    84             self.inWidgetIcon.setPos(xWidgetOff + xSpaceBetweenWidgets + 2*width - xIconOff - self.inWidgetIcon.pixmap().width(), yWidgetOffTop + height/2.0 - self.inWidgetIcon.pixmap().width()/2.0) 
     102            self.inWidgetIcon = QCanvasIcon(self.dlg.canvas, inIconName) 
     103            self.inWidgetIcon.setCenterPos(xWidgetOff + xSpaceBetweenWidgets + 2*width - xIconOff - self.inWidgetIcon.pixmap.width()/2.0, yWidgetOffTop + height/2.0) 
     104            self.inWidgetIcon.show() 
    85105 
    86106        # show signal boxes and text labels 
     
    89109        for i in range(len(outputs)): 
    90110            y = yWidgetOffTop + ((i+1)*signalSpace)/float(len(outputs)+1) 
    91             box = QGraphicsRectItem(xWidgetOff + width, y - ySignalSize/2.0, xSignalSize, ySignalSize, None, self.dlg.canvas) 
     111            box = QCanvasRectangle(xWidgetOff + width, y - ySignalSize/2.0, xSignalSize, ySignalSize, self.dlg.canvas) 
    92112            box.setBrush(QBrush(QColor(0,0,255))) 
    93             box.setZValue(200) 
     113            box.show() 
    94114            self.outBoxes.append((outputs[i].name, box)) 
    95115 
    96             self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, outputs[i].name, xWidgetOff + width - 5, y - 7, Qt.AlignRight + Qt.AlignVCenter, bold =1, show=1)) 
    97             self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, outputs[i].type, xWidgetOff + width - 5, y + 7, Qt.AlignRight + Qt.AlignVCenter, bold =0, show=1)) 
     116            self.texts.append(MyCanvasText(self.dlg.canvas, outputs[i].name, xWidgetOff + width - 5, y - 7, Qt.AlignRight + Qt.AlignVCenter, bold =1, show=1)) 
     117            self.texts.append(MyCanvasText(self.dlg.canvas, outputs[i].type, xWidgetOff + width - 5, y + 7, Qt.AlignRight + Qt.AlignVCenter, bold =0, show=1)) 
    98118 
    99119        for i in range(len(inputs)): 
    100120            y = yWidgetOffTop + ((i+1)*signalSpace)/float(len(inputs)+1) 
    101             box = QGraphicsRectItem(xWidgetOff + width + xSpaceBetweenWidgets - xSignalSize, y - ySignalSize/2.0, xSignalSize, ySignalSize, None, self.dlg.canvas) 
     121            box = QCanvasRectangle(xWidgetOff + width + xSpaceBetweenWidgets - xSignalSize, y - ySignalSize/2.0, xSignalSize, ySignalSize, self.dlg.canvas) 
    102122            box.setBrush(QBrush(QColor(0,0,255))) 
    103             box.setZValue(200) 
     123            box.show() 
    104124            self.inBoxes.append((inputs[i].name, box)) 
    105125 
    106             self.texts.append(orngGui.MyCanvasText(self.dlg.canvas, inputs[i].name, xWidgetOff + width + xSpaceBetweenWidgets + 5, y - 7, Qt.AlignLeft + Qt.AlignVCenter, bold =1, show=1)) 
    107             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)) 
    108  
    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)) 
     126            self.texts.append(MyCanvasText(self.dlg.canvas, inputs[i].name, xWidgetOff + width + xSpaceBetweenWidgets + 5, y - 7, Qt.AlignLeft + Qt.AlignVCenter, bold =1, show=1)) 
     127            self.texts.append(MyCanvasText(self.dlg.canvas, inputs[i].type, xWidgetOff + width + xSpaceBetweenWidgets + 5, y + 7, Qt.AlignLeft + Qt.AlignVCenter, bold =0, show=1)) 
     128 
     129        self.texts.append(MyCanvasText(self.dlg.canvas, outName, xWidgetOff + width/2.0, yWidgetOffTop + height + 5, Qt.AlignHCenter + Qt.AlignTop, bold =1, show=1)) 
     130        self.texts.append(MyCanvasText(self.dlg.canvas, inName, xWidgetOff + width* 1.5 + xSpaceBetweenWidgets, yWidgetOffTop + height + 5, Qt.AlignHCenter + Qt.AlignTop, bold =1, show=1)) 
    111131 
    112132        return (2*xWidgetOff + 2*width + xSpaceBetweenWidgets, yWidgetOffTop + height + yWidgetOffBottom) 
    113133 
    114134    def getTextWidth(self, text, bold = 0): 
    115         temp = QGraphicsSimpleTextItem(text, None, self.dlg.canvas) 
     135        temp = QCanvasText(text, self.dlg.canvas) 
    116136        if bold: 
    117137            font = temp.font() 
    118138            font.setBold(1) 
    119139            temp.setFont(font) 
    120         temp.hide() 
    121         return temp.boundingRect().width() 
     140        rect = temp.boundingRect() 
     141        return rect.width() 
    122142 
    123143    # ################################################################### 
    124144    # mouse button was pressed 
    125     def mousePressEvent(self, ev): 
     145    def contentsMousePressEvent(self, ev): 
    126146        self.bMouseDown = 1 
    127         point = self.mapToScene(ev.pos()) 
    128         activeItem = self.scene().itemAt(QPointF(ev.pos())) 
    129         if type(activeItem) == QGraphicsRectItem and activeItem not in [self.outWidget, self.inWidget]: 
     147        activeItems = self.canvas().collisions(QRect(ev.pos().x()-1, ev.pos().y()-1,2,2)) 
     148 
     149        if activeItems == []: return 
     150        box = self.findItem(activeItems, QCanvasRectangle) 
     151        if box and box != self.outWidget and box != self.inWidget: 
    130152            self.bLineDragging = 1 
    131             self.tempLine = QGraphicsLineItem(None, self.dlg.canvas) 
    132             self.tempLine.setLine(point.x(), point.y(), point.x(), point.y()) 
     153            self.tempLine = QCanvasLine(self.dlg.canvas) 
     154            self.tempLine.setPoints(ev.pos().x(), ev.pos().y(), ev.pos().x(), ev.pos().y()) 
    133155            self.tempLine.setPen(QPen(QColor(0,255,0), 1)) 
    134             self.tempLine.setZValue(-300) 
     156            self.tempLine.setZ(-120) 
     157            self.tempLine.show() 
    135158            return 
    136         elif type(activeItem) == QGraphicsLineItem: 
    137             for (line, outName, inName, outBox, inBox) in self.lines: 
    138                 if line == activeItem: 
     159 
     160        line = self.findItem(activeItems, QCanvasLine) 
     161        if line: 
     162            for (Line, outName, inName, outBox, inBox) in self.lines: 
     163                if Line == line: 
    139164                    self.dlg.removeLink(outName, inName) 
    140165                    return 
     
    142167    # ################################################################### 
    143168    # mouse button was released ######################################### 
    144     def mouseMoveEvent(self, ev): 
     169    def contentsMouseMoveEvent(self, ev): 
    145170        if self.bLineDragging: 
    146             curr = self.mapToScene(ev.pos()) 
    147             start = self.tempLine.line().p1() 
    148             self.tempLine.setLine(start.x(), start.y(), curr.x(), curr.y()) 
    149             self.scene().update() 
     171            start = self.tempLine.startPoint() 
     172            self.tempLine.setPoints(start.x(), start.y(), ev.pos().x(), ev.pos().y()) 
     173            self.canvas().update() 
    150174 
    151175    # ################################################################### 
    152176    # mouse button was released ######################################### 
    153     def mouseReleaseEvent(self, ev): 
     177    def contentsMouseReleaseEvent(self, ev): 
    154178        if self.bLineDragging: 
    155179            self.bLineDragging = 0 
    156             activeItem = self.scene().itemAt(QPointF(ev.pos())) 
    157  
    158             if type(activeItem) == QGraphicsRectItem: 
    159                 activeItem2 = self.scene().itemAt(self.tempLine.line().p1()) 
    160                 if activeItem.x() < activeItem2.x(): outBox = activeItem; inBox = activeItem2 
    161                 else:                                outBox = activeItem2; inBox = activeItem 
     180            activeItems = self.canvas().collisions(QRect(ev.pos().x()-1, ev.pos().y()-1,2,2)) 
     181 
     182            box = self.findItem(activeItems, QCanvasRectangle) 
     183            if box: 
     184                startItems = self.canvas().collisions(QRect(self.tempLine.startPoint().x()-1, self.tempLine.startPoint().y()-1,2,2)) 
     185                box2 = self.findItem(startItems, QCanvasRectangle) 
     186                if box.x() < box2.x(): outBox = box; inBox = box2 
     187                else:                  outBox = box2; inBox = box 
    162188                outName = None; inName = None 
    163189                for (name, box) in self.outBoxes: 
     
    165191                for (name, box) in self.inBoxes: 
    166192                    if box == inBox: inName = name 
    167                 if outName != None and inName != None: 
    168                     self.dlg.addLink(outName, inName) 
     193                if outName != None and inName != None: self.dlg.addLink(outName, inName) 
    169194 
    170195            self.tempLine.hide() 
    171             self.scene().update() 
    172  
     196            self.tempLine.setCanvas(None) 
     197            self.canvas().update() 
     198 
     199 
     200    def findItem(self, items, wantedType): 
     201        for item in items: 
     202            if isinstance(item, wantedType): return item 
     203        return None 
    173204 
    174205    def addLink(self, outName, inName): 
     
    181212            print "error adding link. Data = ", outName, inName 
    182213            return 
    183         line = QGraphicsLineItem(None, self.dlg.canvas) 
    184         outRect = outBox.rect() 
    185         inRect = inBox.rect() 
    186         line.setLine(outRect.x() + outRect.width()-2, outRect.y() + outRect.height()/2.0, inRect.x()+2, inRect.y() + inRect.height()/2.0) 
     214        line = QCanvasLine(self.dlg.canvas) 
     215        line.setPoints(outBox.x() + outBox.width()-2, outBox.y() + outBox.height()/2.0, inBox.x()+2, inBox.y() + inBox.height()/2.0) 
    187216        line.setPen(QPen(QColor(0,255,0), 6)) 
    188         line.setZValue(100) 
    189 ##        line.show() 
    190         self.scene().update() 
     217        line.setZ(-120) 
     218        line.show() 
     219        self.canvas().update() 
    191220        self.lines.append((line, outName, inName, outBox, inBox)) 
    192221 
     
    196225            if outN == outName and inN == inName: 
    197226                line.hide() 
     227                line.setCanvas(None) 
    198228                self.lines.remove((line, outN, inN, outBox, inBox)) 
    199                 self.scene().update() 
     229                self.canvas().update() 
    200230                return 
    201231 
     
    208238        apply(QDialog.__init__,(self,) + args) 
    209239        self.canvasDlg = canvasDlg 
    210  
     240        self.topLayout = QVBoxLayout( self, 10 ) 
    211241        self.signals = [] 
    212242        self._links = [] 
     
    214244 
    215245        # GUI 
    216         self.setWindowTitle('Connect Signals') 
    217         self.setLayout(QVBoxLayout()) 
    218  
    219         self.canvasGroup = orngGui.widgetBox(self, 1) 
    220         self.canvas = QGraphicsScene(0,0,1000,1000) 
     246        self.resize(515,286) 
     247        if (int(qVersion()[0]) >= 3): 
     248            self.setName('Connect Signals') 
     249            self.setCaption(self.tr("Connect Signals")) 
     250        else: 
     251            self.setName('Qt Connect Signals') 
     252            self.setCaption(self.tr("Qt Connect Signals")) 
     253 
     254        self.grid = QGridLayout( 2, 1 ) 
     255        self.topLayout.addLayout( self.grid, 10 ) 
     256 
     257        self.canvasGroup = QHGroupBox("", self) 
     258        self.canvas = QCanvas(1000,1000) 
    221259        self.canvasView = SignalCanvasView(self, self.canvas, self.canvasGroup) 
    222         self.canvasGroup.layout().addWidget(self.canvasView) 
    223  
    224         buttons = orngGui.widgetBox(self, orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)) 
    225  
    226         self.buttonHelp = orngGui.button(buttons, self, "&Help") 
    227         buttons.layout().addStretch(1) 
    228         self.buttonClearAll = orngGui.button(buttons, self, "Clear &All", callback = self.clearAll) 
    229         self.buttonOk = orngGui.button(buttons, self, "&OK", callback = self.accept) 
     260        self.grid.addWidget(self.canvasGroup, 1,1) 
     261 
     262 
     263        LayoutWidget = QWidget(self,'Layout1') 
     264        LayoutWidget.setGeometry(QRect(20,240,476,33)) 
     265        self.grid.addWidget(LayoutWidget, 2,1) 
     266        Layout1 = QHBoxLayout(LayoutWidget) 
     267        Layout1.setSpacing(6) 
     268        Layout1.setMargin(0) 
     269 
     270        #self.buttonHelp = QPushButton("&Help", LayoutWidget) 
     271        #self.buttonHelp.setAutoDefault(1) 
     272        #Layout1.addWidget(self.buttonHelp) 
     273 
     274        self.buttonClearAll = QPushButton("Clear &All", LayoutWidget) 
     275        Layout1.addWidget(self.buttonClearAll) 
     276 
     277        spacer = QSpacerItem(20,20,QSizePolicy.Expanding,QSizePolicy.Minimum) 
     278        Layout1.addItem(spacer) 
     279 
     280        self.buttonOk = QPushButton("&OK", LayoutWidget) 
    230281        self.buttonOk.setAutoDefault(1) 
    231282        self.buttonOk.setDefault(1) 
    232         self.buttonCancel = orngGui.button(buttons, self, "&Cancel", callback = self.reject) 
     283        Layout1.addWidget(self.buttonOk) 
     284 
     285        self.buttonCancel = QPushButton("&Cancel", LayoutWidget) 
     286        self.buttonCancel.setAutoDefault(1) 
     287        Layout1.addWidget(self.buttonCancel) 
     288 
     289        self.connect(self.buttonClearAll,SIGNAL('clicked()'),self.clearAll) 
     290        self.connect(self.buttonOk,SIGNAL('clicked()'),self,SLOT('accept()')) 
     291        self.connect(self.buttonCancel,SIGNAL('clicked()'),self,SLOT('reject()')) 
    233292 
    234293    def clearAll(self): 
     
    240299        self.inWidget = inWidget 
    241300        (width, height) = self.canvasView.addSignalList(outWidget.caption, inWidget.caption, outWidget.widget.getOutputs(), inWidget.widget.getInputs(), outWidget.widget.getFullIconName(), inWidget.widget.getFullIconName()) 
    242         self.canvas.setSceneRect(0, 0, width, height) 
    243         self.resize(width+50, height+80) 
     301        self.canvas.resize(width, height) 
     302        self.resize(width+55, height+90) 
    244303 
    245304    def countCompatibleConnections(self, outputs, inputs, outInstance, inInstance, outType, inType): 
     
    265324                    betterOutSignal = outS 
    266325                    betterInSignal = inS 
     326 
    267327        return existsBetter, betterOutSignal, betterInSignal 
    268328 
     
    279339                    continue        #print "Unable to find signal type for signal %s. Check the definition of the widget." % (inS.name) 
    280340                if issubclass(outType, inType): 
    281                         possibleLinks.append((outS.name, inS.name)) 
     341                    possibleLinks.append((outS.name, inS.name)) 
    282342        return possibleLinks 
    283343 
     
    296356        outConnected = self.outWidget.getOutConnectedSignalNames() 
    297357 
    298         # input connections that can be simultaneously connected to multiple outputs are not to be considered as already connected 
     358        # input connections that can be simultaneously connected to multiple outputs are not to be considered as already connected  
    299359        for i in inConnected[::-1]: 
    300360            if not self.inWidget.instance.signalIsOnlySingleConnection(i): 
     
    317377 
    318378        if not all: return 0 
    319  
     379         
    320380        # try to find a link to any inputs that hasn't been previously connected 
    321381        self.allSignalsTaken = 1 
     
    331391        for pl in [pl1, pl2, pl3, pl4]: 
    332392            #if len(pl) > 1 and sum([i not in inConnected for (o,i) in pl]) > 1: # if we have more than one valid 
    333             if len(pl) > 1:     # if we have more than one valid 
     393            if len(pl) > 1:     # if we have more than one valid  
    334394                self.multiplePossibleConnections = 1 
    335395            if len(pl) > 0:     # when we find a first non-empty list we stop searching 
     
    369429 
    370430 
    371 class ColorIcon(QToolButton): 
     431class ColorIcon(QPushButton): 
    372432    def __init__(self, parent, color): 
    373         QToolButton.__init__(self, parent) 
     433        QPushButton.__init__(self, parent, "") 
    374434        self.color = color 
     435        self.parent = parent 
    375436        self.setMaximumSize(20,20) 
    376437        self.connect(self, SIGNAL("clicked()"), self.showColorDialog) 
    377         self.updateColor() 
    378  
    379     def updateColor(self): 
    380         pixmap = QPixmap(16,16) 
    381         painter = QPainter() 
    382         painter.begin(pixmap) 
    383         painter.setPen(QPen(self.color)) 
    384         painter.setBrush(QBrush(self.color)) 
    385         painter.drawRect(0, 0, 16, 16); 
    386         painter.end() 
    387         self.setIcon(QIcon(pixmap)) 
    388         self.setIconSize(QSize(16,16)) 
    389  
    390438 
    391439    def drawButtonLabel(self, painter): 
     
    395443 
    396444    def showColorDialog(self): 
    397         color = QColorDialog.getColor(self.color, self) 
     445        color = QColorDialog.getColor(self.color, self.parent) 
    398446        if color.isValid(): 
    399447            self.color = color 
    400             self.updateColor() 
    401448            self.repaint() 
    402449 
     
    406453        apply(QDialog.__init__,(self,) + args) 
    407454        self.canvasDlg = canvasDlg 
    408         self.setWindowTitle("Canvas Options") 
    409         self.topLayout = QVBoxLayout(self) 
    410         self.topLayout.setSpacing(0) 
    411         self.resize(500,500) 
    412  
    413         self.tabs = QTabWidget(self) 
    414         GeneralTab = orngGui.widgetBox(self.tabs, removeMargin = 0) 
    415         ExceptionsTab = orngGui.widgetBox(self.tabs, removeMargin = 0) 
    416         TabOrderTab = orngGui.widgetBox(self.tabs, removeMargin = 0) 
    417  
    418         self.tabs.addTab(GeneralTab, "General") 
    419         self.tabs.addTab(ExceptionsTab, "Exception handling") 
    420         self.tabs.addTab(TabOrderTab, "Widget tab order") 
     455        if (int(qVersion()[0]) >= 3): 
     456            if sys.platform == "darwin": 
     457                self.setCaption("Preferences") 
     458            else: 
     459                self.setCaption("Canvas Options") 
     460        else: 
     461            if sys.platform == "darwin": 
     462                self.setCaption("Qt Preferences") 
     463            else: 
     464                self.setCaption("Qt Canvas Options") 
     465        #self.controlArea = QVBoxLayout (self) 
     466        self.topLayout = QVBoxLayout( self, 10 ) 
     467        self.resize(500,450) 
     468 
     469        self.tabs = QTabWidget(self, 'tabWidget') 
     470        GeneralTab = QVGroupBox(self.tabs) 
     471        ExceptionsTab = QVGroupBox(self.tabs) 
     472        TabOrderTab = QVGroupBox(self.tabs) 
     473        self.tabs.insertTab(GeneralTab, "General") 
     474        self.tabs.insertTab(ExceptionsTab, "Output Handling") 
     475        self.tabs.insertTab(TabOrderTab, "Widget Tab Order") 
    421476 
    422477        # ################################################################# 
    423478        # GENERAL TAB 
    424         generalBox = orngGui.widgetBox(GeneralTab, "General Options") 
    425         self.snapToGridCB = orngGui.checkBox(generalBox, "Snap widgets to grid") 
    426         self.useLargeIconsCB = orngGui.checkBox(generalBox, "Show widgets using large icons and text") 
    427         self.writeLogFileCB  = orngGui.checkBox(generalBox, "Write content of Output window to log file") 
    428         self.showSignalNamesCB = orngGui.checkBox(generalBox, "Show signal names between widgets") 
    429         self.dontAskBeforeCloseCB= orngGui.checkBox(generalBox, "Don't ask to save schema before closing") 
    430         self.autoSaveSchemasOnCloseCB = orngGui.checkBox(generalBox, "Automatically save temporary schemas on close") 
    431         self.saveWidgetsPositionCB = orngGui.checkBox(generalBox, "Save size and position of widgets") 
    432         self.useContextsCB = orngGui.checkBox(generalBox, "Use context settings") 
     479        generalBox = QVGroupBox(GeneralTab) 
     480        generalBox.setTitle("General Options") 
     481        self.snapToGridCB = QCheckBox("Snap widgets to grid", generalBox) 
     482        self.useLargeIconsCB = QCheckBox("Show widgets using large icons and text", generalBox) 
     483        self.writeLogFileCB  = QCheckBox("Write content of Output window to log file", generalBox) 
     484        self.showSignalNamesCB = QCheckBox("Show signal names between widgets", generalBox) 
     485        self.dontAskBeforeCloseCB= QCheckBox("Don't ask to save schema before closing", generalBox) 
     486        self.autoSaveSchemasOnCloseCB = QCheckBox("Automatically save temporary schemas on close", generalBox) 
     487        self.saveWidgetsPositionCB = QCheckBox("Save size and position of widgets", generalBox) 
     488        self.useContextsCB = QCheckBox("Use context settings", generalBox) 
     489##        hb = QHBox(generalBox) 
     490##        sep = QWidget(hb) 
     491##        sep.setFixedWidth(30) 
     492##        self.autoLoadSchemasOnStartCB = QCheckBox("Automatically reload last schema", hb) 
    433493 
    434494        validator = QIntValidator(self) 
    435495        validator.setRange(0,10000) 
    436496 
    437         canvasSizeBox = orngGui.widgetBox(GeneralTab, "Default Size of Orange Canvas") 
    438         self.widthEdit = orngGui.lineEdit(canvasSizeBox, "Width:  ", orientation='horizontal', validator = validator ) 
    439         self.heightEdit = orngGui.lineEdit(canvasSizeBox, "Height: ", orientation='horizontal', validator = validator) 
    440  
    441         colorsBox = orngGui.widgetBox(GeneralTab, "Set Colors") 
    442         if canvasDlg: 
    443             selectedWidgetBox = orngGui.widgetBox(colorsBox, orientation = "horizontal") 
    444             self.selectedWidgetIcon = ColorIcon(selectedWidgetBox, canvasDlg.widgetSelectedColor) 
    445             selectedWidgetBox.layout().addWidget(self.selectedWidgetIcon) 
    446             selectedWidgetLabel = orngGui.widgetLabel(selectedWidgetBox, " Selected Widget") 
    447  
    448             activeWidgetBox = orngGui.widgetBox(colorsBox, orientation = "horizontal") 
    449             self.activeWidgetIcon = ColorIcon(activeWidgetBox, canvasDlg.widgetActiveColor) 
    450             activeWidgetBox.layout().addWidget(self.activeWidgetIcon) 
    451             selectedWidgetLabel = orngGui.widgetLabel(activeWidgetBox, " Active Widget") 
    452  
    453             lineBox = orngGui.widgetBox(colorsBox, orientation = "horizontal") 
    454             self.lineIcon = ColorIcon(lineBox, canvasDlg.lineColor) 
    455             lineBox.layout().addWidget(self.lineIcon) 
    456             selectedWidgetLabel = orngGui.widgetLabel(lineBox, " Lines") 
    457         GeneralTab.layout().addStretch(1) 
     497        canvasSizeBox = QVGroupBox(GeneralTab) 
     498        canvasSizeBox.setTitle("Default Size of Orange Canvas") 
     499        widthBox = QHBox(canvasSizeBox) 
     500        widthLabel = QLabel("Width:  ", widthBox) 
     501        self.widthEdit = QLineEdit(widthBox) 
     502        self.widthEdit.setValidator(validator) 
     503 
     504        heightBox = QHBox(canvasSizeBox) 
     505        heightLabel = QLabel("Height: ", heightBox) 
     506        self.heightEdit = QLineEdit(heightBox) 
     507        self.heightEdit.setValidator(validator) 
     508 
     509        colorsBox = QVGroupBox(GeneralTab) 
     510        colorsBox.setTitle("Set Colors For...") 
     511 
     512        selectedWidgetBox = QHBox(colorsBox) 
     513        self.selectedWidgetIcon = ColorIcon(selectedWidgetBox, canvasDlg.widgetSelectedColor) 
     514        selectedWidgetLabel = QLabel(" Selected Widget", selectedWidgetBox) 
     515 
     516        activeWidgetBox = QHBox(colorsBox) 
     517        self.activeWidgetIcon = ColorIcon(activeWidgetBox, canvasDlg.widgetActiveColor) 
     518        activeWidgetLabel = QLabel(" Active Widget", activeWidgetBox) 
     519 
     520        lineBox = QHBox(colorsBox) 
     521        self.lineIcon = ColorIcon(lineBox, canvasDlg.lineColor) 
     522        lineLabel = QLabel(" Lines", lineBox) 
     523 
    458524 
    459525        # ################################################################# 
    460526        # EXCEPTION TAB 
    461         exceptions = orngGui.widgetBox(ExceptionsTab, "Exceptions") 
     527        exceptions = QVGroupBox("Exceptions", ExceptionsTab) 
    462528        #self.catchExceptionCB = QCheckBox('Catch exceptions', exceptions) 
    463         self.focusOnCatchExceptionCB = orngGui.checkBox(exceptions, 'Focus output window on catch') 
    464         self.printExceptionInStatusBarCB = orngGui.checkBox(exceptions, 'Print last exception in status bar') 
    465  
    466         output = orngGui.widgetBox(ExceptionsTab, "System output") 
     529        self.focusOnCatchExceptionCB = QCheckBox('Focus output window on catch', exceptions) 
     530        self.printExceptionInStatusBarCB = QCheckBox('Print last exception in status bar', exceptions) 
     531 
     532        output = QVGroupBox("System output", ExceptionsTab) 
    467533        #self.catchOutputCB = QCheckBox('Catch system output', output) 
    468         self.focusOnCatchOutputCB = orngGui.checkBox(output, 'Focus output window on system output') 
    469         self.printOutputInStatusBarCB = orngGui.checkBox(output, 'Print last system output in status bar') 
    470  
    471         hboxExc = orngGui.widgetBox(ExceptionsTab, orientation="horizontal") 
    472         outputCanvas = orngGui.widgetBox(hboxExc, "Canvas Info Handling") 
    473         outputWidgets = orngGui.widgetBox(hboxExc, "Widget Info Handling") 
    474         self.ocShow = orngGui.checkBox(outputCanvas, 'Show icon above widget for...') 
    475         self.ocInfo = orngGui.checkBox(outputCanvas, 'Information', indent = 10) 
    476         self.ocWarning = orngGui.checkBox(outputCanvas, 'Warnings', indent = 10) 
    477         self.ocError = orngGui.checkBox(outputCanvas, 'Errors', indent = 10) 
    478  
    479         self.owShow = orngGui.checkBox(outputWidgets, 'Show statusbar info for...') 
    480         self.owInfo = orngGui.checkBox(outputWidgets, 'Information', indent = 10) 
    481         self.owWarning = orngGui.checkBox(outputWidgets, 'Warnings', indent = 10) 
    482         self.owError = orngGui.checkBox(outputWidgets, 'Errors', indent = 10) 
    483  
    484         verbosityBox = orngGui.widgetBox(ExceptionsTab, "Verbosity", orientation = "horizontal") 
    485         verbosityBox.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)) 
    486         self.verbosityCombo = orngGui.comboBox(verbosityBox, label = "Set level of widget output: ", orientation='horizontal', items=["Small", "Medium", "High"]) 
    487         ExceptionsTab.layout().addStretch(1) 
     534        self.focusOnCatchOutputCB = QCheckBox('Focus output window on system output', output) 
     535        self.printOutputInStatusBarCB = QCheckBox('Print last system output in status bar', output) 
     536 
     537        hbox = QHBox(ExceptionsTab) 
     538        hbox.layout().setSpacing(5) 
     539        outputCanvas = QVGroupBox("Canvas Info Handling", hbox) 
     540        outputWidgets = QVGroupBox("Widget Info Handling", hbox) 
     541        self.ocShow = QCheckBox('Show icon above widget for...', outputCanvas) 
     542        self.ocInfo = indentedCheckBox('Information', outputCanvas) 
     543        self.ocWarning = indentedCheckBox('Warnings', outputCanvas) 
     544        self.ocError = indentedCheckBox('Errors', outputCanvas) 
     545 
     546        self.owShow = QCheckBox('Show statusbar info for...', outputWidgets) 
     547        self.owInfo = indentedCheckBox('Information', outputWidgets) 
     548        self.owWarning = indentedCheckBox('Warnings', outputWidgets) 
     549        self.owError = indentedCheckBox('Errors', outputWidgets) 
     550 
     551        verbosity = QHGroupBox("Verbosity", ExceptionsTab) 
     552        QLabel("Set level of widget output: ", verbosity) 
     553        self.verbosityCombo = QComboBox(verbosity) 
     554        self.verbosityCombo.insertItem("Small") 
     555        self.verbosityCombo.insertItem("Medium") 
     556        self.verbosityCombo.insertItem("High") 
    488557 
    489558        # ################################################################# 
    490         # TAB ORDER TAB 
    491         tabOrderBox = orngGui.widgetBox(TabOrderTab, "Set Order of Widget Categories", orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) 
    492         self.tabOrderList = QListWidget(tabOrderBox) 
    493         self.tabOrderList.setAcceptDrops(True) 
    494  
    495         tabOrderBox.layout().addWidget(self.tabOrderList) 
    496         self.tabOrderList.setSelectionMode(QListWidget.SingleSelection) 
    497  
    498         w = orngGui.widgetBox(tabOrderBox, sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)) 
    499         self.upButton = orngGui.button(w, self, "Up", callback = self.moveUp) 
    500         self.downButton = orngGui.button(w, self, "Down", callback = self.moveDown) 
    501         w.layout().addSpacing(20) 
    502         self.removeButton = orngGui.button(w, self, "Remove", callback = self.removeCategory) 
    503         w.layout().addStretch(1) 
     559        # WIDGET TAB ORDER 
     560        caption = QLabel("Set order of widget categories", TabOrderTab) 
     561        hbox1 = QHBox(TabOrderTab) 
     562        hbox1.layout().setSpacing(5) 
     563        self.tabOrderList = QListBox(hbox1) 
     564        self.tabOrderList.setSelectionMode(QListBox.Single) 
     565        hbox2 = QVBox(hbox1) 
     566        hbox2.layout().setSpacing(5) 
     567        self.upButton = QPushButton("Up", hbox2) 
     568        self.downButton = QPushButton("Down", hbox2) 
     569        self.removeButton = QPushButton("Remove", hbox2) 
     570        self.upButton.setMaximumWidth(60) 
     571        self.downButton.setMaximumWidth(60) 
     572        self.removeButton.setMaximumWidth(60) 
     573        sep = QWidget(hbox2) 
     574        sep.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)) 
     575        self.connect(self.upButton, SIGNAL("clicked()"), self.moveUp) 
     576        self.connect(self.downButton, SIGNAL("clicked()"), self.moveDown) 
     577        self.connect(self.removeButton, SIGNAL("clicked()"), self.removeCategory) 
     578        self.connect(self.tabOrderList, SIGNAL("highlighted(int)"), self.enableDisableButtons) 
    504579 
    505580        # OK, Cancel buttons 
    506         hbox = orngGui.widgetBox(self, orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)) 
    507         hbox.layout().addStretch(1) 
    508         self.okButton = orngGui.button(hbox, self, "OK", callback = self.accept) 
    509         self.cancelButton = orngGui.button(hbox, self, "Cancel", callback = self.reject) 
    510         self.connect(self.tabOrderList, SIGNAL("currentRowChanged(int)"), self.enableDisableButtons) 
     581 
     582        hbox = QHBox(self) 
     583        if hbox.layout(): 
     584            hbox.layout().setSpacing(6) 
     585            hbox.layout().setMargin(0) 
     586        sep = QWidget(hbox) 
     587        sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)) 
     588 
     589        self.okButton = QPushButton("OK", hbox) 
     590        self.cancelButton = QPushButton("Cancel", hbox) 
    511591 
    512592        self.topLayout.addWidget(self.tabs) 
    513593        self.topLayout.addWidget(hbox) 
    514594 
     595        self.connect(self.okButton, SIGNAL("clicked()"), self.accept) 
     596        self.connect(self.cancelButton, SIGNAL("clicked()"), self.reject) 
    515597 
    516598    # move selected widget category up 
    517599    def moveUp(self): 
    518600        for i in range(1, self.tabOrderList.count()): 
    519             if self.tabOrderList.item(i).isSelected(): 
    520                 item = self.tabOrderList.takeItem(i) 
    521                 for j in range(self.tabOrderList.count()): self.tabOrderList.item(j).setSelected(0) 
    522                 self.tabOrderList.insertItem(i-1, item) 
    523                 item.setSelected(1) 
     601            if self.tabOrderList.isSelected(i): 
     602                text = self.tabOrderList.text(i) 
     603                self.tabOrderList.removeItem(i) 
     604                self.tabOrderList.insertItem(text, i-1) 
     605                self.tabOrderList.setSelected(i-1, True) 
    524606 
    525607    # move selected widget category down 
    526608    def moveDown(self): 
    527609        for i in range(self.tabOrderList.count()-2,-1,-1): 
    528             if self.tabOrderList.item(i).isSelected(): 
    529                 item = self.tabOrderList.takeItem(i) 
    530                 for j in range(self.tabOrderList.count()): self.tabOrderList.item(j).setSelected(0) 
    531                 self.tabOrderList.insertItem(i+1, item) 
    532                 item.setSelected(1) 
    533  
    534     def enableDisableButtons(self, itemIndex): 
     610            if self.tabOrderList.isSelected(i): 
     611                text = self.tabOrderList.text(i) 
     612                self.tabOrderList.removeItem(i) 
     613                self.tabOrderList.insertItem(text, i+1) 
     614                self.tabOrderList.setSelected(i+1, True) 
     615 
     616    def enableDisableButtons(self, *i): 
     617        itemIndex = self.tabOrderList.currentItem() 
    535618        self.upButton.setEnabled(itemIndex > 0) 
    536619        self.downButton.setEnabled(itemIndex < self.tabOrderList.count()-1) 
    537         self.removeButton.setEnabled(not self.canvasDlg.tabs.tabDict[str(self.tabOrderList.item(self.tabOrderList.currentRow()).text())].builtIn) 
     620        self.removeButton.setEnabled(not self.tabs.tabDict[str(self.tabOrderList.currentText())].builtIn) 
    538621 
    539622    def removeCategory(self): 
    540         curCat = str(self.tabOrderList.item(self.tabOrderList.currentRow()).text()) 
    541         if QMessageBox.warning(self,'Orange Canvas', "Unregister widget category '%s' from Orange canvas? This will not remove any files." % curCat, QMessageBox.Ok , QMessageBox.Cancel | QMessageBox.Default | QMessageBox.Escape) == QMessageBox.Yes: 
     623        curCat = str(self.tabOrderList.currentText()) 
     624        if QMessageBox.warning(self,'Orange Canvas', "Unregister widget category '%s' from Orange canvas?\nThis will not remove any files." % curCat, QMessageBox.Yes, QMessageBox.No | QMessageBox.Default | QMessageBox.Escape) == QMessageBox.Yes: 
    542625            self.removeTabs.append(curCat) 
    543             self.tabOrderList.takeItem(self.tabOrderList.currentRow()) 
    544  
     626            self.tabOrderList.removeItem(self.tabOrderList.currentItem()) 
     627 
     628 
     629########## 
     630### Widget registry editor 
     631#### 
    545632 
    546633class KeyEdit(QLineEdit): 
     
    567654            return 
    568655 
    569         pressed = "-".join(filter(None, [e.modifiers() & x and y for x, y in [(Qt.ControlModifier, "Ctrl"), (Qt.AltModifier, "Alt")]]) + [chr(e.key())]) 
     656        pressed = "-".join(filter(None, [e.state() & x and y for x, y in [(e.ControlButton, "Ctrl"), (e.AltButton, "Alt")]]) + [chr(e.key())]) 
    570657 
    571658        assigned = self.invInvDict.get(pressed, None) 
     
    573660            return 
    574661 
    575         if assigned and QMessageBox.question(self, "Confirmation", "'%s' is already assigned to '%s'. Override?" % (pressed, assigned.widget.nameKey), QMessageBox.Yes | QMessageBox.Default, QMessageBox.No | QMessageBox.Escape) == QMessageBox.No: 
    576             return 
     662        if assigned: 
     663            dlg = QMessageBox("Confirmation", "'%s' is already assigned to '%s'. Override?" % (pressed, assigned.widget.nameKey), 
     664                              QMessageBox.Warning, QMessageBox.Yes | QMessageBox.Default, QMessageBox.No | QMessageBox.Escape, 0) 
     665            dlg.exec_loop() 
     666            if dlg.result() == QMessageBox.No: 
     667                return 
    577668 
    578669        self.setText(pressed) 
     
    583674            del self.invdict[assigned.widget] 
    584675 
    585 # widget shortcuts dialog 
     676 
    586677class WidgetRegistryDlg(QDialog): 
    587678    def __init__(self, canvasDlg, *args): 
     
    590681        apply(QDialog.__init__,(self,) + args) 
    591682        self.canvasDlg = canvasDlg 
    592         self.setWindowTitle("Widget Shortcuts") 
    593         self.setLayout(QVBoxLayout()) 
    594         self.layout().setSpacing(10) 
    595         self.resize(700,500) 
     683        if (int(qVersion()[0]) >= 3): 
     684            self.setCaption("Widget Shortcuts") 
     685        else: 
     686            self.setCaption("Qt Widget Shortcuts") 
     687        self.topLayout = QVBoxLayout( self, 10 ) 
     688        self.resize(500,500) 
    596689 
    597690        self.invDict = dict([(y, x) for x, y in canvasDlg.widgetShortcuts.items()]) 
    598691        invInvDict = {} 
    599692 
    600         self.tabs = QTabWidget(self) 
     693        self.tabs = QTabWidget(self, 'tabWidget') 
    601694        for tab in canvasDlg.tabs.tabs: 
    602             scrollArea = QScrollArea() 
    603             self.tabs.addTab(scrollArea, str(canvasDlg.tabs.tabText(canvasDlg.tabs.indexOf(tab)))) 
    604             #scrollArea.setWidgetResizable(1)       # you have to use this or set size to wtab manually - otherwise nothing gets shown 
    605  
    606695            wtab = QWidget(self.tabs) 
    607             scrollArea.setWidget(wtab) 
     696            self.tabs.insertTab(wtab, canvasDlg.tabs.tabLabel(tab)) 
    608697 
    609698            widgets = filter(lambda x:x.__class__ == orngTabs.WidgetButton, tab.widgets) 
    610699            rows = (len(widgets)+2) / 3 
    611             layout = QGridLayout(wtab) 
    612 ##            for i in range(2, 9, 3): 
    613 ##                layout.addItem(QSpacerItem(20, 0), 0, i) 
    614 ##            for i in range(0, 2*rows, 2): 
    615 ##                layout.addItem(QSpacerItem(0, 20), i, 0) 
     700            layout = QGridLayout(wtab, 2*rows+2, 9, 10) 
     701 
     702            for i in range(2, 9, 3): 
     703                layout.addColSpacing(i, 20) 
     704            for i in range(0, 2*rows, 2): 
     705                layout.addRowSpacing(i, 20) 
    616706 
    617707            for i, w in enumerate(widgets): 
    618 ##                y, x = 1 + 2 * (i % rows), 3 * (i/rows) 
    619                 x = i / rows 
    620                 y = i % rows 
    621  
    622                 hlayout = QHBoxLayout() 
    623                 mainBox = QWidget(wtab) 
    624                 mainBox.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) 
    625                 mainBox.setLayout(hlayout) 
    626                 layout.addWidget(mainBox, y, x, Qt.AlignTop | Qt.AlignLeft) 
     708                y, x = 1 + 2 * (i % rows), 3 * (i/rows) 
     709                pixmap = w.iconSet().pixmap(QIconSet.Large, QIconSet.Normal) 
    627710                label = QLabel(wtab) 
    628                 label.setPixmap(w.icon().pixmap(w.icon().actualSize(QSize(50,50)))) 
    629                 hlayout.addWidget(label) 
    630  
    631                 optionsw = QWidget(self) 
    632                 optionsw.setLayout(QVBoxLayout()) 
    633                 hlayout.addWidget(optionsw) 
    634                 optionsw.layout().addStretch(1) 
    635  
    636                 orngGui.widgetLabel(optionsw, w.name) 
     711                label.setPixmap(pixmap) 
     712                layout.addWidget(label, y, x) 
     713 
     714                optionsw = QVBox(wtab) 
     715                layout.addWidget(optionsw, y, x+1, Qt.AlignLeft + Qt.AlignVCenter) 
     716 
     717                QLabel(w.name, optionsw) 
     718                QWidget(optionsw).setFixedHeight(8) 
     719                shb = QHBox(optionsw) 
     720                #QLabel("Shortcut: ", shb) 
    637721                key = self.invDict.get(w, "<none>") 
    638                 le = KeyEdit(optionsw, key, self.invDict, w, invInvDict) 
    639                 optionsw.layout().addWidget(le) 
     722                le = KeyEdit(shb, key, self.invDict, w, invInvDict) 
    640723                invInvDict[key] = le 
    641724                le.setFixedWidth(60) 
    642  
    643             wtab.resize(wtab.sizeHint()) 
     725                sep = QWidget(shb) 
     726                sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     727 
     728            sep = QWidget(wtab) 
     729            sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     730            layout.addMultiCellWidget(sep, 2*rows+1, 2*rows+1, 0, 8) 
    644731 
    645732        # OK, Cancel buttons 
    646         hbox = orngGui.widgetBox(self, orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)) 
    647         hbox.layout().addStretch(1) 
    648         self.okButton = orngGui.button(hbox, self, "OK", callback = self.accept) 
    649         self.cancelButton = orngGui.button(hbox, self, "Cancel", callback = self.reject) 
     733        hbox = QHBox(self) 
     734        if hbox.layout(): 
     735            hbox.layout().setSpacing(6) 
     736            hbox.layout().setMargin(0) 
     737 
     738        sep = QWidget(hbox) 
     739        sep.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     740 
     741        self.okButton = QPushButton("OK", hbox) 
     742        self.okButton.setFixedWidth(110) 
    650743        self.okButton.setDefault(True) 
    651  
    652         self.layout().addWidget(self.tabs) 
    653         self.layout().addWidget(hbox) 
     744        self.cancelButton = QPushButton("Cancel", hbox) 
     745        self.cancelButton.setFixedWidth(110) 
     746 
     747        self.topLayout.addWidget(self.tabs) 
     748        self.topLayout.addWidget(hbox) 
     749 
     750        self.connect(self.okButton, SIGNAL("clicked()"), self.accept) 
     751        self.connect(self.cancelButton, SIGNAL("clicked()"), self.reject) 
    654752 
    655753 
     
    661759        apply(QDialog.__init__,(self,) + args) 
    662760        self.canvasDlg = canvasDlg 
    663         self.topLayout = QVBoxLayout(self) 
    664         self.topLayout.setSpacing(10) 
     761        self.topLayout = QVBoxLayout( self, 10 ) 
    665762        self.grid = QGridLayout( 5, 3 ) 
    666763        self.topLayout.addLayout( self.grid, 10 ) 
     
    669766        groupBox.setTitle("Channel settings") 
    670767        self.grid.addWidget(groupBox, 1,1) 
     768        topLayout2 = QVBoxLayout(groupBox, 10 ) 
    671769        propGrid = QGridLayout(groupBox, 4, 2 ) 
     770        topLayout2.addLayout(propGrid, 10) 
    672771 
    673772        cap0 = QLabel("Symbolic channel names:", self) 
     
    695794        removeButton = QPushButton("Remove selected name", self) 
    696795        closeButton = QPushButton("Close",self) 
    697         self.channelList = QListWidget(self) 
     796        self.channelList = QListBox( self, "channels" ) 
    698797        self.channelList.setMinimumHeight(200) 
    699798        self.connect( self.channelList, SIGNAL("highlighted(int)"), self.listItemChanged ) 
     
    744843 
    745844    def listItemChanged(self, index): 
    746         name = str(self.channelList.item(index).text()) 
     845        name = str(self.channelList.text(index)) 
    747846        value = self.channels[name] 
    748847        items = value.split("::") 
     
    765864        index = self.channelList.currentItem() 
    766865        if index != -1: 
    767             name = str(self.channelList.item(index).text()) 
     866            name = str(self.channelList.text(index)) 
    768867            self.channels[name] = str(self.editFullName.text()) + "::" + str(self.editPriority.currentText()) + "::" + str(self.editColor.currentText()) 
    769868 
    770869    def addNewSignal(self): 
    771         (Qstring,ok) = QInputDialog.getText(self, "Qt Add New Channel Name", "Enter new symbolic channel name") 
     870        if (int(qVersion()[0]) >= 3): 
     871            (Qstring,ok) = QInputDialog.getText("Add New Channel Name", "Enter new symbolic channel name") 
     872        else: 
     873            (Qstring,ok) = QInputDialog.getText("Qt Add New Channel Name", "Enter new symbolic channel name") 
    772874        string = str(Qstring) 
    773875        if ok: 
     
    781883    def selectItem(self, string): 
    782884        for i in range(self.channelList.count()): 
    783             temp = str(self.channelList.item(i).text()) 
     885            temp = str(self.channelList.text(i)) 
    784886            if temp == string: 
    785887                self.channelList.setCurrentItem(i) 
     
    790892        if index != -1: 
    791893            tempDict = {} 
    792             symbName = str(self.channelList.item(index).text()) 
     894            symbName = str(self.channelList.text(index)) 
    793895 
    794896            for key in self.channels.keys(): 
    795897                if key != symbName: 
    796898                    tempDict[key] = self.channels[key] 
    797             self.channels = dict(tempDict) 
     899            self.channels = copy(tempDict) 
    798900 
    799901        self.reloadList() 
     
    808910    def __init__(self, *args): 
    809911        apply(QDialog.__init__,(self,) + args) 
    810         self.setWindowTitle("Set Widget Order") 
    811         self.setLayout(QVBoxLayout()) 
    812  
    813         listbox = orngGui.widgetBox(self, 1, orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) 
    814         self.tabOrderList = QListWidget(listbox) 
    815         self.tabOrderList.setSelectionMode(QListWidget.SingleSelection) 
    816         listbox.layout().addWidget(self.tabOrderList) 
    817  
    818         w = orngGui.widgetBox(listbox, sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)) 
    819         self.upButton = orngGui.button(w, self, "Up", callback = self.moveUp) 
    820         self.downButton = orngGui.button(w, self, "Down", callback = self.moveDown) 
    821         w.layout().addStretch(1) 
    822  
    823         hbox = orngGui.widgetBox(self, orientation = "horizontal", sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)) 
    824         orngGui.button(hbox, self, "Add separator", callback = self.insertSeparator) 
    825         hbox.layout().addStretch(1) 
    826         orngGui.button(hbox, self, "&OK", callback = self.accept) 
    827         orngGui.button(hbox, self, "&Cancel", callback = self.reject) 
    828  
    829         self.resize(200,250) 
     912        if (int(qVersion()[0]) >= 3): 
     913            self.setCaption("Set Widget Order") 
     914        else: 
     915            self.setCaption("Qt Set Widget Order") 
     916        self.shownWidgetList = [] 
     917        self.hiddenWidgetList = [] 
     918 
     919        self.topLayout = QVBoxLayout( self, 10 ) 
     920 
     921        self.grid = QGridLayout( 2, 1 ) 
     922        self.topLayout.addLayout( self.grid, 10 ) 
     923 
     924        self.tab = QTable(self) 
     925        self.tab.setSelectionMode(QTable.Single ) 
     926        self.tab.setRowMovingEnabled(1) 
     927        self.grid.addWidget(self.tab, 1,1) 
     928 
     929        self.tab.setNumCols(2) 
     930        self.tabHH = self.tab.horizontalHeader() 
     931        self.tabHH.setLabel(0, 'Show') 
     932        self.tabHH.setLabel(1, 'Widget Name') 
     933        self.tabHH.resizeSection(0, 50) 
     934        self.tabHH.resizeSection(1, 170) 
     935 
     936        LayoutWidget = QWidget(self,'Layout1') 
     937        LayoutWidget.setGeometry(QRect(200,240,476,33)) 
     938        self.grid.addWidget(LayoutWidget, 2,1) 
     939        Layout1 = QHBoxLayout(LayoutWidget) 
     940        Layout1.setSpacing(6) 
     941        Layout1.setMargin(0) 
     942 
     943        self.insertSeparatorButton = QPushButton('Add separator', LayoutWidget) 
     944        self.connect(self.insertSeparatorButton, SIGNAL("clicked()"), self.insertSeparator) 
     945        Layout1.addWidget(self.insertSeparatorButton) 
     946 
     947        spacer = QSpacerItem(20,20,QSizePolicy.Expanding,QSizePolicy.Minimum) 
     948        Layout1.addItem(spacer) 
     949 
     950        self.okButton = QPushButton('&OK', LayoutWidget) 
     951        self.okButton.setDefault(1) 
     952        Layout1.addWidget(self.okButton) 
     953        self.connect(self.okButton, SIGNAL("clicked()"), self.accept) 
     954 
     955        self.buttonCancel = QPushButton("&Cancel", LayoutWidget) 
     956        self.buttonCancel.setAutoDefault(1) 
     957        Layout1.addWidget(self.buttonCancel) 
     958        self.connect(self.buttonCancel, SIGNAL('clicked()'), self, SLOT('reject()')) 
     959 
     960        self.resize(250,250) 
    830961 
    831962    def accept(self): 
    832         self.shownWidgetList = [str(self.tabOrderList.item(i).text()) for i in range(self.tabOrderList.count())] 
     963        self.shownWidgetList = [] 
     964        self.hiddenWidgetList = [] 
     965        for i in range(self.tab.numRows()): 
     966            if self.tab.cellWidget(i, 0).isChecked(): 
     967                self.shownWidgetList.append(self.tab.text(i, 1)) 
     968            elif self.tab.text(i,1) != "[Separator]": 
     969                self.hiddenWidgetList.append(self.tab.text(i,1)) 
    833970        QDialog.accept(self) 
    834971 
     972 
    835973    def insertSeparator(self): 
    836         curr = self.tabOrderList.indexFromItem(self.tabOrderList.currentItem()).row() 
     974        curr = max(0, self.findSelected()) 
    837975        self.insertWidgetName("[Separator]", curr) 
    838976 
     977 
    839978    def insertWidgetName(self, name, index = -1): 
    840         if index == -1: 
    841             self.tabOrderList.addItem(name) 
    842         else: 
    843             self.tabOrderList.insertItem(index, name) 
    844  
    845     # move selected widget category up 
    846     def moveUp(self): 
    847         for i in range(1, self.tabOrderList.count()): 
    848             if self.tabOrderList.item(i).isSelected(): 
    849                 item = self.tabOrderList.takeItem(i) 
    850                 for j in range(self.tabOrderList.count()): self.tabOrderList.item(j).setSelected(0) 
    851                 self.tabOrderList.insertItem(i-1, item) 
    852                 item.setSelected(1) 
    853  
    854  
    855     # move selected widget category down 
    856     def moveDown(self): 
    857         for i in range(self.tabOrderList.count()-2,-1,-1): 
    858             if self.tabOrderList.item(i).isSelected(): 
    859                 item = self.tabOrderList.takeItem(i) 
    860                 for j in range(self.tabOrderList.count()): self.tabOrderList.item(j).setSelected(0) 
    861                 self.tabOrderList.insertItem(i+1, item) 
    862                 item.setSelected(1) 
     979        if index == -1: index = self.tab.numRows() 
     980        self.tab.setNumRows(self.tab.numRows()+1) 
     981        for i in range(self.tab.numRows()-1, index-1, -1): 
     982            self.swapCells(i, i+1) 
     983        check = QCheckBox(self.tab) 
     984        check.setChecked(1) 
     985        self.tab.setCellWidget(index, 0, check) 
     986        self.tab.setText(index, 1, name) 
     987        #self.tab.adjustColumn(1) 
     988 
     989 
     990    def swapCells(self, row1, row2): 
     991        self.tab.swapCells( row1,0, row2, 0) 
     992        self.tab.swapCells( row1,1, row2, 1) 
     993        self.tab.updateCell(row1,0) 
     994        self.tab.updateCell(row1,1) 
     995        self.tab.updateCell(row2,0) 
     996        self.tab.updateCell(row2,1) 
     997 
     998    def findSelected(self): 
     999        for i in range(self.tab.numRows()): 
     1000            if self.tab.isSelected(i, 0) or self.tab.isSelected(i, 1): return i 
     1001        return -1 
    8631002 
    8641003 
    8651004if __name__=="__main__": 
    866     import sys 
    8671005    app = QApplication(sys.argv) 
    868     dlg = saveApplicationDlg(None) 
     1006    dlg = CanvasOptionsDlg(app) 
     1007    app.setMainWidget(dlg) 
    8691008    dlg.show() 
    870     sys.exit(app.exec_()) 
    871  
     1009    app.exec_loop() 
     1010 
  • orange/OrangeCanvas/orngDoc.py

    r3792 r4014  
    33#    document class - main operations (save, load, ...) 
    44# 
    5 from PyQt4.QtCore import * 
    6 from PyQt4.QtGui import * 
    75import sys, os, os.path, string, traceback 
     6from qt import * 
     7from qtcanvas import * 
    88from xml.dom.minidom import Document, parse 
    99import orngView 
     
    1818        apply(QMainWindow.__init__,(self,) + args) 
    1919        self.canvasDlg = canvasDlg 
    20         self.canvasDlg.workspace.addWindow(self) 
    2120        self.canSave = 0 
    2221        self.resize(700,500) 
    2322        self.showNormal() 
    24         self.setWindowTitle("Schema " + str(self.canvasDlg.iDocIndex)) 
     23        self.setCaption("Schema " + str(self.canvasDlg.iDocIndex)) 
    2524        self.canvasDlg.iDocIndex = self.canvasDlg.iDocIndex + 1 
    26         self.ctrlPressed = 0 
    2725 
    2826        self.enableSave(False) 
    29         self.setWindowIcon(QIcon(canvasDlg.file_new)) 
     27        self.setIcon(QPixmap(canvasDlg.file_new)) 
    3028        self.lines = []                         # list of orngCanvasItems.CanvasLine items 
    3129        self.widgets = []                       # list of orngCanvasItems.CanvasWidget items 
    3230        self.signalManager = SignalManager()    # signal manager to correctly process signals 
     31        self.ctrlPressed = 0 
    3332 
    3433        self.documentpath = canvasDlg.settings["saveSchemaDir"] 
    35         self.documentname = str(self.windowTitle()) 
     34        self.documentname = str(self.caption()) 
    3635        self.applicationpath = canvasDlg.settings["saveApplicationDir"] 
    37         self.applicationname = str(self.windowTitle()) 
     36        self.applicationname = str(self.caption()) 
    3837        self.documentnameValid = False 
    3938        self.loadedSettingsDict = {} 
    40         self.canvas = QGraphicsScene(0,0,2000,2000) 
     39        self.canvas = QCanvas(2000,2000) 
    4140        self.canvasView = orngView.SchemaView(self, self.canvas, self) 
    4241        self.setCentralWidget(self.canvasView) 
     
    5251        self.synchronizeContexts() 
    5352        if self.canvasDlg.settings["autoSaveSchemasOnClose"] and self.widgets != []: 
    54             self.save(os.path.join(self.canvasDlg.canvasSettingsDir, "_lastSchema.ows")) 
     53            self.save(os.path.join(self.canvasDlg.outputDir, "_lastSchema.ows")) 
    5554 
    5655        if not self.canSave or self.canvasDlg.settings["dontAskBeforeClose"]: 
     
    6362 
    6463        #QMainWindow.closeEvent(self, ce) 
    65         res = QMessageBox.question(self, 'Orange Canvas','Do you want to save changes made to schema?', QMessageBox.Yes, QMessageBox.No, QMessageBox.Cancel) 
    66         if res == QMessageBox.Yes: 
     64        res = QMessageBox.information(self,'Orange Canvas','Do you want to save changes made to schema?','&Yes','&No','&Cancel',0) 
     65        if res == 0: 
    6766            self.saveDocument() 
    6867            ce.accept() 
    6968            self.clear() 
    70         elif res == QMessageBox.No: 
     69        elif res == 1: 
    7170            self.clear() 
    7271            ce.accept() 
     
    9897 
    9998        if self.signalManager.existsPath(inWidget.instance, outWidget.instance): 
    100             QMessageBox.critical( self, "Orange Canvas", "Cyclic connections are not allowed in Orange Canvas.", QMessageBox.Ok) 
    101             return 
    102  
    103         dialog = SignalDialog(self.canvasDlg, None) 
     99            QMessageBox.critical( None, "Orange Canvas", "Cyclic connections are not allowed in Orange Canvas.", QMessageBox.Ok + QMessageBox.Default ) 
     100            return 
     101 
     102        dialog = SignalDialog(self.canvasDlg, None, "", True) 
    104103        dialog.setOutInWidgets(outWidget, inWidget) 
    105104        connectStatus = dialog.addDefaultLinks() 
     
    112111 
    113112        if connectStatus == 0: 
    114             QMessageBox.information( self, "Orange Canvas", "Selected widgets don't share a common signal type. Unable to connect.", QMessageBox.Ok) 
     113            QMessageBox.information( None, "Orange Canvas", "Selected widgets don't share a common signal type. Unable to connect.", QMessageBox.Ok + QMessageBox.Default ) 
    115114            return 
    116115        elif connectStatus == -1: 
    117             QMessageBox.critical( self, "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) 
    118             return 
    119  
     116            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 ) 
     117            return 
    120118 
    121119        # if there are multiple choices, how to connect this two widget, then show the dialog 
    122         if len(dialog.getLinks()) > 1 or dialog.multiplePossibleConnections or dialog.getLinks() == []: 
    123             if dialog.exec_() == QDialog.Rejected: 
     120        if self.ctrlPressed or len(dialog.getLinks()) > 1 or dialog.multiplePossibleConnections or dialog.allSignalsTaken or dialog.getLinks() == []: 
     121            res = dialog.exec_loop() 
     122            if dialog.result() == QDialog.Rejected: 
    124123                return 
    125124 
     
    150149 
    151150        if newSignals == None: 
    152             dialog = SignalDialog(self.canvasDlg, None) 
     151            dialog = SignalDialog(self.canvasDlg, None, "", True) 
    153152            dialog.setOutInWidgets(outWidget, inWidget) 
    154153            for (outName, inName) in signals: 
     
    157156 
    158157            # if there are multiple choices, how to connect this two widget, then show the dialog 
    159             if dialog.exec_() == QDialog.Rejected: 
    160                 return 
     158            res = dialog.exec_loop() 
     159            if dialog.result() == QDialog.Rejected: return 
    161160 
    162161            newSignals = dialog.getLinks() 
     
    226225        if self.signalManager.links.has_key(outWidget.instance): 
    227226            for (widget, signalFrom, signalTo, enabled) in self.signalManager.links[outWidget.instance]: 
    228                     if widget == inWidget.instance: 
    229                         otherSignals = 1 
     227                if widget == inWidget.instance: 
     228                    otherSignals = 1 
    230229        if not otherSignals: 
    231230            self.removeLine(outWidget, inWidget) 
     
    258257    # add new widget 
    259258    def addWidget(self, widget, x= -1, y=-1, caption = "", activateSettings = 1): 
    260         qApp.setOverrideCursor(Qt.WaitCursor) 
     259        qApp.setOverrideCursor(QWidget.waitCursor) 
    261260        try: 
    262261            newwidget = orngCanvasItems.CanvasWidget(self.signalManager, self.canvas, self.canvasView, widget, self.canvasDlg.defaultPic, self.canvasDlg) 
     
    271270 
    272271        if x==-1 or y==-1: 
    273             x = self.canvasView.sceneRect().x() + 10 
     272            x = self.canvasView.contentsX() + 10 
    274273            for w in self.widgets: 
    275274                x = max(w.x() + 110, x) 
     
    277276            y = 150 
    278277        newwidget.setCoords(x,y) 
    279         self.canvasView.ensureVisible(newwidget) 
    280 ##        newwidget.setViewPos(self.canvasView.contentsX(), self.canvasView.contentsY()) 
     278        self.canvasView.ensureVisible(x+50,y) 
     279        newwidget.setViewPos(self.canvasView.contentsX(), self.canvasView.contentsY()) 
    281280 
    282281        if caption == "": caption = newwidget.caption 
     
    287286            caption = caption + " (" + str(i) + ")" 
    288287        newwidget.updateText(caption) 
    289         newwidget.instance.setWindowTitle(caption) 
     288        if (int(qVersion()[0]) >= 3): 
     289            newwidget.instance.setCaptionTitle(caption) 
     290        else: 
     291            newwidget.instance.setCaptionTitle("Qt " + caption) 
    290292 
    291293        # show the widget and activate the settings 
    292         qApp.setOverrideCursor(Qt.WaitCursor) 
     294        qApp.setOverrideCursor(QWidget.waitCursor) 
    293295        try: 
    294296            self.signalManager.addWidget(newwidget.instance) 
     
    391393 
    392394    def saveDocumentAs(self): 
    393         qname = QFileDialog.getSaveFileName(self, "Save File", os.path.join(self.documentpath, self.documentname), "Orange Widget Scripts (*.ows)") 
     395        qname = QFileDialog.getSaveFileName( os.path.join(self.documentpath, self.documentname), "Orange Widget Scripts (*.ows)", self, "", "Save File") 
    394396        name = str(qname) 
    395397        if os.path.splitext(name)[0] == "": return 
     
    399401        self.canvasDlg.settings["saveSchemaDir"] = self.documentpath 
    400402        self.applicationname = os.path.splitext(os.path.split(name)[1])[0] + ".py" 
    401         self.setWindowTitle(self.documentname) 
     403        self.setCaption(self.documentname) 
    402404        self.documentnameValid = True 
    403405        self.save() 
     
    472474        if not os.path.exists(filename): 
    473475            self.close() 
    474             QMessageBox.critical(self, 'Orange Canvas', 'Unable to find file "'+ filename,  QMessageBox.Ok + QMessageBox.Default) 
     476            QMessageBox.critical(self,'Orange Canvas','Unable to find file "'+ filename,  QMessageBox.Ok + QMessageBox.Default) 
    475477            return 
    476478 
    477479        # set cursor 
    478         qApp.setOverrideCursor(Qt.WaitCursor) 
     480        qApp.setOverrideCursor(QWidget.waitCursor) 
    479481 
    480482        try: 
     
    499501                tempWidget = self.addWidgetByFileName(name, int(widget.getAttribute("xPos")), int(widget.getAttribute("yPos")), widget.getAttribute("caption"), activateSettings = 0) 
    500502                if not tempWidget: 
    501                     QMessageBox.information(self, 'Orange Canvas','Unable to create instance of widget \"'+ name + '\"',  QMessageBox.Ok + QMessageBox.Default) 
     503                    QMessageBox.information(self,'Orange Canvas','Unable to create an instance of the \"'+ name + '\" widget',  QMessageBox.Ok + QMessageBox.Default) 
    502504                else: 
    503505                    if tempWidget.caption in settingsDict.keys(): 
    504506                        tempWidget.instance.loadSettingsStr(settingsDict[tempWidget.caption]) 
    505507                        tempWidget.instance.activateLoadedSettings() 
    506                 qApp.processEvents() 
     508                #qApp.processEvents() 
    507509 
    508510            #read lines 
     
    516518                outWidget = self.getWidgetByCaption(outCaption) 
    517519                if inWidget == None or outWidget == None: 
    518                     print "Unable to create a line due to invalid widget name. Try reinstalling widgets." 
     520                    print 'Unable to create a line between widgets "%s" and "%s" due to a missing widget.' % (outCaption, inCaption) 
    519521                    continue 
    520522 
     
    528530            self.enableSave(False) 
    529531 
    530             if caption != None: self.setWindowTitle(caption) 
    531             else:               self.setWindowTitle(self.documentname) 
     532            if caption != None: self.setCaption(caption) 
     533            else:               self.setCaption(self.documentname) 
    532534            self.documentnameValid = True 
    533535            if self.widgets: 
     
    539541                    widget.instance.restoreWidgetStatus() 
    540542        finally: 
    541             qApp.restoreOverrideCursor() 
     543            # set cursor 
     544            qApp.setOverrideCursor(QWidget.arrowCursor) 
    542545 
    543546 
     
    549552        extension = sys.platform == "win32" and ".pyw" or ".py" 
    550553        appName = os.path.splitext(self.applicationname)[0] + extension 
    551         qname = QFileDialog.getSaveFileName(self, "Save File as Application", os.path.join(self.applicationpath, appName) , "Orange Scripts (*%s)" % extension) 
     554        qname = QFileDialog.getSaveFileName( os.path.join(self.applicationpath, appName) , "Orange Scripts (*%s)" % extension, self, "", "Save File as Application") 
    552555        if qname.isEmpty(): return 
    553556 
    554         saveDlg = saveApplicationDlg(None) 
     557        saveDlg = saveApplicationDlg(None, "", True) 
    555558 
    556559        # add widget captions 
     
    560563                if self.widgets[i].instance == instance: saveDlg.insertWidgetName(self.widgets[i].caption) 
    561564 
    562         if saveDlg.exec_() == QDialog.Rejected: 
    563             return 
     565        res = saveDlg.exec_loop() 
     566        if saveDlg.result() == QDialog.Rejected: 
     567            return 
     568 
     569        shownWidgetList = saveDlg.shownWidgetList 
     570        hiddenWidgetList = saveDlg.hiddenWidgetList 
    564571 
    565572        (self.applicationpath, self.applicationname) = os.path.split(str(qname)) 
     
    570577        t = "    "  # instead of tab 
    571578        n = "\n" 
    572         start = """#This is automatically created file containing an Orange schema 
    573 import orngOrangeFoldersQt4 
    574 import sys, os, cPickle, orange, orngSignalManager, OWGUI 
     579        imports = """import sys, os, cPickle, orange, orngSignalManager, orngRegistry 
    575580DEBUG_MODE = 0   #set to 1 to output debugging info to file 'signalManagerOutput.txt' 
    576  
    577 """ 
    578  
     581orngRegistry.addWidgetDirectories()\n""" 
     582 
     583        captions = "# set widget captions\n" +t+t 
    579584        instancesT = "# create widget instances\n" +t+t 
    580585        instancesB = "# create widget instances\n" +t+t 
     586        tabs = "# add tabs\n"+t+t 
    581587        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 
     588        buttons = "# create widget buttons\n"+t+t 
     589        buttonsConnect = "#connect GUI buttons to show widgets\n"+t+t 
     590        icons = "# set icons\n"+t+t 
     591        manager = "" 
    582592        loadSett = "" 
    583593        saveSett = "" 
    584         widgetParameters = "" 
    585  
     594        signals = "#set event and progress handler\n"+t+t 
     595        synchronizeContexts = "" 
     596        widgetInstanceList = "#list of widget instances\n" +t+t + "self.widgets = [" 
     597 
     598        sepCount = 1 
    586599        # gui for shown widgets 
    587         for widgetName in saveDlg.shownWidgetList:    # + saveDlg.hiddenWidgetList 
     600        for widgetName in shownWidgetList: 
    588601            if widgetName != "[Separator]": 
    589602                widget = None 
     
    591604                    if self.widgets[i].caption == widgetName: widget = self.widgets[i] 
    592605 
    593                 shown = widgetName in saveDlg.shownWidgetList 
    594606                name = widget.caption 
    595607                name = name.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    596                 start += "from %s import *\n" % (widget.widget.getFileName()) 
     608                imports += "from %s import *\n" % (widget.widget.getFileName()) 
    597609                instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
    598610                instancesB += "self.ow%s = %s(signalManager = self.signalManager)\n" %(name, widget.widget.getFileName()) +t+t 
    599                 widgetParameters += "self.setWidgetParameters(self.ow%s, '%s', '%s', %d)\n" % (name, widget.widget.getIconName(), widget.caption, shown) +t+t 
    600                 loadSett += """self.ow%s.loadSettingsStr(strSettings["%s"]); self.ow%s.activateLoadedSettings()\n""" % (name, widget.caption, name) +t+t 
     611                signals += "self.ow%s.setEventHandler(self.eventHandler)\n" % (name) +t+t + "self.ow%s.setProgressBarHandler(self.progressHandler)\n" % (name) +t+t 
     612                icons += "self.ow%s.setWidgetIcon('%s')\n" % (name, widget.widget.getIconName()) + t+t 
     613                captions += "if (int(qVersion()[0]) >= 3):\n" +t+t+t + "self.ow%s.setCaptionTitle('%s')\n" %(name, widget.caption) +t+t + "else:\n" +t+t+t + "self.ow%s.setCaptionTitle('Qt %s')\n" %(name, widget.caption) +t+t 
     614                manager += "self.signalManager.addWidget(self.ow%s)\n" %(name) +t+t 
     615                tabs += """self.tabs.insertTab (self.ow%s, "%s")\n""" % (name , widget.caption) +t+t 
     616                tabs += "self.ow%s.captionTitle = '%s'\n" % (name, widget.caption)+t+t 
     617                tabs += "self.ow%s.setCaption(self.ow%s.captionTitle)\n" % (name, name) +t+t 
     618                buttons += """owButton%s = QPushButton("%s", self)\n""" % (name, widget.caption) +t+t 
     619                buttonsConnect += """self.connect(owButton%s ,SIGNAL("clicked()"), self.ow%s.reshow)\n""" % (name, name) +t+t 
     620                loadSett += """self.ow%s.loadSettingsStr(strSettings["%s"])\n""" % (name, widget.caption) +t+t 
     621                loadSett += """self.ow%s.activateLoadedSettings()\n""" % (name) +t+t 
    601622                saveSett += """strSettings["%s"] = self.ow%s.saveSettingsStr()\n""" % (widget.caption, name) +t+t 
     623                synchronizeContexts = "self.ow%s.synchronizeContexts()\n" % (name) +t+t + synchronizeContexts 
     624                widgetInstanceList += "self.ow%s, " % (name) 
    602625            else: 
    603                 widgetParameters += "self.box.layout().addSpacing(10)\n" +t+t 
     626                buttons += "frameSpace%s = QFrame(self);  frameSpace%s.setMinimumHeight(10); frameSpace%s.setMaximumHeight(10)\n" % (str(sepCount), str(sepCount), str(sepCount)) +t+t 
     627                sepCount += 1 
     628 
     629        instancesT += n+t+t + "# create instances of hidden widgets\n\n" +t+t 
     630        instancesB += n+t+t + "# create instances of hidden widgets\n\n" +t+t 
     631 
     632        # gui for hidden widgets 
     633        for widgetName in hiddenWidgetList: 
     634            widget = None 
     635            for i in range(len(self.widgets)): 
     636                if self.widgets[i].caption == widgetName: widget = self.widgets[i] 
     637 
     638            name = widget.caption 
     639            name = name.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
     640            imports += "from %s import *\n" % (widget.widget.getFileName()) 
     641            instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
     642            instancesB += "self.ow%s = %s(signalManager = self.signalManager)\n" %(name, widget.widget.getFileName()) +t+t 
     643            signals += "self.ow%s.signalManager = self.signalManager\n" % (name) +t+t + "self.ow%s.setEventHandler(self.eventHandler)\n" % (name) +t+t + "self.ow%s.setProgressBarHandler(self.progressHandler)\n" % (name) +t+t 
     644            manager += "self.signalManager.addWidget(self.ow%s)\n" %(name) +t+t 
     645            tabs += """self.tabs.insertTab (self.ow%s, "%s")\n""" % (name , widget.caption) +t+t 
     646            loadSett += """self.ow%s.loadSettingsStr(strSettings["%s"])\n""" % (name, widget.caption) +t+t 
     647            loadSett += """self.ow%s.activateLoadedSettings()\n""" % (name) +t+t 
     648            saveSett += """strSettings["%s"] = self.ow%s.saveSettingsStr()\n""" % (widget.caption, name) +t+t 
     649            widgetInstanceList += "self.ow%s, " % (name) 
    604650 
    605651        for line in self.lines: 
     
    614660                links += "self.signalManager.addLink( self.ow" + outWidgetName + ", self.ow" + inWidgetName + ", '" + outName + "', '" + inName + "', 1)\n" +t+t 
    615661 
     662        widgetInstanceList += "]" 
    616663        links += "self.signalManager.setFreeze(0)\n" +t+t 
    617         if not asTabs: 
    618             widgetParameters += "self.box.layout().addSpacing(10)"+n+t+t+"exitButton = OWGUI.button(self.box, self, \"Exit\", callback = self.accept())"+n+t+t 
     664        buttons += "frameSpace = QFrame(self);  frameSpace.setMinimumHeight(20); frameSpace.setMaximumHeight(20)\n"+t+t 
     665        buttons += "exitButton = QPushButton(\"E&xit\",self)\n"+t+t + "self.connect(exitButton,SIGNAL(\"clicked()\"), application, SLOT(\"quit()\"))\n"+t+t 
     666 
     667        classinit = """ 
     668    def __init__(self,parent=None, debugMode = DEBUG_MODE, debugFileName = "signalManagerOutput.txt", verbosity = 1): 
     669        QVBox.__init__(self,parent) 
     670        caption = '%s' 
     671        if (int(qVersion()[0]) >= 3): 
     672            self.setCaption(caption) 
     673        else: 
     674            self.setCaption("Qt " + caption) 
     675        self.signalManager = orngSignalManager.SignalManager(debugMode, debugFileName, verbosity) 
     676        self.verbosity = verbosity""" % (fileName) 
     677 
     678        if asTabs == 1: 
     679            classinit += """ 
     680        self.tabs = QTabWidget(self, 'tabWidget') 
     681        self.resize(800,600)""" 
    619682 
    620683        progress = """ 
    621         statusBar = QStatusBar(self); self.layout().addWidget(statusBar) 
    622         self.caption = QLabel('', statusBar) 
    623         self.caption.setMaximumWidth(230) 
    624         self.progress = QProgressBar(statusBar) 
     684        statusBar = QStatusBar(self) 
     685        self.progress = QProgressBar(100, statusBar) 
    625686        self.progress.setMaximumWidth(100) 
     687        self.progress.setCenterIndicator(1) 
    626688        self.status = QLabel("", statusBar) 
    627689        self.status.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)) 
    628         statusBar.addWidget(self.progress) 
    629         statusBar.addWidget(self.caption) 
    630         statusBar.addWidget(self.status)""" 
    631  
    632         handlerFuncts = """ 
    633     def setWidgetParameters(self, widget, iconName, caption, shown): 
    634         widget.setEventHandler(self.eventHandler) 
    635         widget.setProgressBarHandler(self.progressHandler) 
    636         widget.setWidgetIcon(iconName) 
    637         widget.setWindowTitle(caption) 
    638         self.signalManager.addWidget(widget) 
    639         self.widgets.append(widget) 
    640         if shown: """ 
    641  
    642         if asTabs: 
    643             handlerFuncts += "OWGUI.createTabPage(self.tabs, caption)\n"+t+t 
    644         else: 
    645             handlerFuncts += "OWGUI.button(self.box, self, caption, callback = widget.reshow)\n" 
    646  
    647         handlerFuncts += """ 
    648  
    649     def eventHandler(self, text): 
    650         self.status.setText(text) 
     690        statusBar.addWidget(self.progress, 1) 
     691        statusBar.addWidget(self.status, 1)""" 
     692 
     693        handlerFunct = """ 
     694    def eventHandler(self, text, eventVerbosity = 1): 
     695        if self.verbosity >= eventVerbosity: 
     696            self.status.setText(text) 
    651697 
    652698    def progressHandler(self, widget, val): 
    653699        if val < 0: 
    654             self.caption.setText("<nobr>Processing: <b>" + str(widget.captionTitle) + "</b></nobr>") 
     700            self.status.setText("<nobr>Processing: <b>" + str(widget.captionTitle) + "</b></nobr>") 
    655701            self.progress.setProgress(0) 
    656702        elif val >100: 
    657             self.caption.setText("") 
     703            self.status.setText("") 
    658704            self.progress.reset() 
    659705        else: 
    660706            self.progress.setProgress(val) 
    661             self.update() 
     707            self.update()""" 
     708 
     709        loadSettings = """ 
    662710 
    663711    def loadSettings(self): 
     
    668716        strSettings = cPickle.load(file) 
    669717        file.close() 
     718        """ % (fileName + ".sav") 
     719        loadSettings += loadSett 
     720 
     721        saveSettings = """ 
     722 
     723    def saveSettings(self): 
     724        if DEBUG_MODE: return 
    670725        %s 
    671  
    672     def closeEvent(self, ev): 
    673         OWBaseWidget.closeEvent(self, ev) 
    674         if DEBUG_MODE: return 
    675         for widget in self.widgets[::-1]: 
    676             widget.synchronizeContexts() 
    677             widget.close() 
    678726        strSettings = {} 
    679         %s 
    680         file = open("%s", "w") 
     727        """ % (synchronizeContexts) + saveSett + n+t+t + """file = open("%s", "w") 
    681728        cPickle.dump(strSettings, file) 
    682729        file.close() 
    683  
     730        """ % (fileName + ".sav") 
     731 
     732 
     733        finish = """ 
    684734if __name__ == "__main__": 
    685735    application = QApplication(sys.argv) 
    686736    ow = GUIApplication() 
     737    application.setMainWidget(ow) 
    687738    ow.show() 
     739 
    688740    # comment the next line if in debugging mode and are interested only in output text in 'signalManagerOutput.txt' file 
    689     application.exec_() 
    690         """ % (fileName + ".sav", loadSett, saveSett, fileName + ".sav") 
    691  
    692         start += n+n + """ 
    693 class GUIApplication(OWBaseWidget): 
    694     def __init__(self,parent=None, debugMode = DEBUG_MODE, debugFileName = "signalManagerOutput.txt", verbosity = 1): 
    695         self.signalManager = orngSignalManager.SignalManager(debugMode, debugFileName, verbosity) 
    696         OWBaseWidget.__init__(self, title = '%s', signalManager = self.signalManager) 
    697         self.widgets = [] 
    698         """ % (fileName) 
    699  
    700         if asTabs == 1: 
    701             start += """ 
    702         self.tabs = QTabWidget(self) 
    703         self.layout().addWidget(self.tabs) 
    704         self.resize(800,600)""" 
    705         else: 
    706             start += """ 
    707         self.box = OWGUI.widgetBox(self.topWidgetPart, 'Widgets')""" 
     741    application.exec_loop() 
     742    ow.saveSettings() 
     743""" 
     744 
     745        #if save != "": 
     746        #    save = t+"def exit(self):\n" +t+t+ save 
    708747 
    709748        if asTabs: 
    710             whole = start + n+n+t+t+ instancesT + n+t+t + widgetParameters + n+t+t + progress + n+t+t + links + n + handlerFuncts 
    711         else: 
    712             whole = start + n+n+t+t+ instancesB + n+t+t + widgetParameters + n+t+t + progress + n+t+t+  links + n + handlerFuncts 
     749            whole = imports + "\n\n" + "class GUIApplication(QVBox):" + classinit + n+n+t+t+ instancesT + signals + n+t+t + widgetInstanceList+n+t+t + progress + n+t+t + manager + n+t+t + tabs + n+ t+t + links + n+ handlerFunct + "\n\n" + loadSettings + saveSettings + "\n\n" + finish 
     750        else: 
     751            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 
    713752 
    714753        #save app 
     
    716755        self.canvasDlg.settings["saveApplicationDir"] = self.applicationpath 
    717756        fileApp.write(whole) 
     757        fileApp.flush() 
    718758        fileApp.close() 
    719759 
     
    723763    def dumpWidgetVariables(self): 
    724764        for widget in self.widgets: 
    725             self.canvasDlg.output.write("<hr><b>%s</b><br>" % (widget.caption)) 
     765            self.canvasDlg.output.write("<hr><br><b>%s</b><br>" % (widget.caption)) 
    726766            v = vars(widget.instance).keys() 
    727767            v.sort() 
     
    730770 
    731771    def keyReleaseEvent(self, e): 
    732         self.ctrlPressed = int(e.modifiers()) & Qt.ControlModifier != 0 
    733         e.ignore() 
     772        self.ctrlPressed = e.state() & e.ControlButton 
    734773 
    735774    def keyPressEvent(self, e): 
    736         self.ctrlPressed = int(e.modifiers()) & Qt.ControlModifier != 0 
     775        self.ctrlPressed = e.state() & e.ControlButton 
    737776        if e.key() > 127: 
    738             e.ignore() 
     777            QMainWindow.keyPressEvent(self, e) 
    739778            return 
    740779 
    741780        # the list could include (e.ShiftButton, "Shift") if the shift key didn't have the special meaning 
    742         pressed = "-".join(filter(None, [int(e.modifiers()) & x and y for x, y in [(Qt.ControlModifier, "Ctrl"), (Qt.AltModifier, "Alt")]]) + [chr(e.key())]) 
     781        pressed = "-".join(filter(None, [e.state() & x and y for x, y in [(e.ControlButton, "Ctrl"), (e.AltButton, "Alt")]]) + [chr(e.key())]) 
    743782        widgetToAdd = self.canvasDlg.widgetShortcuts.get(pressed) 
    744783        if widgetToAdd: 
    745784            widgetToAdd.clicked() 
    746             if e.modifiers() & Qt.ShiftModifier and len(self.widgets) > 1: 
     785            if e.state() & e.ShiftButton and len(self.widgets) > 1: 
    747786                self.addLine(self.widgets[-2], self.widgets[-1]) 
    748787        else: 
    749             e.ignore() 
     788            QMainWindow.keyPressEvent(self, e) 
    750789 
    751790 
     
    755794    app.setMainWidget(dlg) 
    756795    dlg.show() 
    757     app.exec_() 
     796    app.exec_loop() 
  • orange/OrangeCanvas/orngOutput.py

    r3792 r4014  
    33#     print system output and exceptions into a window. Enables copy/paste 
    44# 
    5 from PyQt4.QtCore import * 
    6 from PyQt4.QtGui import * 
     5from qt import * 
    76import sys 
    87import string 
     
    1514        apply(QMainWindow.__init__,(self,) + args) 
    1615        self.canvasDlg = canvasDlg 
    17         self.canvasDlg.workspace.addWindow(self) 
    1816 
    19         self.textOutput = QTextEdit(self) 
    20         self.textOutput.setReadOnly(1) 
    21         self.textOutput.setCurrentFont(QFont('Courier New',10, QFont.Normal)) 
     17        self.textOutput = QTextView(self) 
     18        self.textOutput.setFont(QFont('Courier New',10, QFont.Normal)) 
    2219        self.setCentralWidget(self.textOutput) 
    23         self.setWindowTitle("Output Window") 
    24         self.setWindowIcon(QIcon(canvasDlg.outputPix)) 
     20        self.setCaption("Output Window") 
     21        self.setIcon(QPixmap(canvasDlg.outputPix)) 
    2522 
    26         #self.defaultExceptionHandler = sys.excepthook 
    27         #self.defaultSysOutHandler = sys.stdout 
     23        self.defaultExceptionHandler = sys.excepthook 
     24        self.defaultSysOutHandler = sys.stdout 
    2825        self.focusOnCatchException = 1 
    2926        self.focusOnCatchOutput  = 0 
     
    3229        self.writeLogFile = 1 
    3330 
    34         self.logFile = open(os.path.join(canvasDlg.canvasSettingsDir, "outputLog.htm"), "w") # create the log file 
     31        self.logFile = open(os.path.join(canvasDlg.outputDir, "outputLog.htm"), "w") # create the log file 
    3532        #self.printExtraOutput = 0 
    3633        self.unfinishedText = "" 
    3734        self.verbosity = 0 
    38  
     35         
    3936        #sys.excepthook = self.exceptionHandler 
    4037        #sys.stdout = self 
    4138        #self.textOutput.setText("") 
    4239        #self.setFocusPolicy(QWidget.NoFocus) 
    43  
     40         
    4441        self.resize(700,500) 
    4542        self.showNormal() 
     
    7370    def setFocusOnException(self, focusOnCatchException): 
    7471        self.focusOnCatchException = focusOnCatchException 
    75  
     72         
    7673    def setFocusOnOutput(self, focusOnCatchOutput): 
    7774        self.focusOnCatchOutput = focusOnCatchOutput 
     
    8784 
    8885    def clear(self): 
    89         self.textOutput.setHtml("") 
    90  
     86        self.textOutput.setText("") 
     87     
    9188    # print text produced by warning and error widget calls 
    9289    def widgetEvents(self, text, eventVerbosity = 1): 
    93         if self.verbosity >= eventVerbosity: 
     90        if self.verbosity >= eventVerbosity:  
    9491            if text != None: 
    9592                self.write(str(text)) 
     
    9895    # simple printing of text called by print calls 
    9996    def write(self, text): 
    100         # is this some extra info for debuging 
    101         #if len(text) > 7 and text[0:7] == "<extra>": 
    102         #    if not self.printExtraOutput: return 
    103         #    text = text[7:] 
    10497        text = str(text) 
    10598        text = text.replace("<", "(").replace(">", ")")    # since this is rich text control, we have to replace special characters 
     
    110103        text = text.replace("(hr)", "<hr>") 
    111104        text = text.replace("\n", "<br>\n")   # replace new line characters with <br> otherwise they don't get shown correctly in html output 
    112         #text = "<nobr>" + text + "</nobr>" 
     105        #text = "<nobr>" + text + "</nobr>"   
    113106 
    114107        if self.focusOnCatchOutput: 
     
    117110 
    118111        if self.writeLogFile: 
    119             #self.logFile.write(str(text) + "<br>\n") 
    120112            self.logFile.write(text) 
    121  
    122         #self.textOutput.append(text) 
    123         self.textOutput.insertHtml(text) 
    124         #self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
     113             
     114        self.textOutput.setText(str(self.textOutput.text()) + text) 
     115        self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
     116         
    125117        if text[-1:] == "\n": 
    126118            if self.printOutput: 
     
    129121        else: 
    130122            self.unfinishedText += text 
    131  
     123         
    132124    def writelines(self, lines): 
    133125        for line in lines: 
     
    137129        pass 
    138130 
     131    def keyReleaseEvent (self, event): 
     132        if event.state() & Qt.ControlButton != 0 and event.ascii() == 3:    # user pressed CTRL+"C" 
     133            self.textOutput.copy() 
     134 
    139135    def exceptionHandler(self, type, value, tracebackInfo): 
    140136        if self.focusOnCatchException: 
     
    143139 
    144140        text = "" 
    145         if str(self.textOutput.toPlainText()) not in ["", "\n"]: 
    146             text += "<hr>" 
    147141        t = localtime() 
    148         text += "<nobr>Unhandled exception of type <b>%s </b> occured at %d:%02d:%02d:</nobr><br><nobr>Traceback:</nobr><br>" % ( str(type) , t[3],t[4],t[5]) 
     142        text += "<hr><nobr>Unhandled exception of type <b>%s </b> occured at %d:%02d:%02d:</nobr><br><nobr>Traceback:</nobr><br>" % ( str(type) , t[3],t[4],t[5]) 
    149143 
    150144        if self.printException: 
     
    153147        # TO DO:repair this code to shown full traceback. when 2 same errors occur, only the first one gets full traceback, the second one gets only 1 item 
    154148        list = traceback.extract_tb(tracebackInfo, 10) 
    155         space = "&nbsp; &nbsp; " 
     149        space = "&nbsp &nbsp " 
    156150        totalSpace = space 
    157151        for i in range(len(list)): 
     
    169163        value = str(value).replace("<", "(").replace(">", ")")    # since this is rich text control, we have to replace special characters 
    170164        text += "<nobr>" + totalSpace + "Exception type: <b>" + str(type) + "</b></nobr><br>" 
    171         text += "<nobr>" + totalSpace + "Exception value: <b>" + value+ "</b></nobr><hr>" 
    172         text = text.replace("<br>","<br>\n") 
    173         self.textOutput.insertHtml(text) 
    174         #self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
     165        text += "<nobr>" + totalSpace + "Exception value: <b>" + value+ "</b></nobr><br><hr>" 
     166        self.textOutput.setText(str(self.textOutput.text()) + text) 
     167        self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
    175168 
    176169        if self.writeLogFile: 
    177             self.logFile.write(str(text) + "<br>\n") 
     170            self.logFile.write(str(text) + "<br>") 
  • orange/OrangeCanvas/orngRegistry.py

    r3792 r4014  
    55import os, sys, string, re, user 
    66import xml.dom.minidom 
    7 from orngOrangeFoldersQt4 import * 
    87 
    98class WidgetsToXML: 
    109 
    1110    # read all installed widgets, build a registry and store widgets.pth with directory names in python dir 
    12     def ParseWidgetRoot(self, widgetDirName, canvasSettingsDir): 
     11    def ParseWidgetRoot(self, widgetDirName, outputDir): 
    1312        widgetDirName = os.path.realpath(widgetDirName) 
    14         canvasSettingsDir = os.path.realpath(canvasSettingsDir) 
    15          
     13        outputDir = os.path.realpath(outputDir) 
     14 
    1615        # create xml document 
    1716        doc = xml.dom.minidom.Document() 
     
    2625                self.ParseDirectory(doc, categories, full_filename, filename) 
    2726 
    28         additionalFile = os.path.join(canvasSettingsDir, "additionalCategories") 
     27        additionalFile = os.path.join(outputDir, "additionalCategories") 
    2928        if os.path.exists(additionalFile): 
    3029            for lne in open(additionalFile, "rt"): 
     
    3837        # we put widgets that are in the root dir of widget directory to category "Other" 
    3938        self.ParseDirectory(doc, categories, widgetDirName, "Other") 
    40          
     39 
    4140        xmlText = doc.toprettyxml() 
    42         file = open(os.path.join(canvasSettingsDir, "widgetregistry.xml"), "wt") 
     41        file = open(os.path.join(outputDir, "widgetregistry.xml"), "wt") 
    4342        file.write(xmlText) 
    4443        file.flush() 
     
    4847    # parse all widgets in directory widgetDirName\categoryName into new category named categoryName 
    4948    def ParseDirectory(self, doc, categories, full_dirname, categoryName, plugin = False): 
    50         if full_dirname not in sys.path:        # add directory to orange path 
    51             sys.path.insert(0, full_dirname)          # this doesn't save the path when you close the canvas, so we have to save also to widgets.pth 
    52          
     49        if sys.path.count(full_dirname) == 0:       # add directory to orange path 
     50            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 
    5352        for filename in os.listdir(full_dirname): 
    5453            full_filename = os.path.join(full_dirname, filename) 
     
    7675            if (name == None):      # if the file doesn't have a name, we treat it as a non-widget file 
    7776                continue 
    78              
     77 
    7978            # create XML node for the widget 
    8079            child = categories.firstChild 
    8180            while (child != None and child.attributes.get("name").nodeValue != categoryName): 
    8281                child= child.nextSibling 
    83      
     82 
    8483            if (child == None): 
    8584                child = doc.createElement("category") 
     
    8887                    child.setAttribute("directory", full_dirname) 
    8988                categories.appendChild(child) 
    90      
     89 
    9190            widget = doc.createElement("widget") 
    9291            widget.setAttribute("file", filename[:-3]) 
     
    9897            widget.setAttribute("author", author) 
    9998            widget.setAttribute("contact", contact) 
    100              
    101             # description             
     99 
     100            # description 
    102101            if (description != ""): 
    103102                desc = doc.createElement("description") 
     
    124123        if (search == None): 
    125124            return None 
    126          
     125 
    127126        text = search.group(0) 
    128127        text = text[text.find(">")+1:-text[::-1].find("<")-1]    #delete the <...> </...> 
    129128        return text.strip() 
    130129 
    131          
     130 
    132131    def GetAllInputs(self, data): 
    133132        #result = re.search('self.inputs *= *[[].*]', data) 
     
    169168    dirs = __getDirectoryNames() 
    170169    parse = WidgetsToXML() 
    171     parse.ParseWidgetRoot(dirs["widgetDir"], dirs["canvasSettingsDir"]) 
     170    widgetDir = os.path.join(dirs["canvasDir"], "../OrangeWidgets") 
     171    parse.ParseWidgetRoot(widgetDir, dirs["outputDir"]) 
    172172 
    173173def readAdditionalCategories(): 
    174174    dirs = __getDirectoryNames() 
    175     addCatFile = os.path.join(dirs["canvasDir"], "additionalCategories") 
     175    addCatFile = os.path.join(dirs["outputDir"], "additionalCategories") 
    176176    if os.path.exists(addCatFile): 
    177177        return [tuple([x.strip() for x in lne.split("\t")]) for lne in open(addCatFile, "r")] 
     
    181181def writeAdditionalCategories(categories): 
    182182    dirs = __getDirectoryNames() 
    183     open(os.path.join(dirs["canvasDir"], "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
     183    open(os.path.join(dirs["outputDir"], "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
    184184 
    185185def addWidgetCategory(category, directory, add = True): 
     
    190190 
    191191 
     192 
     193def __getDirectoryNames(): 
     194    try: 
     195        canvasDir = os.path.split(os.path.abspath(__file__))[0] 
     196        orangeDir = canvasDir[:-13] 
     197    except: 
     198        import orange 
     199        orangeDir = os.path.split(os.path.abspath(orange.__file__))[0] 
     200        canvasDir = os.path.join(orangeDir, "OrangeCanvas") 
     201 
     202    widgetDir = os.path.join(orangeDir, "OrangeWidgets") 
     203    if not os.path.exists(widgetDir): 
     204        print "Error. Directory %s not found. Unable to locate widgets." % widgetDir 
     205 
     206    reportsDir = os.path.join(orangeDir, "report") 
     207    if not os.path.exists(reportsDir): 
     208        try: os.mkdir(reportsDir)        # Vista has roaming profiles that will say that this folder does not exist and will then fail to create it, because it exists... 
     209        except: pass 
     210 
     211    picsDir = os.path.join(widgetDir, "icons") 
     212    if not os.path.exists(picsDir): 
     213        print "Error. Directory %s not found. Unable to locate widget icons." % picsDir 
     214 
     215    home = user.home 
     216    if home[-1] == ":": 
     217        home += "\\" 
     218    if os.name == "nt": 
     219        applicationDir = os.path.join(home, "Application Data") 
     220        if not os.path.exists(applicationDir): 
     221            try: os.mkdir(applicationDir) 
     222            except: pass 
     223        outputDir = os.path.join(applicationDir, "Orange")                  # directory for saving settings and stuff 
     224    elif sys.platform == "darwin": 
     225        applicationDir = os.path.join(home, "Library") 
     226        applicationDir = os.path.join(applicationDir, "Application Support") 
     227        outputDir = os.path.join(applicationDir, "Orange") 
     228    else: 
     229        outputDir = os.path.join(home, "Orange")                  # directory for saving settings and stuff 
     230    if not os.path.exists(outputDir): 
     231        try: os.mkdir(outputDir)        # Vista has roaming profiles that will say that this folder does not exist and will then fail to create it, because it exists... 
     232        except: pass 
     233    outputDir = os.path.join(outputDir, "OrangeCanvas") 
     234    if not os.path.exists(outputDir): 
     235        try: os.mkdir(outputDir)        # Vista has roaming profiles that will say that this folder does not exist and will then fail to create it, because it exists... 
     236        except: pass 
     237 
     238    registryFileName = os.path.join(outputDir, "widgetregistry.xml") 
     239    if not os.path.exists(registryFileName): 
     240        WidgetsToXML().ParseWidgetRoot(widgetDir, outputDir) 
     241 
     242    return dict([(name, vars()[name]) for name in ["canvasDir", "orangeDir", "widgetDir", "reportsDir", "picsDir", "outputDir", "registryFileName"]]) 
     243 
     244 
     245def addWidgetDirectories(): 
     246    sys.path.append(orangeDir) 
     247    sys.path.append(widgetDir) 
     248    if os.path.exists(widgetDir): 
     249        for name in os.listdir(widgetDir): 
     250            fullName = os.path.join(widgetDir, name) 
     251            if os.path.isdir(fullName): 
     252                sys.path.append(fullName) 
     253 
     254    doc = xml.dom.minidom.parse(registryFileName) 
     255    for category in doc.getElementsByTagName("category"): 
     256        directory = category.getAttribute("directory") 
     257        if directory: 
     258            sys.path.append(directory) 
     259 
     260 
     261directoryNames = __getDirectoryNames() 
     262vars().update(directoryNames) 
     263 
    192264if __name__=="__main__": 
    193265    rebuildRegistry() 
  • orange/OrangeCanvas/orngSignalManager.py

    r3792 r4014  
    1818        self.type = signalType 
    1919        self.handler = handler 
    20          
    21         if type(parameters) == str: parameters = eval(parameters)   # in registry, parameters are stored as strings 
     20 
     21        if isinstance(parameters, str): parameters = eval(parameters)   # in registry, parameters are stored as strings 
    2222        # if we have the old definition of parameters then transform them 
    2323        if parameters in [0,1]: 
     
    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          
    38         if type(parameters) == str: parameters = eval(parameters) 
     37 
     38        if isinstance(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 
     
    121121 
    122122        self.debugFile.write(strValue) 
    123         if type(object) == orange.ExampleTable: 
     123        if isinstance(object, orange.ExampleTable): 
    124124            name = " " + getattr(object, "name", "") 
    125125            self.debugFile.write(". Token type = ExampleTable" + name + ". len = " + str(len(object))) 
    126         elif type(object) == list: 
     126        elif isinstance(object, list): 
    127127            self.debugFile.write(". Token type = %s. Value = %s" % (str(type(object)), str(object[:10]))) 
    128128        elif object != None: 
     
    151151        self.debugFile.write(totalSpace[:-1] + "Exception value: " + str(value)+ "\n") 
    152152        self.debugFile.flush() 
    153          
     153 
    154154    # ---------------------------------------------------------- 
    155155    # ---------------------------------------------------------- 
     
    166166        if self.verbosity >= 2: 
    167167            self.addEvent("added widget " + widget.title, eventVerbosity = 2) 
    168              
     168 
    169169        if widget not in self.widgets: 
    170170            #self.widgets.insert(0, widget) 
     
    176176            self.addEvent("remove widget " + widget.title, eventVerbosity = 2) 
    177177        self.widgets.remove(widget) 
    178          
     178 
    179179 
    180180    # send list of widgets, that send their signal to widget's signalName 
     
    196196        return widgets 
    197197 
    198     # can we connect widgetFrom with widgetTo, so that there is no cycle?     
     198    # can we connect widgetFrom with widgetTo, so that there is no cycle? 
    199199    def canConnect(self, widgetFrom, widgetTo): 
    200         return not self.existsPath(widgetTo, widgetFrom)         
     200        return not self.existsPath(widgetTo, widgetFrom) 
    201201 
    202202    def addLink(self, widgetFrom, widgetTo, signalNameFrom, signalNameTo, enabled): 
    203203        if self.verbosity >= 2: 
    204204            self.addEvent("add link from " + widgetFrom.title + " to " + widgetTo.title, eventVerbosity = 2) 
    205          
     205 
    206206        if not self.canConnect(widgetFrom, widgetTo): return 0 
    207207        # check if signal names still exist 
     
    241241            for key in widgetFrom.linksOut[signalNameFrom].keys(): 
    242242                widgetTo.updateNewSignalData(widgetFrom, signalNameTo, widgetFrom.linksOut[signalNameFrom][key], key, signalNameFrom) 
    243              
     243 
    244244        # reorder widgets if necessary 
    245245        if self.widgets.index(widgetFrom) > self.widgets.index(widgetTo): 
     
    275275                return enabled 
    276276        return 0 
    277      
     277 
    278278    def removeLink(self, widgetFrom, widgetTo, signalNameFrom, signalNameTo): 
    279279        if self.verbosity >= 2: 
    280280            self.addEvent("remove link from " + widgetFrom.title + " to " + widgetTo.title, eventVerbosity = 2) 
    281          
     281 
    282282        # no need to update topology, just remove the link 
    283283        if self.links.has_key(widgetFrom): 
     
    307307        if enabled: self.processNewSignals(widgetTo) 
    308308 
    309      
     309 
    310310    def getLinkEnabled(self, widgetFrom, widgetTo): 
    311311        for (widget, nameFrom, nameTo, enabled) in self.links[widgetFrom]:      # it is enough that we find one signal connected from widgetFrom to widgetTo 
     
    326326                #print "signal from ", widgetFrom, " to ", widgetTo, " signal: ", signalNameFrom, " value: ", value, " id: ", id 
    327327                widgetTo.updateNewSignalData(widgetFrom, signalTo, value, id, signalNameFrom) 
    328                  
     328 
    329329 
    330330        if not self.freezing and not self.signalProcessingInProgress: 
     
    332332            self.processNewSignals(widgetFrom) 
    333333 
    334     # when a new link is created, we have to  
     334    # when a new link is created, we have to 
    335335    def sendOnNewLink(self, widgetFrom, widgetTo, signals): 
    336336        for (outName, inName) in signals: 
     
    342342        if len(self.widgets) == 0: return 
    343343        if self.signalProcessingInProgress: return 
    344          
     344 
    345345        if self.verbosity >= 2: 
    346346            self.addEvent("process new signals from " + firstWidget.title, eventVerbosity = 2) 
    347          
     347 
    348348        if firstWidget not in self.widgets: 
    349349            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 
     
    368368        # is there a direct link 
    369369        if not self.links.has_key(widgetFrom): return 0 
    370          
     370 
    371371        for (widget, signalFrom, signalTo, enabled) in self.links[widgetFrom]: 
    372372            if widget == widgetTo: return 1 
  • orange/OrangeCanvas/orngTabs.py

    r3792 r4014  
    33#    tab for showing widgets and widget button class 
    44# 
    5 from PyQt4.QtCore import * 
    6 from PyQt4.QtGui import * 
     5from qt import * 
    76import os.path, sys 
    87from string import strip 
     
    1110from xml.dom.minidom import Document, parse 
    1211 
    13 ICONS_LARGE_SIZE = 80 
    14 ICONS_SMALL_SIZE = 40 
    15  
    1612class DirectionButton(QToolButton): 
    1713    def __init__(self, parent, leftDirection = 1, useLargeIcons = 0): 
    1814        apply(QToolButton.__init__,(self, parent)) 
    19         self.setAutoRaise(1) 
     15        self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
    2016        self.parent = parent 
    2117        self.leftDirection = leftDirection        # is direction to left or right 
     
    2319        self.setAutoRepeat(1) 
    2420 
    25         if self.leftDirection:   self.setIcon(QIcon(self.parent.parent().canvasDlg.move_left)) 
    26         else:                    self.setIcon(QIcon(self.parent.parent().canvasDlg.move_right)) 
    27  
     21        if self.leftDirection:     self.setIconSet(QIconSet(QPixmap(self.parent.parent().canvasDlg.move_left))) 
     22        else:                    self.setIconSet(QIconSet(QPixmap(self.parent.parent().canvasDlg.move_right))) 
     23         
    2824        if useLargeIcons == 1: 
    29             self.setIconSize(QSize(ICONS_LARGE_SIZE-15,ICONS_LARGE_SIZE-15)) 
    30             self.setMaximumSize(5+ICONS_LARGE_SIZE/2, ICONS_LARGE_SIZE) 
    31             self.setMinimumSize(5+ICONS_LARGE_SIZE/2, ICONS_LARGE_SIZE) 
    32         else: 
    33             self.setIconSize(QSize(ICONS_SMALL_SIZE-4, ICONS_SMALL_SIZE-4)) 
    34             self.setMaximumSize(5+ICONS_SMALL_SIZE/2, ICONS_SMALL_SIZE) 
    35             self.setMinimumSize(5+ICONS_SMALL_SIZE/2, ICONS_SMALL_SIZE) 
    36  
     25            self.setUsesBigPixmap(True) 
     26            self.setMaximumSize(40, 80) 
     27            self.setMinimumSize(40, 80) 
     28        else: 
     29            self.setMaximumSize(24, 48) 
     30            self.setMinimumSize(24, 48) 
     31                 
    3732    def clicked(self): 
    3833        if self.leftDirection:  self.parent.moveWidgetsToLeft() 
     
    4338    def __init__(self, *args): 
    4439        apply(QToolButton.__init__,(self,)+ args) 
    45         self.setAutoRaise(1) 
     40        self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
    4641        self.shiftPressed = 0 
    4742 
     
    5348        inputs = self.getInputs() 
    5449        if len(inputs) == 0: 
    55             formatedInList = "<b>Inputs:</b><br> &nbsp;&nbsp; None<br>" 
     50            formatedInList = "<b>Inputs:</b><br> &nbsp &nbsp None" 
    5651        else: 
    5752            formatedInList = "<b>Inputs:</b><br>" 
    5853            for signal in inputs: 
    59                 formatedInList += " &nbsp;&nbsp; - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
     54                formatedInList = formatedInList + " &nbsp &nbsp - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
     55            #formatedInList += "</ul>" 
    6056 
    6157        outputs = self.getOutputs() 
    6258        if len(outputs) == 0: 
    63             formatedOutList = "<b>Outputs:</b><br> &nbsp; &nbsp; None<br>" 
     59            formatedOutList = "<b>Outputs:</b><br> &nbsp &nbsp None<br>" 
    6460        else: 
    6561            formatedOutList = "<b>Outputs:</b><br>" 
    6662            for signal in outputs: 
    67                 formatedOutList += " &nbsp; &nbsp; - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
    68  
    69         tooltipText = "<b><b>&nbsp;%s</b></b><hr><b>Description:</b><br>&nbsp;&nbsp;%s<hr>%s<hr>%s" % (name, self.getDescription(), formatedInList[:-4], formatedOutList[:-4]) 
    70         self.setToolTip(tooltipText) 
     63                formatedOutList = formatedOutList + " &nbsp &nbsp - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
     64            #formatedOutList += "</ul>" 
     65        formatedOutList = formatedOutList[:-4] 
     66         
     67        #tooltipText = name + "\nClass name: " + fileName + "\nin: " + formatedInList + "\nout: " + formatedOutList + "\ndescription: " + description 
     68        tooltipText = "<b>%s</b><br><hr>" % (name) 
     69        #author = self.getAuthor() 
     70        #if author: tooltipText += "<b>Author:</b> %s<br><hr>" % (author) 
     71        tooltipText += "<b>Description:</b><br> &nbsp &nbsp %s<hr>%s<hr>%s" % (self.getDescription(), formatedInList, formatedOutList) 
     72        QToolTip.add( self, tooltipText) 
    7173 
    7274        self.canvasDlg = canvasDlg 
    73         self.setText(name) 
    74  
    75         self.setIcon(QIcon(self.getFullIconName())) 
    76  
     75        self.setTextLabel(name, False) 
     76         
     77        self.setIconSet(QIconSet(QPixmap(self.getFullIconName()))) 
     78         
    7779        if useLargeIcons == 1: 
    78             self.setIconSize(QSize(ICONS_LARGE_SIZE-20,ICONS_LARGE_SIZE-20)) 
    79             self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) 
    80             self.setMaximumSize(ICONS_LARGE_SIZE, ICONS_LARGE_SIZE) 
    81             self.setMinimumSize(ICONS_LARGE_SIZE, ICONS_LARGE_SIZE) 
    82         else: 
    83             self.setIconSize(QSize(ICONS_SMALL_SIZE-4, ICONS_SMALL_SIZE-4)) 
    84             self.setMaximumSize(ICONS_SMALL_SIZE, ICONS_SMALL_SIZE) 
    85             self.setMinimumSize(ICONS_SMALL_SIZE, ICONS_SMALL_SIZE) 
     80            self.setUsesTextLabel (True) 
     81            self.setUsesBigPixmap(True) 
     82            self.setMaximumSize(80, 80) 
     83            self.setMinimumSize(80, 80) 
     84        else: 
     85            self.setMaximumSize(48, 48) 
     86            self.setMinimumSize(48, 48) 
    8687 
    8788    def getFileName(self): 
     
    9091    def getFullIconName(self): 
    9192        name = self.getIconName() 
    92         if os.path.exists(os.path.join(self.canvasDlg.picsDir, name)): 
    93             return os.path.join(self.canvasDlg.picsDir, name) 
    94         elif os.path.exists(os.path.join(self.canvasDlg.widgetDir, name)): 
    95             return os.path.join(self.canvasDlg.widgetDir, name) 
    96         else: 
    97             return self.canvasDlg.defaultPic 
    98  
     93        widgetDir = str(self.widgetTabs.widgetInfo[self.nameKey]["directory"])#os.path.split(self.getFileName())[0] 
     94         
     95        for paths in [(self.canvasDlg.picsDir, name), 
     96                      (self.canvasDlg.widgetDir, name), 
     97                      (name,), 
     98                      (widgetDir, name), 
     99                      (widgetDir, "icons", name)]: 
     100            fname = os.path.join(*paths) 
     101            if os.path.exists(fname): 
     102                return fname 
     103             
     104        return self.canvasDlg.defaultPic 
     105         
    99106    def getIconName(self): 
    100107        return str(self.widgetTabs.widgetInfo[self.nameKey]["iconName"]) 
     
    149156    def getCategory(self): 
    150157        return self.nameKey[:self.nameKey.index("-")].strip() 
    151  
     158     
    152159    def clicked(self, rightClick = False): 
    153160        win = self.canvasDlg.workspace.activeWindow() 
     
    175182        x0, y0, x1, y1 = tl.x(), tl.y(), br.x(), br.y() 
    176183        wx, wy = e.globalX()-x0-ww2, e.globalY()-y0-wh2 
    177  
     184         
    178185        inwindow = (wx > 0) and (wy > 0) and (wx < vrect.width()-ww2) and (wy < vrect.height()-wh2) and isinstance(win, orngDoc.SchemaDoc) 
    179  
     186         
    180187        dinwin, widget = getattr(self, "widgetDragging", (None, None)) 
    181188        if dinwin and (dinwin != win or not inwindow): 
     
    208215    def mouseReleaseEvent(self, e): 
    209216        dinwin, widget = getattr(self, "widgetDragging", (None, None)) 
    210         self.shiftPressed = e.modifiers() & Qt.ShiftModifier 
     217        self.shiftPressed = e.state() & e.ShiftButton 
    211218        if widget: 
    212219            if widget.invalidPosition: 
     
    217224            delattr(self, "widgetDragging") 
    218225        else:  # not dragging, just a click 
    219             if e.button() == Qt.RightButton: 
     226            if e.button() == QMouseEvent.RightButton: 
    220227                self.clicked(True) 
    221228 
    222229        QToolButton.mouseReleaseEvent(self, e) 
    223  
     230             
    224231class WidgetTab(QWidget): 
    225232    def __init__(self, useLargeIcons = 0, *args): 
    226233        apply(QWidget.__init__,(self,)+ args) 
    227234        self.HItemBox = QHBoxLayout(self) 
    228         self.HItemBox.setSpacing(0) 
    229         self.HItemBox.setMargin(0) 
    230235        self.widgets = [] 
    231236        self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     
    233238        self.left  = DirectionButton(self, 1, useLargeIcons = useLargeIcons) 
    234239        self.right = DirectionButton(self, 0, useLargeIcons = useLargeIcons) 
    235         self.frameSpace = QFrame(self) 
    236         self.frameSpace.setMinimumWidth(10) 
    237         self.frameSpace.setMaximumWidth(10) 
    238  
    239240        self.HItemBox.addWidget(self.left) 
    240241        self.HItemBox.addWidget(self.right) 
     242         
     243        self.frameSpace = QFrame(self);  self.frameSpace.setMinimumWidth(10); self.frameSpace.setMaximumWidth(10) 
    241244        self.HItemBox.addWidget(self.frameSpace) 
    242245 
     
    246249        while self.widgetIndex > 0 and isinstance(self.widgets[self.widgetIndex], QFrame): 
    247250            self.widgetIndex -= 1 
    248  
     251         
    249252        self.updateLeftRightButtons() 
    250253 
     
    255258        while self.widgetIndex < len(self.widgets)-2 and isinstance(self.widgets[self.widgetIndex], QFrame): 
    256259            self.widgetIndex += 1 
    257  
     260         
    258261        self.updateLeftRightButtons() 
    259262 
     
    270273        for i in range(self.widgetIndex, len(self.widgets)): 
    271274            widgetsWidth += self.widgets[i].width() 
    272         windowWidth = self.visibleRegion().boundingRect().width() - 2*self.left.width() - 20 
    273  
     275        windowWidth = self.width() - 2*self.left.width() - 20 
     276         
    274277        while self.widgetIndex > 0 and windowWidth > widgetsWidth + self.widgets[self.widgetIndex-1].width(): 
    275278            widgetsWidth += self.widgets[self.widgetIndex-1].width() 
     
    283286        for widget in self.widgets[self.widgetIndex:]: 
    284287            widget.show() 
    285  
    286         self.right.setEnabled(windowWidth < widgetsWidth ) 
    287         self.left.setEnabled(self.widgetIndex > 0) 
    288  
     288         
    289289        if widgetsWidth < windowWidth + 2*self.left.width() + 20 and self.widgetIndex == 0: 
    290290            self.left.hide(); self.right.hide(); self.frameSpace.hide() 
    291291        else: 
    292292            self.left.show(); self.right.show(); self.frameSpace.show() 
     293             
     294        if widgetsWidth < windowWidth: self.right.setEnabled(0) 
     295        else:    self.right.setEnabled(1) 
     296 
     297        if self.widgetIndex > 0: self.left.setEnabled(1) 
     298        else: self.left.setEnabled(0) 
    293299 
    294300        self.HItemBox.invalidate() 
    295301 
    296302    def resizeEvent(self, e): 
    297         QWidget.resizeEvent(self, e) 
    298303        self.updateLeftRightButtons() 
    299304 
    300305 
    301  
    302306class WidgetTabs(QTabWidget): 
    303     def __init__(self, canvasDlg, widgetInfo, *args): 
     307    def __init__(self, widgetInfo, *args): 
    304308        apply(QTabWidget.__init__,(self,) + args) 
    305309        self.tabs = [] 
    306         self.canvasDlg = canvasDlg 
     310        self.canvasDlg = None 
    307311        self.allWidgets = [] 
    308312        self.useLargeIcons = False 
     
    310314        self.setMinimumWidth(10)    # this way the < and > button will show if tab dialog is too small 
    311315        self.widgetInfo = widgetInfo 
    312  
     316         
    313317    def insertWidgetTab(self, name): 
    314         tab = WidgetTab(self.useLargeIcons, self) 
     318        tab = WidgetTab(self.useLargeIcons, self, name) 
    315319        self.tabs.append(tab) 
    316         self.addTab(tab, name) 
     320        self.insertTab(tab, name) 
    317321        self.tabDict[name] = tab 
    318322        return tab 
     323         
     324    def setCanvasDlg(self, canvasDlg): 
     325        self.canvasDlg = canvasDlg 
    319326 
    320327    # read the xml registry and show all installed widgets 
     
    337344        for i in range(len(self.tabs)-1, -1, -1): 
    338345            if self.tabs[i].widgets == []: 
    339                 self.removeTab(self.indexOf(self.tabs[i])) 
     346                self.removePage(self.tabs[i]) 
    340347                self.tabs.remove(self.tabs[i]) 
    341348 
    342  
     349         
    343350    # add all widgets inside the category to the tab 
    344351    def addWidgetCategory(self, category): 
     
    349356        tab.builtIn = not category.hasAttribute("directory") 
    350357        directory = not tab.builtIn and str(category.getAttribute("directory")) 
    351  
     358         
    352359        priorityList = [] 
    353360        nameList = [] 
     
    358365        inputList = [] 
    359366        outputList = [] 
    360  
    361  
     367         
     368         
    362369        widgetList = category.getElementsByTagName("widget") 
    363370        for widget in widgetList: 
     
    370377                priority = int(widget.getAttribute("priority")) 
    371378                iconName = widget.getAttribute("icon") 
    372  
     379                 
    373380                # it's a complicated way to get to the widget description 
    374381                description = "" 
     
    399406 
    400407        exIndex = 0 
    401         for i in range(len(priorityList)): 
     408        for i in range(len(priorityList)):             
    402409            button = WidgetButton(tab) 
    403410            self.widgetInfo[strCategory + " - " + nameList[i]] = {"fileName": fileNameList[i], "iconName": iconNameList[i], "author" : authorList[i], "description":descriptionList[i], "priority":priorityList, "inputs": inputList[i], "outputs" : outputList[i], "button": button, "directory": directory} 
  • orange/OrangeCanvas/orngView.py

    r3792 r4014  
    33#    handling the mouse events inside documents 
    44# 
     5from qt import * 
     6from qtcanvas import * 
    57import orngCanvasItems 
    6 from PyQt4.QtCore import * 
    7 from PyQt4.QtGui import * 
    88 
    99# ######################################## 
    1010# ######## SCHEMA VIEW class 
    1111# ######################################## 
    12 class SchemaView(QGraphicsView): 
     12class SchemaView(QCanvasView): 
    1313    def __init__(self, doc, *args): 
    14         apply(QGraphicsView.__init__,(self,) + args) 
    15         #self.setAlignment(Qt.AlignLeft | Qt.AlignTop) 
     14        apply(QCanvasView.__init__,(self,) + args) 
    1615        self.doc = doc 
    1716        self.bMouseDown = False 
     
    2726        self.tempWidget = None 
    2827        self.selWidgets = [] 
    29         self.setRenderHint(QPainter.Antialiasing) 
    3028        self.createPopupMenus() 
    31         self.ensureVisible(0,0,1,1) 
     29        self.connect(self, SIGNAL("contentsMoving(int,int)"), self.contentsMoving) 
     30 
    3231 
    3332    def createPopupMenus(self): 
    34         self.widgetPopup = QMenu("Widget", self) 
    35         self.widgetPopup.addAction( "Open",  self.openActiveWidget) 
    36         self.widgetPopup.addSeparator() 
    37         rename = self.widgetPopup.addAction( "&Rename", self.renameActiveWidget, Qt.Key_F2) 
    38         delete = self.widgetPopup.addAction("Remove", self.removeActiveWidget, Qt.Key_Delete) 
    39         delete.setShortcut(Qt.Key_Delete) 
    40         rename.setShortcut(Qt.Key_F2) 
     33        self.widgetPopup = QPopupMenu(self, "Widget") 
     34        self.widgetPopup.insertItem( "Open",  self.openActiveWidget) 
     35        self.widgetPopup.insertSeparator() 
     36        rename = self.widgetPopup.insertItem( "&Rename", self.renameActiveWidget, Qt.Key_F2) 
     37        delete = self.widgetPopup.insertItem("Remove", self.removeActiveWidget, Qt.Key_Delete ) 
     38        self.widgetPopup.setAccel(Qt.Key_Delete, delete) 
     39        self.widgetPopup.setAccel(Qt.Key_F2, rename) 
    4140        #self.widgetPopup.insertSeparator() 
    42         #self.menupopupWidgetEnabledID = self.widgetPopup.addAction("Enabled", self.enabledWidget) 
    43  
    44         self.linePopup = QMenu("Link", self) 
    45         self.lineEnabledAction = self.menupopupLinkEnabledID = self.linePopup.addAction( "Enabled",  self.toggleEnabledLink) 
    46         self.lineEnabledAction.setCheckable(1) 
    47         self.linePopup.addSeparator() 
    48         self.linePopup.addAction("Reset Signals", self.resetLineSignals) 
    49         self.linePopup.addAction("Remove", self.deleteSelectedLine) 
    50         self.linePopup.addSeparator() 
     41        #self.menupopupWidgetEnabledID = self.widgetPopup.insertItem("Enabled", self.enabledWidget) 
     42 
     43        self.linePopup = QPopupMenu(self, "Link") 
     44        self.menupopupLinkEnabledID = self.linePopup.insertItem( "Enabled",  self.toggleEnabledLink) 
     45        self.linePopup.insertItem( "Resend Signals",  self.resendSignals) 
     46        self.linePopup.insertSeparator() 
     47        self.linePopup.insertItem( "Reset Signals", self.resetLineSignals) 
     48        self.linePopup.insertItem( "Remove", self.deleteSelectedLine) 
     49        self.linePopup.insertSeparator() 
    5150 
    5251 
     
    6564    def renameActiveWidget(self): 
    6665        exName = str(self.tempWidget.caption) 
    67         (newName ,ok) = QInputDialog.getText(self, "Qt Rename Widget", "Enter new name for the widget \"" + exName + "\":", QLineEdit.Normal, exName) 
     66        if (int(qVersion()[0]) >= 3): 
     67            (newName ,ok) = QInputDialog.getText("Rename Widget", "Enter new name for the widget \"" + exName + "\":", exName) 
     68        else: 
     69            (newName ,ok) = QInputDialog.getText("Qt Rename Widget", "Enter new name for the widget \"" + exName + "\":", exName) 
    6870        newName = str(newName) 
    6971        if ok and self.tempWidget != None and newName != exName: 
    7072            for widget in self.doc.widgets: 
    7173                if widget.caption.lower() == newName.lower(): 
    72                     QMessageBox.information(self, 'Orange Canvas', 'Unable to rename widget. An instance with that name already exists.') 
     74                    QMessageBox.critical(self,'Orange Canvas','Unable to rename widget. An instance with that name already exists.',  QMessageBox.Ok + QMessageBox.Default) 
    7375                    return 
    7476            self.tempWidget.updateText(newName) 
    7577            self.tempWidget.updateTooltip() 
    7678            self.tempWidget.updateLinePosition() 
    77             if len(newName) < 3 or newName[:2].lower() != "qt": 
     79            if (int(qVersion()[0]) < 3) and len(newName) < 3 or newName[:2].lower() != "qt": 
    7880                newName = "Qt " + newName 
    7981            self.tempWidget.instance.setCaption(newName) 
     
    8385    def removeActiveWidget(self): 
    8486        if self.doc.signalManager.signalProcessingInProgress: 
    85              QMessageBox.information( self, "Orange Canvas", "Unable to remove widgets while signal processing is in progress. Please wait.") 
     87             QMessageBox.information( None, "Orange Canvas", "Unable to remove widgets while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
    8688             return 
    8789        if not self.bMultipleSelection: 
     
    9193            self.doc.removeWidget(item) 
    9294 
    93         self.scene().update() 
     95        self.canvas().update() 
    9496        self.selWidgets = [] 
    9597        self.tempWidget = None 
     
    102104    def toggleEnabledLink(self): 
    103105        if self.selectedLine != None: 
    104             oldEnabled = self.doc.signalManager.getLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance) 
    105             self.doc.signalManager.setLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance, not oldEnabled) 
    106             self.selectedLine.setEnabled(not oldEnabled) 
    107 ##            self.selectedLine.repaintLine(self) 
     106            newState = not self.doc.signalManager.getLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance) 
     107            self.doc.signalManager.setLinkEnabled(self.selectedLine.outWidget.instance, self.selectedLine.inWidget.instance, newState) 
     108            self.selectedLine.setEnabled(newState) 
     109            self.selectedLine.repaintLine(self) 
    108110            self.selectedLine.inWidget.updateTooltip() 
    109111            self.selectedLine.outWidget.updateTooltip() 
     
    114116        if not self.selectedLine: return 
    115117        if self.doc.signalManager.signalProcessingInProgress: 
    116              QMessageBox.information( self, "Orange Canvas", "Unable to remove connection while signal processing is in progress. Please wait.") 
     118             QMessageBox.information( None, "Orange Canvas", "Unable to remove connection while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
    117119             return 
    118120        self.deleteLine(self.selectedLine) 
    119121        self.selectedLine = None 
    120         self.scene().update() 
     122        self.canvas().update() 
    121123 
    122124    def deleteLine(self, line): 
     
    145147    # return number of items in "items" of type "type" 
    146148    def findItemTypeCount(self, items, Type): 
    147         return sum([type(item) == Type for item in items]) 
     149        return sum([isinstance(item, Type) for item in items]) 
    148150 
    149151    # find and return first item of type Type 
    150152    def findFirstItemType(self, items, Type): 
    151153        for item in items: 
    152             if type(item) == Type: 
     154            if isinstance(item, Type): 
    153155                return item 
    154156        return None 
     
    158160        ret = [] 
    159161        for item in items: 
    160             if type(item) == Type: 
     162            if isinstance(item, Type): 
    161163                ret.append(item) 
    162164        return ret 
     
    168170 
    169171    # mouse button was pressed 
    170     def mousePressEvent(self, ev): 
    171         self.mouseDownPosition = self.mapToScene(ev.pos()) 
    172  
     172    def contentsMousePressEvent(self, ev): 
     173        self.mouseDownPosition = QPoint(ev.pos().x(), ev.pos().y()) 
    173174        if self.tempRect: 
    174175            self.tempRect.hide() 
     176            self.tempRect.setCanvas(None) 
    175177            self.tempRect = None 
    176178 
    177179        for item in self.doc.widgets: 
    178180            if item not in self.selWidgets: item.setSelected(0) 
    179  
    180         #rect = QRect(ev.pos().x()-5, ev.pos().y()-5,10,10) 
    181         #activeItems = self.scene().collidingItems(rect) 
    182         point = QPointF(self.mouseDownPosition.x(), self.mouseDownPosition.y()) 
    183         activeItem = self.scene().itemAt(QPointF(ev.pos())) 
    184         if not activeItem: 
     181            #item.hide() 
     182            #item.show() 
     183 
     184        rect = QRect(ev.pos().x()-5, ev.pos().y()-5,10,10) 
     185        activeItems = self.canvas().collisions(rect) 
     186        if activeItems == []: 
    185187            self.tempWidget = None 
    186188            self.tempRect = None 
     
    189191 
    190192        # we clicked on a widget or on a line 
    191         else: 
    192             if type(activeItem) == orngCanvasItems.CanvasWidget:        # if we clicked on a widget 
    193                 self.tempWidget = activeItem 
     193        elif activeItems != []: 
     194            widget = self.findFirstItemType(activeItems, orngCanvasItems.CanvasWidget) 
     195            line   = self.findFirstItemType(activeItems, orngCanvasItems.CanvasLine) 
     196            # if we clicked on a widget 
     197            if widget != None: 
     198                self.tempWidget = widget 
    194199                self.tempWidget.setSelected(1) 
    195200 
    196201                # did we click inside the boxes to draw connections 
    197                 if ev.button() == Qt.LeftButton: 
    198                     if activeItem.mouseInsideLeftChannel(point) or activeItem.mouseInsideRightChannel(point): 
    199                         if not self.doc.signalManager.signalProcessingInProgress:   # if we are processing some signals, don't allow to add lines 
    200                             self.unselectAllWidgets() 
    201                             self.bLineDragging = True 
    202                             pos = activeItem.getEdgePoint(point) 
    203                             self.tempLine = orngCanvasItems.TempCanvasLine(self.doc.canvasDlg, self.scene()) 
    204                             self.tempLine.setLine(pos.x(), pos.y(), pos.x(), pos.y()) 
    205                             self.tempLine.setPen(QPen(self.doc.canvasDlg.lineColor, 1)) 
    206 ##                            self.tempLine.show() 
    207                             self.scene().update() 
    208  
    209                     else:   # we clicked inside the widget and we start dragging it 
    210                         self.bWidgetDragging = True 
    211                         if activeItem not in self.selWidgets and not self.doc.ctrlPressed: 
    212                             self.unselectAllWidgets() 
    213                             self.selWidgets = [activeItem] 
    214                             self.bMultipleSelection = False 
    215                         elif self.doc.ctrlPressed: 
    216                             if activeItem not in self.selWidgets: 
    217                                 self.selWidgets.append(activeItem) 
    218                             else: 
    219                                 self.selWidgets.remove(activeItem) 
    220                                 activeItem.setSelected(0) 
    221  
    222                         for w in self.selWidgets: 
    223                             w.setCoords(w.x(), w.y()) 
    224                             w.savePosition() 
    225 ##                            w.removeTooltip() 
    226                             w.setAllLinesFinished(False) 
    227     ##                        w.repaintAllLines() 
     202                if ev.button() == QMouseEvent.LeftButton and (widget.mouseInsideLeftChannel(rect) or widget.mouseInsideRightChannel(rect)): 
     203                    if not self.doc.signalManager.signalProcessingInProgress:   # if we are processing some signals, don't allow to add lines 
     204                        self.bLineDragging = True 
     205                        pos = widget.getEdgePoint(rect) 
     206                        self.tempLine = orngCanvasItems.TempCanvasLine(self.doc.canvasDlg, self.doc.canvas) 
     207                        self.tempLine.setPoints(pos.x(), pos.y(), pos.x(), pos.y()) 
     208                        self.tempLine.show() 
     209                        self.unselectAllWidgets() 
     210                        self.canvas().update() 
     211 
     212                # we clicked inside the widget and we start dragging it 
     213                elif ev.button() == QMouseEvent.LeftButton: 
     214                    self.bWidgetDragging = True 
     215 
     216                    if widget not in self.selWidgets and self.doc.canvasDlg.ctrlPressed == 0: 
     217                        self.unselectAllWidgets() 
     218                        self.selWidgets = [widget] 
     219                        self.bMultipleSelection = False 
     220                    elif self.doc.canvasDlg.ctrlPressed == 1: 
     221                        if widget not in self.selWidgets: 
     222                            self.selWidgets.append(widget) 
     223                        else: 
     224                            self.selWidgets.remove(widget) 
     225                            widget.setSelected(0) 
     226                        #self.doc.canvas.update() 
     227 
     228                    for w in self.selWidgets: 
     229                        w.setCoords(w.x(), w.y()) 
     230                        w.savePosition() 
     231                        w.removeTooltip() 
     232                        w.setAllLinesFinished(False) 
     233                        w.repaintAllLines() 
    228234 
    229235                # is we clicked the right mouse button we show the popup menu for widgets 
    230                 elif ev.button() == Qt.RightButton: 
     236                elif ev.button() == QMouseEvent.RightButton: 
    231237                    self.widgetPopup.popup(ev.globalPos()) 
    232238                else: 
     
    234240 
    235241            # if we right clicked on a line we show a popup menu 
    236             elif type(activeItem) == orngCanvasItems.CanvasLine and ev.button() == Qt.RightButton: 
    237                 self.bMultipleSelection = False 
    238                 self.unselectAllWidgets() 
    239                 self.selectedLine = activeItem 
    240                 self.lineEnabledAction.setChecked(self.selectedLine.getEnabled()) 
    241                 self.linePopup.popup(ev.globalPos()) 
     242            elif line != None: 
     243                if ev.button() == QMouseEvent.RightButton: 
     244                    self.bMultipleSelection = False 
     245                    self.unselectAllWidgets() 
     246                    self.selectedLine = line 
     247                    self.linePopup.setItemChecked(self.menupopupLinkEnabledID, self.selectedLine.getEnabled()) 
     248                    self.linePopup.popup(ev.globalPos()) 
     249                elif ev.button() == QMouseEvent.LeftButton: 
     250                    outWidget, inWidget = line.outWidget.instance, line.inWidget.instance 
     251                    if not self.doc.signalManager.getLinkEnabled(outWidget, inWidget): 
     252                        self.doc.signalManager.setLinkEnabled(outWidget, inWidget, True, True) 
     253 
    242254            else: 
    243255                self.unselectAllWidgets() 
    244256 
    245         self.scene().update() 
     257        self.doc.canvas.update() 
    246258        self.bMouseDown = True 
    247         self.lastMousePosition = self.mapToScene(ev.pos()) 
     259        self.lastMousePosition = QPoint(ev.pos().x(), ev.pos().y()) 
    248260 
    249261 
    250262    # ################################################################### 
    251263    # mouse button was pressed and mouse is moving ###################### 
    252     def mouseMoveEvent(self, ev): 
     264    def contentsMouseMoveEvent(self, ev): 
    253265        #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()): 
    254266        #    self.contentsMouseReleaseEvent(ev) 
    255267        #    return 
    256         point = self.mapToScene(ev.pos()) 
    257268        if self.tempRect: 
    258269            self.tempRect.hide() 
     270            self.tempRect.setCanvas(None) 
    259271            self.tempRect = None 
    260272 
    261         #print self.bWidgetDragging, self.selWidgets 
    262273        if self.bWidgetDragging: 
    263274            for item in self.selWidgets: 
    264275                ex_pos = QPoint(item.x(), item.y()) 
    265                 item.setCoordsBy(point.x() - self.lastMousePosition.x(), point.y() - self.lastMousePosition.y()) 
     276                item.setCoordsBy(ev.pos().x() - self.lastMousePosition.x(), ev.pos().y() - self.lastMousePosition.y()) 
    266277                if self.doc.canvasDlg.snapToGrid: 
    267278                    item.moveToGrid() 
     
    269280                    item.setCoords(item.xPos, item.yPos) 
    270281 
    271                 items = self.scene().collidingItems(item) 
    272                 item.invalidPosition = (self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) > 0) 
     282                items = self.canvas().collisions(item.rect()) 
     283                count = self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) 
     284                if count > 1: item.invalidPosition = True 
     285                else:         item.invalidPosition = False 
    273286                item.updateLineCoords() 
    274287 
    275288        elif self.bLineDragging: 
    276             if self.tempLine: 
    277                 self.tempLine.setLine(self.tempLine.line().x1(), self.tempLine.line().y1(), point.x(), point.y()) 
     289            if self.tempLine: self.tempLine.setPoints(self.tempLine.startPoint().x(), self.tempLine.startPoint().y(), ev.pos().x(), ev.pos().y()) 
    278290 
    279291        elif self.bMultipleSelection: 
    280             rect = QRectF(min (self.mouseDownPosition.x(), point.x()), min (self.mouseDownPosition.y(), point.y()), abs(self.mouseDownPosition.x() - point.x()), abs(self.mouseDownPosition.y() - point.y())) 
    281             self.tempRect = QGraphicsRectItem(rect, None, self.scene()) 
     292            rect = QRect(min (self.mouseDownPosition.x(), ev.pos().x()), min (self.mouseDownPosition.y(), ev.pos().y()), abs(self.mouseDownPosition.x() - ev.pos().x()), abs(self.mouseDownPosition.y() - ev.pos().y())) 
     293            self.tempRect = QCanvasRectangle(rect, self.doc.canvas) 
    282294            self.tempRect.show() 
    283295 
    284296            # select widgets in rectangle 
    285             items = self.scene().collidingItems(self.tempRect) 
     297            items = self.canvas().collisions(rect) 
    286298            widgets = self.findAllItemType(items, orngCanvasItems.CanvasWidget) 
    287299 
     
    294306            self.selWidgets = widgets 
    295307 
    296         self.scene().update() 
    297         self.lastMousePosition = point 
    298  
     308        self.canvas().update() 
     309        self.lastMousePosition = QPoint(ev.pos().x(), ev.pos().y()) 
    299310 
    300311    # ################################################################### 
    301312    # mouse button was released ######################################### 
    302     def mouseReleaseEvent(self, ev): 
    303         point = self.mapToScene(ev.pos()) 
     313    def contentsMouseReleaseEvent(self, ev): 
    304314        if self.tempRect: 
    305315            self.tempRect.hide() 
     316            self.tempRect.setCanvas(None) 
    306317            self.tempRect = None 
    307318 
     
    310321            validPos = True 
    311322            for item in self.selWidgets: 
    312                 items = self.scene().collidingItems(item) 
    313                 validPos = validPos and (self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) == 0) 
    314  
     323                items = self.canvas().collisions(item.rect()) 
     324                count = self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) 
     325                if count > 1: 
     326                    validPos = False 
    315327 
    316328            for item in self.selWidgets: 
     
    322334                item.updateLineCoords() 
    323335                item.setAllLinesFinished(True) 
    324 ##                item.repaintWidget() 
    325 ##                item.repaintAllLines() 
     336                item.repaintWidget() 
     337                item.repaintAllLines() 
    326338 
    327339            self.doc.enableSave(True) 
     
    329341        # if we are drawing line 
    330342        elif self.bLineDragging: 
    331             item = self.scene().itemAt(QPointF(ev.pos())) 
     343            items = self.canvas().collisions(ev.pos()) 
     344            item = self.findFirstItemType(items, orngCanvasItems.CanvasWidget) 
    332345 
    333346            # we must check if we have really conected some output to input 
    334             if type(item) == orngCanvasItems.CanvasWidget and self.tempWidget and self.tempLine and item != self.tempWidget: 
    335                 if self.tempWidget.mouseInsideLeftChannel(self.tempLine.line().p1()): 
     347            if self.tempWidget and self.tempLine and item and item != self.tempWidget: 
     348                if self.tempWidget.mouseInsideLeftChannel(self.tempLine.startPoint()): 
    336349                    outWidget = item 
    337350                    inWidget  = self.tempWidget 
     
    342355                # hide the temp line 
    343356                self.tempLine.hide() 
     357                self.tempLine.setCanvas(None) 
    344358                self.tempLine = None 
    345359 
    346360                if self.doc.signalManager.signalProcessingInProgress: 
    347                      QMessageBox.information( self, "Orange Canvas", "Unable to connect widgets while signal processing is in progress. Please wait.") 
     361                     QMessageBox.information( None, "Orange Canvas", "Unable to connect widgets while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
    348362                else: 
    349363                    line = self.doc.addLine(outWidget, inWidget) 
    350 ##                    if line: line.repaintLine(self) 
     364                    if line: line.repaintLine(self) 
    351365 
    352366            if self.tempLine != None: 
    353                 self.tempLine.setLine(0,0,0,0) 
     367                self.tempLine.setPoints(0,0,0,0) 
    354368                self.tempLine.hide() 
     369                self.tempLine.setCanvas(None) 
    355370                self.tempLine = None 
    356371 
    357         self.scene().update() 
     372        self.canvas().update() 
    358373        self.bMouseDown = False 
    359374        self.bWidgetDragging = False 
    360375        self.bLineDragging = False 
    361         self.bMultipleSelection = False 
    362  
    363     def mouseDoubleClickEvent(self, ev): 
    364         activeItem = self.scene().itemAt(QPointF(ev.pos())) 
    365         if type(activeItem) == orngCanvasItems.CanvasWidget:        # if we clicked on a widget 
    366             self.tempWidget = activeItem 
     376 
     377    def contentsMouseDoubleClickEvent(self, ev): 
     378        rect = QRect(ev.pos().x()-3, ev.pos().y()-3,6,6) 
     379        activeItems = self.canvas().collisions(rect) 
     380        widget = self.findFirstItemType(activeItems, orngCanvasItems.CanvasWidget) 
     381        line   = self.findFirstItemType(activeItems, orngCanvasItems.CanvasLine) 
     382        if widget: 
     383            self.tempWidget = widget 
    367384            self.openActiveWidget() 
    368         elif type(activeItem) == orngCanvasItems.CanvasLine: 
     385        elif line: 
    369386            if self.doc.signalManager.signalProcessingInProgress: 
    370                 QMessageBox.information( self, "Orange Canvas", "Please wait until Orange finishes processing signals.") 
     387                QMessageBox.information( None, "Orange Canvas", "Please wait until Orange finishes processing signals.", QMessageBox.Ok + QMessageBox.Default ) 
    371388                return 
    372             self.doc.resetActiveSignals(activeItem.outWidget, activeItem.inWidget, enabled = self.doc.signalManager.getLinkEnabled(activeItem.outWidget.instance, activeItem.inWidget.instance)) 
    373             activeItem.inWidget.updateTooltip() 
    374             activeItem.outWidget.updateTooltip() 
    375             activeItem.updateTooltip() 
    376  
     389            self.doc.resetActiveSignals(line.outWidget, line.inWidget, enabled = self.doc.signalManager.getLinkEnabled(line.outWidget.instance, line.inWidget.instance)) 
     390            line.inWidget.updateTooltip() 
     391            line.outWidget.updateTooltip() 
     392            line.updateTooltip() 
     393 
     394 
     395    # if we scroll the view, we have to update tooltips for widgets 
     396    def contentsMoving(self, x,y): 
     397        for widget in self.doc.widgets: 
     398            #QToolTip.remove(self, QRect(0,0, self.canvas().width(), self.canvas().height())) 
     399            widget.removeTooltip() 
     400            widget.setViewPos(x,y) 
     401            widget.updateTooltip() 
    377402 
    378403    def progressBarHandler(self, widgetInstance, value): 
     
    402427#    def drawContents(self, painter, x, y, w, h): 
    403428#        rect = QRect(x,y,w,h) 
    404 #        activeItems = self.scene().collisions(rect) 
     429#        activeItems = self.canvas().collisions(rect) 
    405430#        for item in activeItems: 
    406431#            item.drawShape(painter) 
Note: See TracChangeset for help on using the changeset viewer.