Changeset 4013:904ed2617158 in orange


Ignore:
Timestamp:
07/20/07 16:36:23 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
353803fc040e9e798b6e25df3e0e80f53212b3f8
Message:

* empty log message *

Location:
orange/OrangeCanvas
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeCanvas/orngCanvas.pyw

    r3788 r3792  
    22# Description: 
    33#    main file, that creates the MDI environment 
    4  
    5 from qt import * 
    6 import sys, os, cPickle, user 
    7 import orngTabs, orngDoc, orngDlgs, orngOutput, orngRegistry 
     4from PyQt4.QtCore import * 
     5from PyQt4.QtGui import * 
     6import sys, os, cPickle 
     7import orngTabs, orngDoc, orngDlgs, orngOutput 
     8import orange, user, orngMisc, orngRegistry, orngOrangeFoldersQt4 
    89 
    910class OrangeCanvasDlg(QMainWindow): 
    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 
     11    def __init__(self, parent = None, flags = 0): 
     12        QMainWindow.__init__(self, parent) 
    1313        self.debugMode = 1        # print extra output for debuging 
    14         if (int(qVersion()[0]) >= 3): 
    15             self.setCaption("Orange Canvas") 
    16         else: 
    17             self.setCaption("Qt Orange Canvas") 
     14        self.setWindowTitle("Qt Orange Canvas") 
    1815        self.windows = []    # list of id for windows in Window menu 
    1916        self.windowsDict = {}    # dict. with id:menuitem for windows in Window menu 
    2017 
    21         self.__dict__.update(orngRegistry.directoryNames) 
     18        self.__dict__.update(orngOrangeFoldersQt4.directoryNames) 
    2219 
    2320        #self.setFocusPolicy(QWidget.StrongFocus) 
    2421         
    25 ##        import OWReport 
    26 ##        OWReport.IEFeeder(self.reportsDir) 
    27  
    2822        self.defaultPic = os.path.join(self.picsDir, "Unknown.png") 
    2923 
    3024        canvasIconName = os.path.join(self.canvasDir, "icons/CanvasIcon.png") 
    3125        if os.path.exists(canvasIconName): 
    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) 
     26            self.setWindowIcon(QIcon(canvasIconName)) 
     27         
     28        orngOrangeFoldersQt4.addOrangeDirectoriesToPath(self.registryFileName) 
    3929 
    4030        # create error and warning icons 
     
    5343            self.widgetIcons = None 
    5444            print "Unable to load all necessary icons. Please reinstall Orange." 
    55  
     45         
    5646        self.workspace = WidgetWorkspace(self) 
    5747        #self.workspace.setBackgroundColor(QColor(255,255,255)) 
    5848        self.setCentralWidget(self.workspace) 
    5949        self.statusBar = MyStatusBar(self) 
     50        self.setStatusBar(self.statusBar) 
    6051        self.connect(self.workspace, SIGNAL("windowActivated(QWidget*)"), self.focusDocument) 
    61  
     52         
    6253        self.settings = {} 
    6354        self.widgetInfo = {} # this is a dictionary with items: category-widget_name : {info about widget (inList, outList, description...} 
    64  
     55         
    6556        self.rebuildSignals()    # coloring of signals - unused! 
    6657        self.useLargeIcons = False 
     
    6859 
    6960        self.loadSettings() 
    70  
     61         
    7162        self.useLargeIcons = self.settings["useLargeIcons"] 
    7263        self.snapToGrid = self.settings["snapToGrid"] 
    73  
     64         
    7465        self.widgetSelectedColor = QColor(self.settings["widgetSelectedColor"][0], self.settings["widgetSelectedColor"][1], self.settings["widgetSelectedColor"][2]) 
    7566        self.widgetActiveColor   = QColor(self.settings["widgetActiveColor"][0], self.settings["widgetActiveColor"][1], self.settings["widgetActiveColor"][2]) 
    7667        self.lineColor           = QColor(self.settings["lineColor"][0], self.settings["lineColor"][1], self.settings["lineColor"][2]) 
    7768 
    78         self.toolbar = QToolBar(self, 'Toolbar') 
    79         self.widgetsToolBar = QToolBar( self, 'Widgets') 
     69        # create toolbar         
     70        self.toolbar = self.addToolBar("Toolbar") 
     71        self.toolbar.setOrientation(Qt.Horizontal) 
    8072 
    8173        self.iDocIndex = 1 
     
    9183        self.move_right= os.path.join(canvasPicsDir, "moveright.png") 
    9284 
     85        # create menu 
    9386        self.initMenu() 
    9487 
    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') 
     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) 
    9991        self.toolbar.addSeparator() 
    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) 
     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) 
    109101        self.createWidgetsToolbar(not os.path.exists(self.registryFileName)) 
    110  
    111         orngRegistry.addWidgetDirectories() 
     102                
    112103        self.readShortcuts() 
    113  
     104         
    114105        # read recent files 
    115106        self.recentDocs = [] 
     
    119110        height = self.settings.get("canvasHeight", 600) 
    120111        self.resize(width, height) 
    121  
     112         
    122113        # center window in the desktop 
    123114        deskH = app.desktop().height() 
     
    127118        self.move(w,h) 
    128119 
     120         
    129121        # apply output settings 
    130         self.output = orngOutput.OutputWindow(self, self.workspace, "", Qt.WDestructiveClose) 
     122        self.output = orngOutput.OutputWindow(self, self.workspace) 
    131123        self.output.show() 
    132124        #self.output.catchException(self.settings["catchException"]) 
     
    142134 
    143135        self.show() 
    144  
     136                 
    145137        # create new schema 
    146138        win = self.menuItemNewSchema() 
     
    161153    def createWidgetsToolbar(self, rebuildRegistry): 
    162154        self.widgetsToolBar.clear() 
    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 
     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                 
    171159        ## the registry is now build already in the orngRegistry when setting up the directory names 
    172160        if rebuildRegistry == 1: 
    173161            parse = orngRegistry.WidgetsToXML() 
    174             parse.ParseWidgetRoot(self.widgetDir, self.outputDir) 
    175  
     162            parse.ParseWidgetRoot(self.widgetDir, self.canvasSettingsDir) 
     163             
    176164        # if registry still doesn't exist then something is very wrong... 
    177165        if not os.path.exists(self.registryFileName): 
    178             QMessageBox.critical( None, "Orange Canvas", "Unable to locate widget registry. Exiting...", QMessageBox.Ok, QMessageBox.Cancel) 
     166            QMessageBox.critical( self, "Orange Canvas", "Unable to locate widget registry. Exiting...") 
    179167            self.quit() 
    180168 
     
    183171        else: 
    184172            widgetTabList = ["Data", "Classify", "Evaluate", "Visualize", "Associate", "Genomics", "Other"] 
    185  
    186         for tab in widgetTabList: 
    187             self.tabs.insertWidgetTab(tab) 
    188  
     173             
     174        for tab in widgetTabList: self.tabs.insertWidgetTab(tab) 
     175                 
    189176        # read widget registry file and create tab with buttons 
    190177        self.tabs.readInstalledWidgets(self.registryFileName, self.widgetDir, self.picsDir, self.defaultPic, self.useLargeIcons) 
     
    193180        widgetTabList = [] 
    194181        for tab in self.tabs.tabs: 
    195             widgetTabList.append(str(self.tabs.tabLabel(tab))) 
     182            widgetTabList.append(str(self.tabs.tabText(self.tabs.indexOf(tab)))) 
    196183        self.settings["WidgetTabs"] = widgetTabList 
    197  
     184             
    198185 
    199186    def readShortcuts(self): 
    200187        self.widgetShortcuts = {} 
    201         shfn = os.path.join(self.outputDir, "shortcuts.txt") 
     188        shfn = os.path.join(self.canvasSettingsDir, "shortcuts.txt") 
    202189        if os.path.exists(shfn): 
    203190            for t in file(shfn).readlines(): 
     
    208195                else: 
    209196                    print "Warning: invalid shortcut %s (%s)" % (key, button) 
    210  
     197         
    211198    def initMenu(self): 
    212199        # ################### 
    213200        # menu items 
    214201        # ################### 
    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) 
     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) 
    253240 
    254241        # uncomment this only for debugging 
    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  
     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         
    273257        self.connect(self.menuWindow, SIGNAL("aboutToShow()"), self.showWindows) 
    274258 
    275         self.menupopupShowToolbarID = self.menuWindow.insertItem( "Toolbar",  self.menuItemShowToolbar ) 
     259        self.menupopupShowToolbarID = self.menuWindow.addAction( "Toolbar",  self.menuItemShowToolbar ) 
     260        self.menupopupShowToolbarID.setCheckable(True)  
    276261        if self.settings.has_key("showToolbar"): self.showToolbar = self.settings["showToolbar"] 
    277262        else:                                    self.showToolbar = True 
    278263        if not self.showToolbar: self.toolbar.hide() 
    279         self.menuWindow.setItemChecked(self.menupopupShowToolbarID, self.showToolbar) 
    280  
    281         self.menupopupShowWidgetToolbarID = self.menuWindow.insertItem( "Widget Toolbar",  self.menuItemShowWidgetToolbar) 
     264        self.menupopupShowToolbarID.setChecked(self.showToolbar)  
     265         
     266        self.menupopupShowWidgetToolbarID = self.menuWindow.addAction( "Widget Toolbar",  self.menuItemShowWidgetToolbar) 
     267        self.menupopupShowWidgetToolbarID.setCheckable(True)  
    282268        if self.settings.has_key("showWidgetToolbar"): self.showWidgetToolbar = self.settings["showWidgetToolbar"] 
    283         else:                                    self.showWidgetToolbar = True 
     269        else:                                          self.showWidgetToolbar = True 
    284270        if not self.showWidgetToolbar: self.widgetsToolBar.hide() 
    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() 
     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() 
    300286 
    301287        localHelp = 0 
    302         self.menuHelp = QPopupMenu( self ) 
     288        self.menuHelp = QMenu("&Help", self) 
    303289        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")): 
    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  
     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         
    310296        if os.path.exists(os.path.join(self.orangeDir, r"updateOrange.py")): 
    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() 
     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()  
    325313 
    326314 
    327315    def showWindows(self): 
    328316        for id in self.windowsDict.keys(): 
    329             self.menuWindow.removeItem(id) 
     317            self.menuWindow.removeAction(id) 
    330318        self.windowsDict = {} 
    331319        wins = self.workspace.windowList() 
    332320        for i in range(len(wins)): 
    333             txt = str(i+1) + ' ' + str(wins[i].caption()) 
     321            txt = str(i+1) + ' ' + str(wins[i].windowTitle()) 
    334322            if i<10: txt = "&" + txt 
    335             id = self.menuWindow.insertItem(txt, self.activateWindowById) 
     323            id = self.menuWindow.addAction(txt, wins[i].setFocus) 
    336324            self.windowsDict[id]=wins[i] 
    337325 
    338     def activateWindowById(self, id): 
    339         self.windowsDict[id].setFocus() 
     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             
    340330 
    341331    def menuItemNewSchema(self, forceNew = 1): 
     
    343333            for doc in self.workspace.getDocumentList(): 
    344334                if doc.widgets == []: return doc 
    345         win = orngDoc.SchemaDoc(self, self.workspace, "", Qt.WDestructiveClose) 
     335        win = orngDoc.SchemaDoc(self, self.workspace) 
    346336        self.workspace.setDefaultDocPosition(win) 
    347337        return win 
     
    354344 
    355345    def menuItemOpen(self): 
    356         name = QFileDialog.getOpenFileName( self.settings["saveSchemaDir"], "Orange Widget Scripts (*.ows)", self, "", "Open File") 
     346        name = QFileDialog.getOpenFileName(self, "Open File", self.settings["saveSchemaDir"], "Orange Widget Scripts (*.ows)") 
    357347        if name.isEmpty(): 
    358348            return 
     
    362352 
    363353    def menuItemOpenLastSchema(self): 
    364         if os.path.exists(os.path.join(self.outputDir, "_lastSchema.ows")): 
     354        if os.path.exists(os.path.join(self.canvasSettingsDir, "_lastSchema.ows")): 
    365355            win = self.menuItemNewSchema(0) 
    366             win.loadDocument(os.path.join(self.outputDir, "_lastSchema.ows"), str(win.caption())) 
     356            win.loadDocument(os.path.join(self.canvasSettingsDir, "_lastSchema.ows"), str(win.windowTitle())) 
    367357 
    368358    def menuItemClose(self): 
    369359        win = self.workspace.activeWindow() 
    370360        win.close() 
    371  
     361         
    372362    def menuItemSave(self): 
    373363        win = self.workspace.activeWindow() 
     
    390380        win = self.workspace.activeWindow() 
    391381        if isinstance(win, orngDoc.SchemaDoc): 
    392             win.saveDocumentAsApp(asTabs = 1) 
     382            win.saveDocumentAsApp(asTabs = 1)     
    393383 
    394384    def menuItemPrinter(self): 
     
    403393        sizeDlg = OWDlgs.OWChooseImageSizeDlg(win.canvas) 
    404394        sizeDlg.exec_loop() 
    405  
     395         
    406396 
    407397    def readRecentFiles(self): 
     
    417407        recentDocs = recentDocs[:9] 
    418408        self.settings["RecentFiles"] = recentDocs 
    419  
     409         
    420410        for i in range(len(recentDocs)): 
    421411            shortName = "&" + str(i+1) + " " + os.path.basename(recentDocs[i]) 
    422             self.menuRecent.insertItem(shortName, eval("self.menuItemRecent"+str(i+1))) 
     412            self.menuRecent.addAction(shortName, eval("self.menuItemRecent"+str(i+1))) 
    423413 
    424414    def openRecentFile(self, index): 
     
    435425        # convert to a valid file name 
    436426        name = os.path.realpath(name) 
    437  
     427         
    438428        if name in recentDocs: 
    439429            recentDocs.remove(name) 
     
    486476    def menuItemGrid(self): 
    487477        return 
    488  
     478         
    489479    def menuItemShowGrid(self): 
    490480        return 
    491  
     481         
    492482    def updateSnapToGrid(self): 
    493483        if self.snapToGrid == True: 
     
    502492    def updateUseLargeIcons(self): 
    503493        self.createWidgetsToolbar(0) 
    504  
     494                 
    505495    def menuItemEnableAll(self): 
    506496        win = self.workspace.activeWindow() 
    507497        if isinstance(win, orngDoc.SchemaDoc): 
    508498            win.enableAllLines() 
    509  
     499         
    510500    def menuItemDisableAll(self): 
    511501        win = self.workspace.activeWindow() 
     
    529519    def menuItemClearOutputWindow(self): 
    530520        self.output.textOutput.setText("") 
    531         self.statusBar.message("") 
     521        self.statusBar.showMessage("") 
    532522 
    533523    def menuItemSaveOutputWindow(self): 
    534         qname = QFileDialog.getSaveFileName( self.settings["saveSchemaDir"] + "/Output.htm", "HTML Document (*.htm)", self, "", "Save Output To File") 
     524        qname = QFileDialog.getSaveFileName(self, "Save Output To File", self.canvasSettingsDir + "/Output.htm", "HTML Document (*.htm)") 
    535525        if qname.isEmpty(): return 
    536526        name = str(qname) 
     
    547537        self.showToolbar = not self.showToolbar 
    548538        self.settings["showToolbar"] = self.showToolbar 
    549         self.menuWindow.setItemChecked(self.menupopupShowToolbarID, self.showToolbar) 
     539        self.menupopupShowToolbarID.setChecked(self.showToolbar) 
    550540        if self.showToolbar: self.toolbar.show() 
    551541        else: self.toolbar.hide() 
     
    554544        self.showWidgetToolbar = not self.showWidgetToolbar 
    555545        self.settings["showWidgetToolbar"] = self.showWidgetToolbar 
    556         self.menuWindow.setItemChecked(self.menupopupShowWidgetToolbarID, self.showWidgetToolbar) 
     546        self.menupopupShowWidgetToolbarID.setChecked(self.showWidgetToolbar) 
    557547        if self.showWidgetToolbar: self.widgetsToolBar.show() 
    558548        else: self.widgetsToolBar.hide() 
     
    568558    def menuItemRebuildWidgetRegistry(self): 
    569559        self.createWidgetsToolbar(True) 
    570  
     560         
    571561    def menuItemEditWidgetShortcuts(self): 
    572         dlg = orngDlgs.WidgetRegistryDlg(self, None, "", True) 
    573         dlg.exec_loop() 
    574         if dlg.result() == QDialog.Accepted: 
    575  
     562        dlg = orngDlgs.WidgetRegistryDlg(self) 
     563        if dlg.exec_() == QDialog.Accepted: 
    576564            self.widgetShortcuts = dict([(y, x) for x, y in dlg.invDict.items()]) 
    577             shf = file(os.path.join(self.outputDir, "shortcuts.txt"), "wt") 
     565            shf = file(os.path.join(self.canvasSettingsDir, "shortcuts.txt"), "wt") 
    578566            for k, v in self.widgetShortcuts.items(): 
    579567                shf.write("%s: %s\n" % (k, v.nameKey)) 
     
    583571        for win in wins: 
    584572            win.close() 
    585  
     573             
    586574    def menuMinimizeAll(self): 
    587575        wins = self.workspace.windowList() 
    588576        for win in wins: 
    589577            win.showMinimized() 
    590  
     578             
    591579    def menuRestoreAll(self): 
    592580        wins = self.workspace.windowList() 
     
    616604 
    617605    def menuHelpAbout(self): 
    618         pass 
     606        pass     
    619607 
    620608    def rebuildSignals(self): 
     
    637625            return [symbName, str(1), "blue"] 
    638626 
    639     def focusDocument(self, w): 
     627    def focusDocument(self, w):     
    640628        if w: w.setFocus() 
    641629 
    642630    def menuItemCanvasOptions(self): 
    643         dlg = orngDlgs.CanvasOptionsDlg(self, None, "", True) 
     631        dlg = orngDlgs.CanvasOptionsDlg(self, None) 
    644632 
    645633        # set general options settings 
     
    657645        dlg.widthEdit.setText(str(self.settings.get("canvasWidth", 700))) 
    658646 
    659         # exception tab 
     647        # set current exception settings 
    660648        dlg.focusOnCatchExceptionCB.setChecked(self.settings["focusOnCatchException"]) 
    661649        dlg.printExceptionInStatusBarCB.setChecked(self.settings["printExceptionInStatusBar"]) 
    662650        dlg.focusOnCatchOutputCB.setChecked(self.settings["focusOnCatchOutput"]) 
    663651        dlg.printOutputInStatusBarCB.setChecked(self.settings["printOutputInStatusBar"]) 
    664         dlg.verbosityCombo.setCurrentItem(self.settings["outputVerbosity"]) 
     652        dlg.verbosityCombo.setCurrentIndex(self.settings["outputVerbosity"]) 
    665653        dlg.ocShow.setChecked(self.settings["ocShow"]) 
    666654        dlg.ocInfo.setChecked(self.settings["ocInfo"]) 
     
    674662        # fill categories tab list 
    675663        oldTabList = [] 
    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: 
     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: 
    684670            h = int(str(dlg.heightEdit.text())); 
    685671            w = int(str(dlg.widthEdit.text())) 
    686  
     672                         
    687673            # save general settings 
    688674            if self.snapToGrid != dlg.snapToGridCB.isChecked(): 
     
    695681                self.settings["useLargeIcons"] = self.useLargeIcons 
    696682                self.updateUseLargeIcons() 
    697  
     683                     
    698684            # save exceptions settings 
    699685            #self.settings["catchException"] = dlg.catchExceptionCB.isChecked() 
     
    722708            self.settings["useContexts"] = dlg.useContextsCB.isChecked() 
    723709##            self.settings["autoLoadSchemasOnStart"] = dlg.autoLoadSchemasOnStartCB.isChecked() 
    724  
     710             
    725711            self.settings["widgetSelectedColor"] = (dlg.selectedWidgetIcon.color.red(), dlg.selectedWidgetIcon.color.green(), dlg.selectedWidgetIcon.color.blue()) 
    726712            self.settings["widgetActiveColor"]   = (dlg.activeWidgetIcon.color.red(), dlg.activeWidgetIcon.color.green(), dlg.activeWidgetIcon.color.blue()) 
     
    751737                    line.showSignalNames = show 
    752738                    line.updateTooltip() 
    753  
     739                 
    754740            #self.output.catchException(self.settings["catchException"]) 
    755741            #self.output.catchOutput(self.settings["catchOutput"]) 
     
    766752 
    767753            # save tab order settings 
    768             newTabList = [] 
    769             for i in range(dlg.tabOrderList.count()): 
    770                 newTabList.append(str(dlg.tabOrderList.text(i))) 
     754            newTabList = [str(dlg.tabOrderList.item(i).text()) for i in range(dlg.tabOrderList.count())] 
    771755            if newTabList != oldTabList: 
    772756                self.settings["WidgetTabs"] = newTabList 
     
    776760    def setStatusBarEvent(self, text): 
    777761        if text == "" or text == None: 
    778             self.statusBar.message("") 
     762            self.statusBar.showMessage("") 
    779763            return 
    780764        elif text == "\n": return 
     
    784768        text = text.replace("<i>", ""); text = text.replace("</i>", "") 
    785769        text = text.replace("<br>", ""); text = text.replace("&nbsp", "") 
    786         self.statusBar.message(QString("Last event: " + str(text))) 
    787  
     770        self.statusBar.showMessage("Last event: " + str(text)) 
     771         
    788772    ####################### 
    789773    # SETTINGS 
    790774    ####################### 
    791775 
    792     # Loads settings from the widget's .ini file 
     776    # Loads settings from the widget's .ini file     
    793777    def loadSettings(self): 
    794         filename = os.path.join(self.outputDir, "orngCanvas.ini") 
     778        filename = os.path.join(self.canvasSettingsDir, "orngCanvas.ini") 
    795779        if os.path.exists(filename): 
    796780            file = open(filename, "rb") 
     
    807791        self.settings.setdefault("saveWidgetsPosition", 0) 
    808792##        self.settings.setdefault("autoLoadSchemasOnStart", 0) 
    809  
     793         
    810794        self.settings.setdefault("widgetSelectedColor", (0, 255, 0)) 
    811795        self.settings.setdefault("widgetActiveColor", (0,0,255)) 
     
    815799        #if not self.settings.has_key("catchOutput"): self.settings["catchOutput"] = 1 
    816800 
    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) 
     801        self.settings.setdefault("saveSchemaDir", self.canvasSettingsDir) 
     802        self.settings.setdefault("saveApplicationDir", self.canvasSettingsDir) 
    823803        self.settings.setdefault("showSignalNames", 1) 
    824804        self.settings.setdefault("useContexts", 1) 
     
    826806        self.settings.setdefault("canvasWidth", 700) 
    827807        self.settings.setdefault("canvasHeight", 600) 
    828  
     808         
    829809        self.settings.setdefault("focusOnCatchException", 1) 
    830810        self.settings.setdefault("focusOnCatchOutput" , 0) 
     
    840820        self.settings.setdefault("ocError", 1) 
    841821        self.settings.setdefault("owError", 1) 
    842  
     822                 
    843823 
    844824    # Saves settings to this widget's .ini file 
    845825    def saveSettings(self): 
    846         filename = os.path.join(self.outputDir, "orngCanvas.ini") 
     826        filename = os.path.join(self.canvasSettingsDir, "orngCanvas.ini") 
    847827        file=open(filename, "wb") 
    848828        cPickle.dump(self.settings, file) 
     
    864844            ce.accept() 
    865845            QMainWindow.closeEvent(self, ce) 
    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  
     846        
    877847    def enableSave(self, enable): 
    878848        self.toolSave.setEnabled(enable) 
    879         self.menuFile.setItemEnabled(self.menuSaveID, enable) 
    880         self.menuFile.setItemEnabled(self.menuSaveAsID, 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         
    881857 
    882858class MyStatusBar(QStatusBar): 
    883     def __init__(self, parent, name = ""): 
    884         QStatusBar.__init__(self, parent, name) 
     859    def __init__(self, parent): 
     860        QStatusBar.__init__(self, parent) 
    885861        self.parentWidget = parent 
    886862 
     
    937913 
    938914app = QApplication(sys.argv) 
    939 dlg = OrangeCanvasDlg(None, "", Qt.WDestructiveClose) 
    940 app.setMainWidget(dlg) 
     915dlg = OrangeCanvasDlg(None) 
    941916dlg.show() 
    942917for arg in sys.argv[1:]: 
    943918    if arg == "-reload": 
    944919        dlg.menuItemOpenLastSchema() 
    945 app.exec_loop() 
     920sys.exit(app.exec_()) 
  • orange/OrangeCanvas/orngCanvasItems.py

    r3788 r3792  
    33#    two main objects that are shown in the canvas; Line and Widget 
    44# 
    5 from qt import * 
    6 from qtcanvas import * 
     5from PyQt4.QtCore import * 
     6from PyQt4.QtGui import * 
    77import os, sys 
    88ERROR = 0 
    99WARNING = 1 
    1010 
    11 class 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  
    23 class TempCanvasLine(QCanvasLine): 
    24     def __init__(self, canvasDlg, *args): 
    25         apply(QCanvasLine.__init__,(self,)+ args) 
    26         self.setZ(-10) 
     11widgetWidth = 68 
     12widgetHeight = 68 
     13 
     14 
     15class TempCanvasLine(QGraphicsLineItem): 
     16    def __init__(self, canvasDlg, canvas): 
     17        QGraphicsLineItem.__init__(self, None, canvas) 
     18        self.setZValue(-10) 
    2719        self.canvasDlg = canvasDlg 
    2820 
    2921    def remove(self): 
    3022        self.hide() 
    31         self.setCanvas(None) 
    3223 
    3324    # draw the line 
     
    4435        pass 
    4536 
    46     def removeTooltip(self): 
    47         pass 
    48  
    49     def updateTooltip(self): 
    50         pass 
    5137 
    5238    # redraw the line 
    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 
     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()))) 
    6244 
    6345# ####################################### 
    6446# # CANVAS LINE 
    6547# ####################################### 
    66 class CanvasLine(QCanvasLine): 
     48class CanvasLine(QGraphicsLineItem): 
    6749    def __init__(self, signalManager, canvasDlg, view, outWidget, inWidget, canvas, *args): 
    68         apply(QCanvasLine.__init__,(self,canvas)+ args) 
     50        QGraphicsLineItem.__init__(self, None, canvas) 
    6951        self.signalManager = signalManager 
    7052        self.canvasDlg = canvasDlg 
     
    7254        self.inWidget = inWidget 
    7355        self.view = view 
    74         self.setZ(-10) 
     56        self.setZValue(-10) 
    7557        self.colors = [] 
     58        self.caption = "" 
    7659        outPoint = outWidget.getRightEdgePoint() 
    7760        inPoint = inWidget.getLeftEdgePoint() 
    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)) 
     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 
    8865 
    8966    def remove(self): 
    9067        self.hide() 
    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)) 
     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)) 
    9670 
    9771    def getEnabled(self): 
     
    11185        return signals 
    11286 
    113     def drawShape(self, painter): 
    114         (startX, startY) = (self.startPoint().x(), self.startPoint().y()) 
    115         (endX, endY)  = (self.endPoint().x(), self.endPoint().y()) 
     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() 
    11691 
    11792        if self.getEnabled(): lineStyle = Qt.SolidLine 
     
    11994 
    12095        painter.setPen(QPen(self.canvasDlg.lineColor, 5 , lineStyle)) 
    121         painter.drawLine(QPoint(startX, startY), QPoint(endX, endY)) 
     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) 
    122103 
    123104    # set the line positions based on the position of input and output widgets 
     
    127108        x2 = self.inWidget.x() + 2 
    128109        y2 = self.inWidget.y() + 26 
    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) 
     110        self.setLine(x1, y1, x2, y2) 
    131111        self.updateTooltip() 
    132112 
    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  
    144113    def updateTooltip(self): 
    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>" 
     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>" 
    153117        string = string[:-4] 
    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) 
     118        self.setToolTip(string) 
    167119 
    168120        # print the text with the signals 
    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  
    183 class CanvasWidgetState(QCanvasRectangle): 
     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 
     126class CanvasWidgetState(QGraphicsRectItem): 
    184127    def __init__(self, parent, canvas, view, widgetIcons): 
    185         QCanvasRectangle.__init__(self, canvas) 
     128        QGraphicsRectItem.__init__(self, None, canvas) 
    186129        self.widgetIcons = widgetIcons 
    187130        self.view = view 
    188131        self.parent = parent 
    189         self.setSize(100, 30) 
    190132 
    191133        self.infoTexts = [] 
     
    246188 
    247189 
    248  
    249190# ####################################### 
    250191# # CANVAS WIDGET 
    251192# ####################################### 
    252 class CanvasWidget(QCanvasRectangle): 
     193class CanvasWidget(QGraphicsRectItem): 
    253194    def __init__(self, signalManager, canvas, view, widget, defaultPic, canvasDlg): 
    254         apply(QCanvasRectangle.__init__, (self,canvas)) 
     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) 
    255209        self.signalManager = signalManager 
    256210        self.widget = widget 
     
    264218            self.imageEdge = QPixmap(os.path.join(canvasDlg.picsDir,"WidgetEdge.png")) 
    265219 
    266         self.setSize(68, 68) 
     220        self.setRect(0,0, widgetWidth, widgetHeight) 
    267221        self.selected = False 
    268222        self.invalidPosition = False    # is the widget positioned over other widgets 
     
    270224        self.outLines = []              # list of connected lines on output 
    271225        self.caption = widget.name 
     226        self.progressBarShown = 0 
    272227        self.xPos = 0 
    273228        self.yPos = 0 
     
    281236        self.widgetStateRect.show() 
    282237 
    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  
    298238        # do we want to restore last position and size of the widget 
    299239        if self.canvasDlg.settings["saveWidgetsPosition"]: 
     
    310250            self.instance.setWidgetIcon(defaultPic) 
    311251 
    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  
    330252    # read the settings if we want to show icons for info, warning, error 
    331253    def updateSettings(self): 
     
    339261        self.widgetStateRect.updateState(self.instance.widgetState) 
    340262 
    341  
    342263    # get the list of connected signal names 
    343264    def getInConnectedSignalNames(self): 
     
    357278 
    358279    def remove(self): 
    359         self.progressBarRect.hide() 
    360         self.progressRect.hide() 
    361         self.progressText.hide() 
    362280        self.widgetStateRect.hide() 
    363         self.progressBarRect.setCanvas(None) 
    364         self.progressRect.setCanvas(None) 
    365         self.progressText.setCanvas(None) 
    366         self.widgetStateRect.setCanvas(None) 
    367  
    368281        self.hide() 
    369         self.setCanvas(None)    # hide the widget 
    370282 
    371283        # save settings 
     
    373285            try:    self.instance.saveSettings() 
    374286            except: print "Unable to successfully save settings for %s widget" % (self.instance.title) 
    375             self.instance.hide() 
     287            self.instance.close() 
    376288            del self.instance 
    377         self.removeTooltip() 
    378         self.text.hide() 
    379289 
    380290    def savePosition(self): 
     
    385295        self.setCoords(self.oldXPos, self.oldYPos) 
    386296 
    387     def updateTextCoords(self): 
    388         self.text.move(self.xPos + 34, self.yPos + 60) 
    389  
    390297    def updateText(self, text): 
    391298        self.caption = str(text) 
    392         self.text.setText(text) 
    393299 
    394300    def updateLinePosition(self): 
     
    396302        for line in self.outLines: line.updateLinePos() 
    397303 
    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  
    403304    def setSelected(self, selected): 
    404305        self.selected = selected 
    405         self.repaintWidget() 
    406  
     306        #self.repaintWidget() 
    407307 
    408308    # set coordinates of the widget 
     
    410310        if x > 0 and x < self.canvas.width():  self.xPos = x 
    411311        if y > 0 and y < self.canvas.height() - 60: self.yPos = y 
    412         self.move(self.xPos, self.yPos) 
    413         self.updateTextCoords() 
     312        self.setPos(self.xPos, self.yPos) 
    414313        self.updateLinePosition() 
    415         self.updateProgressBarPosition() 
    416314 
    417315    def move(self, x, y): 
    418         QCanvasRectangle.move(self, x, y) 
    419         self.widgetStateRect.updateWidgetState() 
    420  
     316        QGraphicsRectItem.setPos(self, x, y) 
     317        self.widgetStateRect.updatePosition() 
    421318 
    422319    # move existing coorinates by dx, dy 
     
    424321        if self.xPos + dx > 0 and self.xPos + dx < self.canvas.width(): self.xPos = self.xPos + dx 
    425322        if self.yPos + dy > 0 and self.yPos + dy < self.canvas.height() - 60: self.yPos = self.yPos + dy 
    426         self.move(self.xPos, self.yPos) 
    427         self.updateTextCoords() 
     323        self.setPos(self.xPos, self.yPos) 
    428324        self.updateLinePosition() 
    429325 
     
    438334        if self.widget.getInputs() == []: return False 
    439335 
    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 
     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 
    443339        else: return False 
    444340 
     
    447343        if self.widget.getOutputs() == []: return False 
    448344 
    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 
     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 
    452348        else: return False 
    453349 
     
    469365 
    470366    # draw the widget 
    471     def drawShape(self, painter): 
     367    def paint(self, painter, option, widget = None): 
     368        painter.resetMatrix() 
    472369        if self.isProcessing: 
    473370            painter.setPen(QPen(self.canvasDlg.widgetActiveColor)) 
     
    476373            painter.drawRect(self.x()+7, self.y(), 54, 54) 
    477374        elif self.selected: 
    478             if self.invalidPosition: color = self.red 
     375            if self.invalidPosition: color = Qt.red 
    479376            else:                    color = self.canvasDlg.widgetSelectedColor 
    480377            painter.setPen(QPen(color)) 
    481378            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) 
    484379            painter.drawRect(self.x()+7, self.y(), 54, 54) 
    485  
    486380 
    487381        painter.drawPixmap(self.x()+2+8, self.y()+3, self.image) 
     
    489383        if self.imageEdge != None: 
    490384            if self.widget.getInputs() != []:    painter.drawPixmap(self.x(), self.y() + 18, self.imageEdge) 
    491             if self.widget.getOutputs() != []:   painter.drawPixmap(self.x()+60, self.y() + 18, self.imageEdge) 
     385            if self.widget.getOutputs() != []:   painter.drawPixmap(self.x()+widgetWidth-8, self.y() + 18, self.imageEdge) 
    492386        else: 
    493387            painter.setBrush(QBrush(self.blue)) 
    494388            if self.widget.getInputs() != []:    painter.drawRect(self.x(), self.y() + 18, 8, 16) 
    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     """ 
     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 
    517405 
    518406    def addOutLine(self, line): 
     
    545433            #line.repaintLine(self.view) 
    546434 
    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) 
     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) 
    556444 
    557445    def updateTooltip(self): 
    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>" 
     446        string = "<nobr><b>" + self.caption + "</b></nobr><hr>Inputs:<br>" 
     447 
     448        if self.widget.getInputs() == []: string += "&nbsp; &nbsp; None<br>" 
    562449        else: 
    563450            for signal in self.widget.getInputs(): 
    564451                widgets = self.signalManager.getLinkWidgetsIn(self.instance, signal.name) 
    565452                if len(widgets) > 0: 
    566                     string += "<nobr> &nbsp &nbsp - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (from " 
     453                    string += "<nobr> &nbsp; &nbsp; - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (from " 
    567454                    for i in range(len(widgets)-1): 
    568455                        string += self.view.doc.getWidgetCaption(widgets[i]) + ", " 
    569456                    string += self.view.doc.getWidgetCaption(widgets[-1]) + ")</nobr><br>" 
    570457                else: 
    571                     string += "<nobr> &nbsp &nbsp - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
    572  
     458                    string += "<nobr> &nbsp; &nbsp; - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
     459 
     460        string = string[:-4] 
    573461        string += "<hr>Outputs:<br>" 
    574         if self.widget.getOutputs() == []: string += "&nbsp &nbsp None<br>" 
     462        if self.widget.getOutputs() == []: string += "&nbsp; &nbsp; None<br>" 
    575463        else: 
    576464            for signal in self.widget.getOutputs(): 
    577465                widgets = self.signalManager.getLinkWidgetsOut(self.instance, signal.name) 
    578466                if len(widgets) > 0: 
    579                     string += "<nobr> &nbsp &nbsp - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (to " 
     467                    string += "<nobr> &nbsp; &nbsp; - <b>" + self.canvasDlg.getChannelName(signal.name) + "</b> (to " 
    580468                    for i in range(len(widgets)-1): 
    581469                        string += self.view.doc.getWidgetCaption(widgets[i]) + ", " 
    582470                    string += self.view.doc.getWidgetCaption(widgets[-1]) + ")</nobr><br>" 
    583471                else: 
    584                     string += "<nobr> &nbsp &nbsp - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
     472                    string += "<nobr> &nbsp; &nbsp; - " + self.canvasDlg.getChannelName(signal.name) + "</nobr><br>" 
    585473        string = string[:-4] 
    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  
     474        self.setToolTip(string) 
    599475 
    600476    def showProgressBar(self): 
    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() 
     477        self.progressBarShown = 1 
     478        self.progressBarValue = 0 
    606479        self.canvas.update() 
    607480 
    608481    def hideProgressBar(self): 
    609         self.progressBarRect.hide() 
    610         self.progressRect.hide() 
    611         self.progressText.hide() 
     482        self.progressBarShown = 0 
    612483        self.canvas.update() 
    613484 
    614485    def setProgressBarValue(self, 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)) + " %") 
     486        self.progressBarValue = value 
    618487        self.canvas.update() 
    619488 
     
    621490        self.isProcessing = value 
    622491        self.canvas.update() 
    623         self.repaintWidget() 
    624  
    625     def rtti(self): 
    626         return 1001 
    627  
     492##        self.repaintWidget() 
     493 
  • orange/OrangeCanvas/orngDlgs.py

    r3667 r3792  
    33#    signal dialog, canvas options dialog 
    44 
    5 from qt import * 
    6 from qtcanvas import * 
    7 from copy import copy 
    8 from string import strip 
    9 import sys 
    10 from orngCanvasItems import * 
    11 from qttable import * 
    12  
    13 def indentedCheckBox(text, parent): 
    14     b = QHBox(parent) 
    15     sep = QWidget(b) 
    16     sep.setFixedSize(10, 10) 
    17     return QCheckBox(text, b) 
    18  
    19  
    20 class 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) 
     5from PyQt4.QtCore import * 
     6from PyQt4.QtGui import * 
     7#from orngCanvasItems import * 
     8import orngGui 
    339 
    3410# this class is needed by signalDialog to show widgets and lines 
    35 class SignalCanvasView(QCanvasView): 
     11class SignalCanvasView(QGraphicsView): 
    3612    def __init__(self, dlg, *args): 
    37         apply(QCanvasView.__init__,(self,) + args) 
     13        apply(QGraphicsView.__init__,(self,) + args) 
    3814        self.dlg = dlg 
    3915        self.bMouseDown = False 
     
    4824        self.inBoxes = [] 
    4925        self.texts = [] 
    50  
    51         #self.connect(self, SIGNAL("contentsMoving(int,int)"), self.contentsMoving) 
     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) 
    5231 
    5332    def addSignalList(self, outName, inName, outputs, inputs, outIconName, inIconName): 
    54         items = self.canvas().allItems() 
    55         for item in items: item.hide() 
    56         self.lines = []; self.outBoxes = []; self.inBoxes = []; self.texts = [] 
     33        for item in self.scene().items(): item.hide() 
     34        self.lines = [] 
     35        self.outBoxes = [] 
     36        self.inBoxes = [] 
     37        self.texts = [] 
    5738        xSpaceBetweenWidgets = 100  # space between widgets 
    5839        xWidgetOff = 10     # offset for widget position 
     
    8465        # show boxes 
    8566        brush = QBrush(QColor(60,150,255)) 
    86         self.outWidget = QCanvasRectangle(xWidgetOff, yWidgetOffTop, width, height, self.dlg.canvas) 
     67        self.outWidget = QGraphicsRectItem(xWidgetOff, yWidgetOffTop, width, height, None, self.dlg.canvas) 
    8768        self.outWidget.setBrush(brush) 
    88         self.outWidget.setZ(-100) 
    89         self.outWidget.show() 
    90  
    91         self.inWidget = QCanvasRectangle(xWidgetOff + width + xSpaceBetweenWidgets, yWidgetOffTop, width, height, self.dlg.canvas) 
     69        self.outWidget.setZValue(-100) 
     70##        self.outWidget.show() 
     71 
     72        self.inWidget = QGraphicsRectItem(xWidgetOff + width + xSpaceBetweenWidgets, yWidgetOffTop, width, height, None, self.dlg.canvas) 
    9273        self.inWidget.setBrush(brush) 
    93         self.inWidget.setZ(-100) 
    94         self.inWidget.show() 
     74        self.inWidget.setZValue(-100) 
     75##        self.inWidget.show() 
    9576 
    9677        # if icons -> show them 
    9778        if outIconName: 
    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() 
     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() 
    10182        if inIconName : 
    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() 
     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) 
    10585 
    10686        # show signal boxes and text labels 
     
    10989        for i in range(len(outputs)): 
    11090            y = yWidgetOffTop + ((i+1)*signalSpace)/float(len(outputs)+1) 
    111             box = QCanvasRectangle(xWidgetOff + width, y - ySignalSize/2.0, xSignalSize, ySignalSize, self.dlg.canvas) 
     91            box = QGraphicsRectItem(xWidgetOff + width, y - ySignalSize/2.0, xSignalSize, ySignalSize, None, self.dlg.canvas) 
    11292            box.setBrush(QBrush(QColor(0,0,255))) 
    113             box.show() 
     93            box.setZValue(200) 
    11494            self.outBoxes.append((outputs[i].name, box)) 
    11595 
    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)) 
     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)) 
    11898 
    11999        for i in range(len(inputs)): 
    120100            y = yWidgetOffTop + ((i+1)*signalSpace)/float(len(inputs)+1) 
    121             box = QCanvasRectangle(xWidgetOff + width + xSpaceBetweenWidgets - xSignalSize, y - ySignalSize/2.0, xSignalSize, ySignalSize, self.dlg.canvas) 
     101            box = QGraphicsRectItem(xWidgetOff + width + xSpaceBetweenWidgets - xSignalSize, y - ySignalSize/2.0, xSignalSize, ySignalSize, None, self.dlg.canvas) 
    122102            box.setBrush(QBrush(QColor(0,0,255))) 
    123             box.show() 
     103            box.setZValue(200) 
    124104            self.inBoxes.append((inputs[i].name, box)) 
    125105 
    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)) 
     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)) 
    131111 
    132112        return (2*xWidgetOff + 2*width + xSpaceBetweenWidgets, yWidgetOffTop + height + yWidgetOffBottom) 
    133113 
    134114    def getTextWidth(self, text, bold = 0): 
    135         temp = QCanvasText(text, self.dlg.canvas) 
     115        temp = QGraphicsSimpleTextItem(text, None, self.dlg.canvas) 
    136116        if bold: 
    137117            font = temp.font() 
    138118            font.setBold(1) 
    139119            temp.setFont(font) 
    140         rect = temp.boundingRect() 
    141         return rect.width() 
     120        temp.hide() 
     121        return temp.boundingRect().width() 
    142122 
    143123    # ################################################################### 
    144124    # mouse button was pressed 
    145     def contentsMousePressEvent(self, ev): 
     125    def mousePressEvent(self, ev): 
    146126        self.bMouseDown = 1 
    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: 
     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]: 
    152130            self.bLineDragging = 1 
    153             self.tempLine = QCanvasLine(self.dlg.canvas) 
    154             self.tempLine.setPoints(ev.pos().x(), ev.pos().y(), ev.pos().x(), ev.pos().y()) 
     131            self.tempLine = QGraphicsLineItem(None, self.dlg.canvas) 
     132            self.tempLine.setLine(point.x(), point.y(), point.x(), point.y()) 
    155133            self.tempLine.setPen(QPen(QColor(0,255,0), 1)) 
    156             self.tempLine.setZ(-120) 
    157             self.tempLine.show() 
     134            self.tempLine.setZValue(-300) 
    158135            return 
    159  
    160         line = self.findItem(activeItems, QCanvasLine) 
    161         if line: 
    162             for (Line, outName, inName, outBox, inBox) in self.lines: 
    163                 if Line == line: 
     136        elif type(activeItem) == QGraphicsLineItem: 
     137            for (line, outName, inName, outBox, inBox) in self.lines: 
     138                if line == activeItem: 
    164139                    self.dlg.removeLink(outName, inName) 
    165140                    return 
     
    167142    # ################################################################### 
    168143    # mouse button was released ######################################### 
    169     def contentsMouseMoveEvent(self, ev): 
     144    def mouseMoveEvent(self, ev): 
    170145        if self.bLineDragging: 
    171             start = self.tempLine.startPoint() 
    172             self.tempLine.setPoints(start.x(), start.y(), ev.pos().x(), ev.pos().y()) 
    173             self.canvas().update() 
     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() 
    174150 
    175151    # ################################################################### 
    176152    # mouse button was released ######################################### 
    177     def contentsMouseReleaseEvent(self, ev): 
     153    def mouseReleaseEvent(self, ev): 
    178154        if self.bLineDragging: 
    179155            self.bLineDragging = 0 
    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 
     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 
    188162                outName = None; inName = None 
    189163                for (name, box) in self.outBoxes: 
     
    191165                for (name, box) in self.inBoxes: 
    192166                    if box == inBox: inName = name 
    193                 if outName != None and inName != None: self.dlg.addLink(outName, inName) 
     167                if outName != None and inName != None: 
     168                    self.dlg.addLink(outName, inName) 
    194169 
    195170            self.tempLine.hide() 
    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 
     171            self.scene().update() 
     172 
    204173 
    205174    def addLink(self, outName, inName): 
     
    212181            print "error adding link. Data = ", outName, inName 
    213182            return 
    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) 
     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) 
    216187        line.setPen(QPen(QColor(0,255,0), 6)) 
    217         line.setZ(-120) 
    218         line.show() 
    219         self.canvas().update() 
     188        line.setZValue(100) 
     189##        line.show() 
     190        self.scene().update() 
    220191        self.lines.append((line, outName, inName, outBox, inBox)) 
    221192 
     
    225196            if outN == outName and inN == inName: 
    226197                line.hide() 
    227                 line.setCanvas(None) 
    228198                self.lines.remove((line, outN, inN, outBox, inBox)) 
    229                 self.canvas().update() 
     199                self.scene().update() 
    230200                return 
    231201 
     
    238208        apply(QDialog.__init__,(self,) + args) 
    239209        self.canvasDlg = canvasDlg 
    240         self.topLayout = QVBoxLayout( self, 10 ) 
     210 
    241211        self.signals = [] 
    242212        self._links = [] 
     
    244214 
    245215        # GUI 
    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) 
     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) 
    259221        self.canvasView = SignalCanvasView(self, self.canvas, self.canvasGroup) 
    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) 
     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) 
    281230        self.buttonOk.setAutoDefault(1) 
    282231        self.buttonOk.setDefault(1) 
    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()')) 
     232        self.buttonCancel = orngGui.button(buttons, self, "&Cancel", callback = self.reject) 
    292233 
    293234    def clearAll(self): 
     
    299240        self.inWidget = inWidget 
    300241        (width, height) = self.canvasView.addSignalList(outWidget.caption, inWidget.caption, outWidget.widget.getOutputs(), inWidget.widget.getInputs(), outWidget.widget.getFullIconName(), inWidget.widget.getFullIconName()) 
    301         self.canvas.resize(width, height) 
    302         self.resize(width+55, height+90) 
     242        self.canvas.setSceneRect(0, 0, width, height) 
     243        self.resize(width+50, height+80) 
    303244 
    304245    def countCompatibleConnections(self, outputs, inputs, outInstance, inInstance, outType, inType): 
     
    324265                    betterOutSignal = outS 
    325266                    betterInSignal = inS 
    326  
    327267        return existsBetter, betterOutSignal, betterInSignal 
    328268 
     
    339279                    continue        #print "Unable to find signal type for signal %s. Check the definition of the widget." % (inS.name) 
    340280                if issubclass(outType, inType): 
    341                     possibleLinks.append((outS.name, inS.name)) 
     281                        possibleLinks.append((outS.name, inS.name)) 
    342282        return possibleLinks 
    343283 
     
    356296        outConnected = self.outWidget.getOutConnectedSignalNames() 
    357297 
    358         # input connections that can be simultaneously connected to multiple outputs are not to be considered as already connected  
     298        # input connections that can be simultaneously connected to multiple outputs are not to be considered as already connected 
    359299        for i in inConnected[::-1]: 
    360300            if not self.inWidget.instance.signalIsOnlySingleConnection(i): 
     
    377317 
    378318        if not all: return 0 
    379          
     319 
    380320        # try to find a link to any inputs that hasn't been previously connected 
    381321        self.allSignalsTaken = 1 
     
    391331        for pl in [pl1, pl2, pl3, pl4]: 
    392332            #if len(pl) > 1 and sum([i not in inConnected for (o,i) in pl]) > 1: # if we have more than one valid 
    393             if len(pl) > 1:     # if we have more than one valid  
     333            if len(pl) > 1:     # if we have more than one valid 
    394334                self.multiplePossibleConnections = 1 
    395335            if len(pl) > 0:     # when we find a first non-empty list we stop searching 
     
    429369 
    430370 
    431 class ColorIcon(QPushButton): 
     371class ColorIcon(QToolButton): 
    432372    def __init__(self, parent, color): 
    433         QPushButton.__init__(self, parent, "") 
     373        QToolButton.__init__(self, parent) 
    434374        self.color = color 
    435         self.parent = parent 
    436375        self.setMaximumSize(20,20) 
    437376        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 
    438390 
    439391    def drawButtonLabel(self, painter): 
     
    443395 
    444396    def showColorDialog(self): 
    445         color = QColorDialog.getColor(self.color, self.parent) 
     397        color = QColorDialog.getColor(self.color, self) 
    446398        if color.isValid(): 
    447399            self.color = color 
     400            self.updateColor() 
    448401            self.repaint() 
    449402 
     
    453406        apply(QDialog.__init__,(self,) + args) 
    454407        self.canvasDlg = canvasDlg 
    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") 
     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") 
    476421 
    477422        # ################################################################# 
    478423        # GENERAL TAB 
    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) 
     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") 
    493433 
    494434        validator = QIntValidator(self) 
    495435        validator.setRange(0,10000) 
    496436 
    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  
     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) 
    524458 
    525459        # ################################################################# 
    526460        # EXCEPTION TAB 
    527         exceptions = QVGroupBox("Exceptions", ExceptionsTab) 
     461        exceptions = orngGui.widgetBox(ExceptionsTab, "Exceptions") 
    528462        #self.catchExceptionCB = QCheckBox('Catch exceptions', exceptions) 
    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) 
     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") 
    533467        #self.catchOutputCB = QCheckBox('Catch system output', output) 
    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") 
     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) 
    557488 
    558489        # ################################################################# 
    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) 
     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) 
    579504 
    580505        # OK, Cancel buttons 
    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) 
     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) 
    591511 
    592512        self.topLayout.addWidget(self.tabs) 
    593513        self.topLayout.addWidget(hbox) 
    594514 
    595         self.connect(self.okButton, SIGNAL("clicked()"), self.accept) 
    596         self.connect(self.cancelButton, SIGNAL("clicked()"), self.reject) 
    597515 
    598516    # move selected widget category up 
    599517    def moveUp(self): 
    600518        for i in range(1, self.tabOrderList.count()): 
    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) 
     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) 
    606524 
    607525    # move selected widget category down 
    608526    def moveDown(self): 
    609527        for i in range(self.tabOrderList.count()-2,-1,-1): 
    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() 
     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): 
    618535        self.upButton.setEnabled(itemIndex > 0) 
    619536        self.downButton.setEnabled(itemIndex < self.tabOrderList.count()-1) 
    620         self.removeButton.setEnabled(not self.tabs.tabDict[str(self.tabOrderList.currentText())].builtIn) 
     537        self.removeButton.setEnabled(not self.canvasDlg.tabs.tabDict[str(self.tabOrderList.item(self.tabOrderList.currentRow()).text())].builtIn) 
    621538 
    622539    def removeCategory(self): 
    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: 
     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: 
    625542            self.removeTabs.append(curCat) 
    626             self.tabOrderList.removeItem(self.tabOrderList.currentItem()) 
    627  
    628  
    629 ########## 
    630 ### Widget registry editor 
    631 #### 
     543            self.tabOrderList.takeItem(self.tabOrderList.currentRow()) 
     544 
    632545 
    633546class KeyEdit(QLineEdit): 
     
    654567            return 
    655568 
    656         pressed = "-".join(filter(None, [e.state() & x and y for x, y in [(e.ControlButton, "Ctrl"), (e.AltButton, "Alt")]]) + [chr(e.key())]) 
     569        pressed = "-".join(filter(None, [e.modifiers() & x and y for x, y in [(Qt.ControlModifier, "Ctrl"), (Qt.AltModifier, "Alt")]]) + [chr(e.key())]) 
    657570 
    658571        assigned = self.invInvDict.get(pressed, None) 
     
    660573            return 
    661574 
    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 
     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 
    668577 
    669578        self.setText(pressed) 
     
    674583            del self.invdict[assigned.widget] 
    675584 
    676  
     585# widget shortcuts dialog 
    677586class WidgetRegistryDlg(QDialog): 
    678587    def __init__(self, canvasDlg, *args): 
     
    681590        apply(QDialog.__init__,(self,) + args) 
    682591        self.canvasDlg = canvasDlg 
    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) 
     592        self.setWindowTitle("Widget Shortcuts") 
     593        self.setLayout(QVBoxLayout()) 
     594        self.layout().setSpacing(10) 
     595        self.resize(700,500) 
    689596 
    690597        self.invDict = dict([(y, x) for x, y in canvasDlg.widgetShortcuts.items()]) 
    691598        invInvDict = {} 
    692599 
    693         self.tabs = QTabWidget(self, 'tabWidget') 
     600        self.tabs = QTabWidget(self) 
    694601        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 
    695606            wtab = QWidget(self.tabs) 
    696             self.tabs.insertTab(wtab, canvasDlg.tabs.tabLabel(tab)) 
     607            scrollArea.setWidget(wtab) 
    697608 
    698609            widgets = filter(lambda x:x.__class__ == orngTabs.WidgetButton, tab.widgets) 
    699610            rows = (len(widgets)+2) / 3 
    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) 
     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) 
    706616 
    707617            for i, w in enumerate(widgets): 
    708                 y, x = 1 + 2 * (i % rows), 3 * (i/rows) 
    709                 pixmap = w.iconSet().pixmap(QIconSet.Large, QIconSet.Normal) 
     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) 
    710627                label = QLabel(wtab) 
    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) 
     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) 
    721637                key = self.invDict.get(w, "<none>") 
    722                 le = KeyEdit(shb, key, self.invDict, w, invInvDict) 
     638                le = KeyEdit(optionsw, key, self.invDict, w, invInvDict) 
     639                optionsw.layout().addWidget(le) 
    723640                invInvDict[key] = le 
    724641                le.setFixedWidth(60) 
    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) 
     642 
     643            wtab.resize(wtab.sizeHint()) 
    731644 
    732645        # OK, Cancel buttons 
    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) 
     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) 
    743650        self.okButton.setDefault(True) 
    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) 
     651 
     652        self.layout().addWidget(self.tabs) 
     653        self.layout().addWidget(hbox) 
    752654 
    753655 
     
    759661        apply(QDialog.__init__,(self,) + args) 
    760662        self.canvasDlg = canvasDlg 
    761         self.topLayout = QVBoxLayout( self, 10 ) 
     663        self.topLayout = QVBoxLayout(self) 
     664        self.topLayout.setSpacing(10) 
    762665        self.grid = QGridLayout( 5, 3 ) 
    763666        self.topLayout.addLayout( self.grid, 10 ) 
     
    766669        groupBox.setTitle("Channel settings") 
    767670        self.grid.addWidget(groupBox, 1,1) 
    768         topLayout2 = QVBoxLayout(groupBox, 10 ) 
    769671        propGrid = QGridLayout(groupBox, 4, 2 ) 
    770         topLayout2.addLayout(propGrid, 10) 
    771672 
    772673        cap0 = QLabel("Symbolic channel names:", self) 
     
    794695        removeButton = QPushButton("Remove selected name", self) 
    795696        closeButton = QPushButton("Close",self) 
    796         self.channelList = QListBox( self, "channels" ) 
     697        self.channelList = QListWidget(self) 
    797698        self.channelList.setMinimumHeight(200) 
    798699        self.connect( self.channelList, SIGNAL("highlighted(int)"), self.listItemChanged ) 
     
    843744 
    844745    def listItemChanged(self, index): 
    845         name = str(self.channelList.text(index)) 
     746        name = str(self.channelList.item(index).text()) 
    846747        value = self.channels[name] 
    847748        items = value.split("::") 
     
    864765        index = self.channelList.currentItem() 
    865766        if index != -1: 
    866             name = str(self.channelList.text(index)) 
     767            name = str(self.channelList.item(index).text()) 
    867768            self.channels[name] = str(self.editFullName.text()) + "::" + str(self.editPriority.currentText()) + "::" + str(self.editColor.currentText()) 
    868769 
    869770    def addNewSignal(self): 
    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") 
     771        (Qstring,ok) = QInputDialog.getText(self, "Qt Add New Channel Name", "Enter new symbolic channel name") 
    874772        string = str(Qstring) 
    875773        if ok: 
     
    883781    def selectItem(self, string): 
    884782        for i in range(self.channelList.count()): 
    885             temp = str(self.channelList.text(i)) 
     783            temp = str(self.channelList.item(i).text()) 
    886784            if temp == string: 
    887785                self.channelList.setCurrentItem(i) 
     
    892790        if index != -1: 
    893791            tempDict = {} 
    894             symbName = str(self.channelList.text(index)) 
     792            symbName = str(self.channelList.item(index).text()) 
    895793 
    896794            for key in self.channels.keys(): 
    897795                if key != symbName: 
    898796                    tempDict[key] = self.channels[key] 
    899             self.channels = copy(tempDict) 
     797            self.channels = dict(tempDict) 
    900798 
    901799        self.reloadList() 
     
    910808    def __init__(self, *args): 
    911809        apply(QDialog.__init__,(self,) + args) 
    912         if (int(qVersion()[0]) >= 3): 
    913             self.setCaption("Set Widget Order") 
     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) 
     830 
     831    def accept(self): 
     832        self.shownWidgetList = [str(self.tabOrderList.item(i).text()) for i in range(self.tabOrderList.count())] 
     833        QDialog.accept(self) 
     834 
     835    def insertSeparator(self): 
     836        curr = self.tabOrderList.indexFromItem(self.tabOrderList.currentItem()).row() 
     837        self.insertWidgetName("[Separator]", curr) 
     838 
     839    def insertWidgetName(self, name, index = -1): 
     840        if index == -1: 
     841            self.tabOrderList.addItem(name) 
    914842        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) 
    961  
    962     def accept(self): 
    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)) 
    970         QDialog.accept(self) 
    971  
    972  
    973     def insertSeparator(self): 
    974         curr = max(0, self.findSelected()) 
    975         self.insertWidgetName("[Separator]", curr) 
    976  
    977  
    978     def insertWidgetName(self, name, index = -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 
     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) 
    1002863 
    1003864 
    1004865if __name__=="__main__": 
     866    import sys 
    1005867    app = QApplication(sys.argv) 
    1006     dlg = CanvasOptionsDlg(app) 
    1007     app.setMainWidget(dlg) 
     868    dlg = saveApplicationDlg(None) 
    1008869    dlg.show() 
    1009     app.exec_loop() 
    1010  
     870    sys.exit(app.exec_()) 
     871 
  • orange/OrangeCanvas/orngDoc.py

    r3721 r3792  
    33#    document class - main operations (save, load, ...) 
    44# 
     5from PyQt4.QtCore import * 
     6from PyQt4.QtGui import * 
    57import sys, os, os.path, string, traceback 
    6 from qt import * 
    7 from 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) 
    2021        self.canSave = 0 
    2122        self.resize(700,500) 
    2223        self.showNormal() 
    23         self.setCaption("Schema " + str(self.canvasDlg.iDocIndex)) 
     24        self.setWindowTitle("Schema " + str(self.canvasDlg.iDocIndex)) 
    2425        self.canvasDlg.iDocIndex = self.canvasDlg.iDocIndex + 1 
     26        self.ctrlPressed = 0 
    2527 
    2628        self.enableSave(False) 
    27         self.setIcon(QPixmap(canvasDlg.file_new)) 
     29        self.setWindowIcon(QIcon(canvasDlg.file_new)) 
    2830        self.lines = []                         # list of orngCanvasItems.CanvasLine items 
    2931        self.widgets = []                       # list of orngCanvasItems.CanvasWidget items 
    3032        self.signalManager = SignalManager()    # signal manager to correctly process signals 
    31         self.ctrlPressed = 0 
    3233 
    3334        self.documentpath = canvasDlg.settings["saveSchemaDir"] 
    34         self.documentname = str(self.caption()) 
     35        self.documentname = str(self.windowTitle()) 
    3536        self.applicationpath = canvasDlg.settings["saveApplicationDir"] 
    36         self.applicationname = str(self.caption()) 
     37        self.applicationname = str(self.windowTitle()) 
    3738        self.documentnameValid = False 
    3839        self.loadedSettingsDict = {} 
    39         self.canvas = QCanvas(2000,2000) 
     40        self.canvas = QGraphicsScene(0,0,2000,2000) 
    4041        self.canvasView = orngView.SchemaView(self, self.canvas, self) 
    4142        self.setCentralWidget(self.canvasView) 
     
    5152        self.synchronizeContexts() 
    5253        if self.canvasDlg.settings["autoSaveSchemasOnClose"] and self.widgets != []: 
    53             self.save(os.path.join(self.canvasDlg.outputDir, "_lastSchema.ows")) 
     54            self.save(os.path.join(self.canvasDlg.canvasSettingsDir, "_lastSchema.ows")) 
    5455 
    5556        if not self.canSave or self.canvasDlg.settings["dontAskBeforeClose"]: 
     
    6263 
    6364        #QMainWindow.closeEvent(self, ce) 
    64         res = QMessageBox.information(self,'Orange Canvas','Do you want to save changes made to schema?','&Yes','&No','&Cancel',0) 
    65         if res == 0: 
     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: 
    6667            self.saveDocument() 
    6768            ce.accept() 
    6869            self.clear() 
    69         elif res == 1: 
     70        elif res == QMessageBox.No: 
    7071            self.clear() 
    7172            ce.accept() 
     
    9798 
    9899        if self.signalManager.existsPath(inWidget.instance, outWidget.instance): 
    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) 
     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) 
    103104        dialog.setOutInWidgets(outWidget, inWidget) 
    104105        connectStatus = dialog.addDefaultLinks() 
     
    111112 
    112113        if connectStatus == 0: 
    113             QMessageBox.information( None, "Orange Canvas", "Selected widgets don't share a common signal type. Unable to connect.", QMessageBox.Ok + QMessageBox.Default ) 
     114            QMessageBox.information( self, "Orange Canvas", "Selected widgets don't share a common signal type. Unable to connect.", QMessageBox.Ok) 
    114115            return 
    115116        elif connectStatus == -1: 
    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 
     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 
    118120 
    119121        # if there are multiple choices, how to connect this two widget, then show the dialog 
    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: 
     122        if len(dialog.getLinks()) > 1 or dialog.multiplePossibleConnections or dialog.getLinks() == []: 
     123            if dialog.exec_() == QDialog.Rejected: 
    123124                return 
    124125 
     
    149150 
    150151        if newSignals == None: 
    151             dialog = SignalDialog(self.canvasDlg, None, "", True) 
     152            dialog = SignalDialog(self.canvasDlg, None) 
    152153            dialog.setOutInWidgets(outWidget, inWidget) 
    153154            for (outName, inName) in signals: 
     
    156157 
    157158            # if there are multiple choices, how to connect this two widget, then show the dialog 
    158             res = dialog.exec_loop() 
    159             if dialog.result() == QDialog.Rejected: return 
     159            if dialog.exec_() == QDialog.Rejected: 
     160                return 
    160161 
    161162            newSignals = dialog.getLinks() 
     
    225226        if self.signalManager.links.has_key(outWidget.instance): 
    226227            for (widget, signalFrom, signalTo, enabled) in self.signalManager.links[outWidget.instance]: 
    227                 if widget == inWidget.instance: 
    228                     otherSignals = 1 
     228                    if widget == inWidget.instance: 
     229                        otherSignals = 1 
    229230        if not otherSignals: 
    230231            self.removeLine(outWidget, inWidget) 
     
    257258    # add new widget 
    258259    def addWidget(self, widget, x= -1, y=-1, caption = "", activateSettings = 1): 
    259         qApp.setOverrideCursor(QWidget.waitCursor) 
     260        qApp.setOverrideCursor(Qt.WaitCursor) 
    260261        try: 
    261262            newwidget = orngCanvasItems.CanvasWidget(self.signalManager, self.canvas, self.canvasView, widget, self.canvasDlg.defaultPic, self.canvasDlg) 
     
    270271 
    271272        if x==-1 or y==-1: 
    272             x = self.canvasView.contentsX() + 10 
     273            x = self.canvasView.sceneRect().x() + 10 
    273274            for w in self.widgets: 
    274275                x = max(w.x() + 110, x) 
     
    276277            y = 150 
    277278        newwidget.setCoords(x,y) 
    278         self.canvasView.ensureVisible(x+50,y) 
    279         newwidget.setViewPos(self.canvasView.contentsX(), self.canvasView.contentsY()) 
     279        self.canvasView.ensureVisible(newwidget) 
     280##        newwidget.setViewPos(self.canvasView.contentsX(), self.canvasView.contentsY()) 
    280281 
    281282        if caption == "": caption = newwidget.caption 
     
    286287            caption = caption + " (" + str(i) + ")" 
    287288        newwidget.updateText(caption) 
    288         if (int(qVersion()[0]) >= 3): 
    289             newwidget.instance.setCaptionTitle(caption) 
    290         else: 
    291             newwidget.instance.setCaptionTitle("Qt " + caption) 
     289        newwidget.instance.setWindowTitle(caption) 
    292290 
    293291        # show the widget and activate the settings 
    294         qApp.setOverrideCursor(QWidget.waitCursor) 
     292        qApp.setOverrideCursor(Qt.WaitCursor) 
    295293        try: 
    296294            self.signalManager.addWidget(newwidget.instance) 
     
    393391 
    394392    def saveDocumentAs(self): 
    395         qname = QFileDialog.getSaveFileName( os.path.join(self.documentpath, self.documentname), "Orange Widget Scripts (*.ows)", self, "", "Save File") 
     393        qname = QFileDialog.getSaveFileName(self, "Save File", os.path.join(self.documentpath, self.documentname), "Orange Widget Scripts (*.ows)") 
    396394        name = str(qname) 
    397395        if os.path.splitext(name)[0] == "": return 
     
    401399        self.canvasDlg.settings["saveSchemaDir"] = self.documentpath 
    402400        self.applicationname = os.path.splitext(os.path.split(name)[1])[0] + ".py" 
    403         self.setCaption(self.documentname) 
     401        self.setWindowTitle(self.documentname) 
    404402        self.documentnameValid = True 
    405403        self.save() 
     
    474472        if not os.path.exists(filename): 
    475473            self.close() 
    476             QMessageBox.critical(self,'Orange Canvas','Unable to find file "'+ filename,  QMessageBox.Ok + QMessageBox.Default) 
     474            QMessageBox.critical(self, 'Orange Canvas', 'Unable to find file "'+ filename,  QMessageBox.Ok + QMessageBox.Default) 
    477475            return 
    478476 
    479477        # set cursor 
    480         qApp.setOverrideCursor(QWidget.waitCursor) 
     478        qApp.setOverrideCursor(Qt.WaitCursor) 
    481479 
    482480        try: 
     
    501499                tempWidget = self.addWidgetByFileName(name, int(widget.getAttribute("xPos")), int(widget.getAttribute("yPos")), widget.getAttribute("caption"), activateSettings = 0) 
    502500                if not tempWidget: 
    503                     QMessageBox.information(self,'Orange Canvas','Unable to create an instance of the \"'+ name + '\" widget',  QMessageBox.Ok + QMessageBox.Default) 
     501                    QMessageBox.information(self, 'Orange Canvas','Unable to create instance of widget \"'+ name + '\"',  QMessageBox.Ok + QMessageBox.Default) 
    504502                else: 
    505503                    if tempWidget.caption in settingsDict.keys(): 
    506504                        tempWidget.instance.loadSettingsStr(settingsDict[tempWidget.caption]) 
    507505                        tempWidget.instance.activateLoadedSettings() 
    508                 #qApp.processEvents() 
     506                qApp.processEvents() 
    509507 
    510508            #read lines 
     
    518516                outWidget = self.getWidgetByCaption(outCaption) 
    519517                if inWidget == None or outWidget == None: 
    520                     print 'Unable to create a line between widgets "%s" and "%s" due to a missing widget.' % (outCaption, inCaption) 
     518                    print "Unable to create a line due to invalid widget name. Try reinstalling widgets." 
    521519                    continue 
    522520 
     
    530528            self.enableSave(False) 
    531529 
    532             if caption != None: self.setCaption(caption) 
    533             else:               self.setCaption(self.documentname) 
     530            if caption != None: self.setWindowTitle(caption) 
     531            else:               self.setWindowTitle(self.documentname) 
    534532            self.documentnameValid = True 
    535533            if self.widgets: 
     
    541539                    widget.instance.restoreWidgetStatus() 
    542540        finally: 
    543             # set cursor 
    544             qApp.setOverrideCursor(QWidget.arrowCursor) 
     541            qApp.restoreOverrideCursor() 
    545542 
    546543 
     
    552549        extension = sys.platform == "win32" and ".pyw" or ".py" 
    553550        appName = os.path.splitext(self.applicationname)[0] + extension 
    554         qname = QFileDialog.getSaveFileName( os.path.join(self.applicationpath, appName) , "Orange Scripts (*%s)" % extension, self, "", "Save File as Application") 
     551        qname = QFileDialog.getSaveFileName(self, "Save File as Application", os.path.join(self.applicationpath, appName) , "Orange Scripts (*%s)" % extension) 
    555552        if qname.isEmpty(): return 
    556553 
    557         saveDlg = saveApplicationDlg(None, "", True) 
     554        saveDlg = saveApplicationDlg(None) 
    558555 
    559556        # add widget captions 
     
    563560                if self.widgets[i].instance == instance: saveDlg.insertWidgetName(self.widgets[i].caption) 
    564561 
    565         res = saveDlg.exec_loop() 
    566         if saveDlg.result() == QDialog.Rejected: 
    567             return 
    568  
    569         shownWidgetList = saveDlg.shownWidgetList 
    570         hiddenWidgetList = saveDlg.hiddenWidgetList 
     562        if saveDlg.exec_() == QDialog.Rejected: 
     563            return 
    571564 
    572565        (self.applicationpath, self.applicationname) = os.path.split(str(qname)) 
     
    577570        t = "    "  # instead of tab 
    578571        n = "\n" 
    579         imports = """import sys, os, cPickle, orange, orngSignalManager, orngRegistry 
     572        start = """#This is automatically created file containing an Orange schema 
     573import orngOrangeFoldersQt4 
     574import sys, os, cPickle, orange, orngSignalManager, OWGUI 
    580575DEBUG_MODE = 0   #set to 1 to output debugging info to file 'signalManagerOutput.txt' 
    581 orngRegistry.addWidgetDirectories()\n""" 
    582  
    583         captions = "# set widget captions\n" +t+t 
     576 
     577""" 
     578 
    584579        instancesT = "# create widget instances\n" +t+t 
    585580        instancesB = "# create widget instances\n" +t+t 
    586         tabs = "# add tabs\n"+t+t 
    587581        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 = "" 
    592582        loadSett = "" 
    593583        saveSett = "" 
    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 
     584        widgetParameters = "" 
     585 
    599586        # gui for shown widgets 
    600         for widgetName in shownWidgetList: 
     587        for widgetName in saveDlg.shownWidgetList:    # + saveDlg.hiddenWidgetList 
    601588            if widgetName != "[Separator]": 
    602589                widget = None 
     
    604591                    if self.widgets[i].caption == widgetName: widget = self.widgets[i] 
    605592 
     593                shown = widgetName in saveDlg.shownWidgetList 
    606594                name = widget.caption 
    607595                name = name.replace(" ", "_").replace("(", "").replace(")", "").replace(".", "").replace("-", "").replace("+", "") 
    608                 imports += "from %s import *\n" % (widget.widget.getFileName()) 
     596                start += "from %s import *\n" % (widget.widget.getFileName()) 
    609597                instancesT += "self.ow%s = %s (self.tabs, signalManager = self.signalManager)\n" % (name, widget.widget.getFileName())+t+t 
    610598                instancesB += "self.ow%s = %s(signalManager = self.signalManager)\n" %(name, widget.widget.getFileName()) +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 
     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 
    622601                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) 
    625602            else: 
    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) 
     603                widgetParameters += "self.box.layout().addSpacing(10)\n" +t+t 
    650604 
    651605        for line in self.lines: 
     
    660614                links += "self.signalManager.addLink( self.ow" + outWidgetName + ", self.ow" + inWidgetName + ", '" + outName + "', '" + inName + "', 1)\n" +t+t 
    661615 
    662         widgetInstanceList += "]" 
    663616        links += "self.signalManager.setFreeze(0)\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)""" 
     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 
    682619 
    683620        progress = """ 
    684         statusBar = QStatusBar(self) 
    685         self.progress = QProgressBar(100, statusBar) 
     621        statusBar = QStatusBar(self); self.layout().addWidget(statusBar) 
     622        self.caption = QLabel('', statusBar) 
     623        self.caption.setMaximumWidth(230) 
     624        self.progress = QProgressBar(statusBar) 
    686625        self.progress.setMaximumWidth(100) 
    687         self.progress.setCenterIndicator(1) 
    688626        self.status = QLabel("", statusBar) 
    689627        self.status.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)) 
    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) 
     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) 
    697651 
    698652    def progressHandler(self, widget, val): 
    699653        if val < 0: 
    700             self.status.setText("<nobr>Processing: <b>" + str(widget.captionTitle) + "</b></nobr>") 
     654            self.caption.setText("<nobr>Processing: <b>" + str(widget.captionTitle) + "</b></nobr>") 
    701655            self.progress.setProgress(0) 
    702656        elif val >100: 
    703             self.status.setText("") 
     657            self.caption.setText("") 
    704658            self.progress.reset() 
    705659        else: 
    706660            self.progress.setProgress(val) 
    707             self.update()""" 
    708  
    709         loadSettings = """ 
     661            self.update() 
    710662 
    711663    def loadSettings(self): 
     
    716668        strSettings = cPickle.load(file) 
    717669        file.close() 
    718         """ % (fileName + ".sav") 
    719         loadSettings += loadSett 
    720  
    721         saveSettings = """ 
    722  
    723     def saveSettings(self): 
     670        %s 
     671 
     672    def closeEvent(self, ev): 
     673        OWBaseWidget.closeEvent(self, ev) 
    724674        if DEBUG_MODE: return 
     675        for widget in self.widgets[::-1]: 
     676            widget.synchronizeContexts() 
     677            widget.close() 
     678        strSettings = {} 
    725679        %s 
    726         strSettings = {} 
    727         """ % (synchronizeContexts) + saveSett + n+t+t + """file = open("%s", "w") 
     680        file = open("%s", "w") 
    728681        cPickle.dump(strSettings, file) 
    729682        file.close() 
    730         """ % (fileName + ".sav") 
    731  
    732  
    733         finish = """ 
     683 
    734684if __name__ == "__main__": 
    735685    application = QApplication(sys.argv) 
    736686    ow = GUIApplication() 
    737     application.setMainWidget(ow) 
    738687    ow.show() 
    739  
    740688    # comment the next line if in debugging mode and are interested only in output text in 'signalManagerOutput.txt' file 
    741     application.exec_loop() 
    742     ow.saveSettings() 
    743 """ 
    744  
    745         #if save != "": 
    746         #    save = t+"def exit(self):\n" +t+t+ save 
     689    application.exec_() 
     690        """ % (fileName + ".sav", loadSett, saveSett, fileName + ".sav") 
     691 
     692        start += n+n + """ 
     693class 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')""" 
    747708 
    748709        if asTabs: 
    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 
     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 
    752713 
    753714        #save app 
     
    755716        self.canvasDlg.settings["saveApplicationDir"] = self.applicationpath 
    756717        fileApp.write(whole) 
    757         fileApp.flush() 
    758718        fileApp.close() 
    759719 
     
    763723    def dumpWidgetVariables(self): 
    764724        for widget in self.widgets: 
    765             self.canvasDlg.output.write("<hr><br><b>%s</b><br>" % (widget.caption)) 
     725            self.canvasDlg.output.write("<hr><b>%s</b><br>" % (widget.caption)) 
    766726            v = vars(widget.instance).keys() 
    767727            v.sort() 
     
    770730 
    771731    def keyReleaseEvent(self, e): 
    772         self.ctrlPressed = e.state() & e.ControlButton 
     732        self.ctrlPressed = int(e.modifiers()) & Qt.ControlModifier != 0 
     733        e.ignore() 
    773734 
    774735    def keyPressEvent(self, e): 
    775         self.ctrlPressed = e.state() & e.ControlButton 
     736        self.ctrlPressed = int(e.modifiers()) & Qt.ControlModifier != 0 
    776737        if e.key() > 127: 
    777             QMainWindow.keyPressEvent(self, e) 
     738            e.ignore() 
    778739            return 
    779740 
    780741        # the list could include (e.ShiftButton, "Shift") if the shift key didn't have the special meaning 
    781         pressed = "-".join(filter(None, [e.state() & x and y for x, y in [(e.ControlButton, "Ctrl"), (e.AltButton, "Alt")]]) + [chr(e.key())]) 
     742        pressed = "-".join(filter(None, [int(e.modifiers()) & x and y for x, y in [(Qt.ControlModifier, "Ctrl"), (Qt.AltModifier, "Alt")]]) + [chr(e.key())]) 
    782743        widgetToAdd = self.canvasDlg.widgetShortcuts.get(pressed) 
    783744        if widgetToAdd: 
    784745            widgetToAdd.clicked() 
    785             if e.state() & e.ShiftButton and len(self.widgets) > 1: 
     746            if e.modifiers() & Qt.ShiftModifier and len(self.widgets) > 1: 
    786747                self.addLine(self.widgets[-2], self.widgets[-1]) 
    787748        else: 
    788             QMainWindow.keyPressEvent(self, e) 
     749            e.ignore() 
    789750 
    790751 
     
    794755    app.setMainWidget(dlg) 
    795756    dlg.show() 
    796     app.exec_loop() 
     757    app.exec_() 
  • orange/OrangeCanvas/orngOutput.py

    r3424 r3792  
    33#     print system output and exceptions into a window. Enables copy/paste 
    44# 
    5 from qt import * 
     5from PyQt4.QtCore import * 
     6from PyQt4.QtGui import * 
    67import sys 
    78import string 
     
    1415        apply(QMainWindow.__init__,(self,) + args) 
    1516        self.canvasDlg = canvasDlg 
     17        self.canvasDlg.workspace.addWindow(self) 
    1618 
    17         self.textOutput = QTextView(self) 
    18         self.textOutput.setFont(QFont('Courier New',10, QFont.Normal)) 
     19        self.textOutput = QTextEdit(self) 
     20        self.textOutput.setReadOnly(1) 
     21        self.textOutput.setCurrentFont(QFont('Courier New',10, QFont.Normal)) 
    1922        self.setCentralWidget(self.textOutput) 
    20         self.setCaption("Output Window") 
    21         self.setIcon(QPixmap(canvasDlg.outputPix)) 
     23        self.setWindowTitle("Output Window") 
     24        self.setWindowIcon(QIcon(canvasDlg.outputPix)) 
    2225 
    23         self.defaultExceptionHandler = sys.excepthook 
    24         self.defaultSysOutHandler = sys.stdout 
     26        #self.defaultExceptionHandler = sys.excepthook 
     27        #self.defaultSysOutHandler = sys.stdout 
    2528        self.focusOnCatchException = 1 
    2629        self.focusOnCatchOutput  = 0 
     
    2932        self.writeLogFile = 1 
    3033 
    31         self.logFile = open(os.path.join(canvasDlg.outputDir, "outputLog.htm"), "w") # create the log file 
     34        self.logFile = open(os.path.join(canvasDlg.canvasSettingsDir, "outputLog.htm"), "w") # create the log file 
    3235        #self.printExtraOutput = 0 
    3336        self.unfinishedText = "" 
    3437        self.verbosity = 0 
    35          
     38 
    3639        #sys.excepthook = self.exceptionHandler 
    3740        #sys.stdout = self 
    3841        #self.textOutput.setText("") 
    3942        #self.setFocusPolicy(QWidget.NoFocus) 
    40          
     43 
    4144        self.resize(700,500) 
    4245        self.showNormal() 
     
    7073    def setFocusOnException(self, focusOnCatchException): 
    7174        self.focusOnCatchException = focusOnCatchException 
    72          
     75 
    7376    def setFocusOnOutput(self, focusOnCatchOutput): 
    7477        self.focusOnCatchOutput = focusOnCatchOutput 
     
    8487 
    8588    def clear(self): 
    86         self.textOutput.setText("") 
    87      
     89        self.textOutput.setHtml("") 
     90 
    8891    # print text produced by warning and error widget calls 
    8992    def widgetEvents(self, text, eventVerbosity = 1): 
    90         if self.verbosity >= eventVerbosity:  
     93        if self.verbosity >= eventVerbosity: 
    9194            if text != None: 
    9295                self.write(str(text)) 
     
    9598    # simple printing of text called by print calls 
    9699    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:] 
    97104        text = str(text) 
    98105        text = text.replace("<", "(").replace(">", ")")    # since this is rich text control, we have to replace special characters 
     
    103110        text = text.replace("(hr)", "<hr>") 
    104111        text = text.replace("\n", "<br>\n")   # replace new line characters with <br> otherwise they don't get shown correctly in html output 
    105         #text = "<nobr>" + text + "</nobr>"   
     112        #text = "<nobr>" + text + "</nobr>" 
    106113 
    107114        if self.focusOnCatchOutput: 
     
    110117 
    111118        if self.writeLogFile: 
     119            #self.logFile.write(str(text) + "<br>\n") 
    112120            self.logFile.write(text) 
    113              
    114         self.textOutput.setText(str(self.textOutput.text()) + text) 
    115         self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
    116          
     121 
     122        #self.textOutput.append(text) 
     123        self.textOutput.insertHtml(text) 
     124        #self.textOutput.ensureVisible(0, self.textOutput.contentsHeight()) 
    117125        if text[-1:] == "\n": 
    118126            if self.printOutput: 
     
    121129        else: 
    122130            self.unfinishedText += text 
    123          
     131 
    124132    def writelines(self, lines): 
    125133        for line in lines: 
     
    129137        pass 
    130138 
    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  
    135139    def exceptionHandler(self, type, value, tracebackInfo): 
    136140        if self.focusOnCatchException: 
     
    139143 
    140144        text = "" 
     145        if str(self.textOutput.toPlainText()) not in ["", "\n"]: 
     146            text += "<hr>" 
    141147        t = localtime() 
    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]) 
     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]) 
    143149 
    144150        if self.printException: 
     
    147153        # 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 
    148154        list = traceback.extract_tb(tracebackInfo, 10) 
    149         space = "&nbsp &nbsp " 
     155        space = "&nbsp; &nbsp; " 
    150156        totalSpace = space 
    151157        for i in range(len(list)): 
     
    163169        value = str(value).replace("<", "(").replace(">", ")")    # since this is rich text control, we have to replace special characters 
    164170        text += "<nobr>" + totalSpace + "Exception type: <b>" + str(type) + "</b></nobr><br>" 
    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()) 
     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()) 
    168175 
    169176        if self.writeLogFile: 
    170             self.logFile.write(str(text) + "<br>") 
     177            self.logFile.write(str(text) + "<br>\n") 
  • orange/OrangeCanvas/orngRegistry.py

    r3661 r3792  
    55import os, sys, string, re, user 
    66import xml.dom.minidom 
     7from orngOrangeFoldersQt4 import * 
    78 
    89class WidgetsToXML: 
    910 
    1011    # read all installed widgets, build a registry and store widgets.pth with directory names in python dir 
    11     def ParseWidgetRoot(self, widgetDirName, outputDir): 
     12    def ParseWidgetRoot(self, widgetDirName, canvasSettingsDir): 
    1213        widgetDirName = os.path.realpath(widgetDirName) 
    13         outputDir = os.path.realpath(outputDir) 
    14  
     14        canvasSettingsDir = os.path.realpath(canvasSettingsDir) 
     15         
    1516        # create xml document 
    1617        doc = xml.dom.minidom.Document() 
     
    2526                self.ParseDirectory(doc, categories, full_filename, filename) 
    2627 
    27         additionalFile = os.path.join(outputDir, "additionalCategories") 
     28        additionalFile = os.path.join(canvasSettingsDir, "additionalCategories") 
    2829        if os.path.exists(additionalFile): 
    2930            for lne in open(additionalFile, "rt"): 
     
    3738        # we put widgets that are in the root dir of widget directory to category "Other" 
    3839        self.ParseDirectory(doc, categories, widgetDirName, "Other") 
    39  
     40         
    4041        xmlText = doc.toprettyxml() 
    41         file = open(os.path.join(outputDir, "widgetregistry.xml"), "wt") 
     42        file = open(os.path.join(canvasSettingsDir, "widgetregistry.xml"), "wt") 
    4243        file.write(xmlText) 
    4344        file.flush() 
     
    4748    # parse all widgets in directory widgetDirName\categoryName into new category named categoryName 
    4849    def ParseDirectory(self, doc, categories, full_dirname, categoryName, plugin = False): 
    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  
     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         
    5253        for filename in os.listdir(full_dirname): 
    5354            full_filename = os.path.join(full_dirname, filename) 
     
    7576            if (name == None):      # if the file doesn't have a name, we treat it as a non-widget file 
    7677                continue 
    77  
     78             
    7879            # create XML node for the widget 
    7980            child = categories.firstChild 
    8081            while (child != None and child.attributes.get("name").nodeValue != categoryName): 
    8182                child= child.nextSibling 
    82  
     83     
    8384            if (child == None): 
    8485                child = doc.createElement("category") 
     
    8788                    child.setAttribute("directory", full_dirname) 
    8889                categories.appendChild(child) 
    89  
     90     
    9091            widget = doc.createElement("widget") 
    9192            widget.setAttribute("file", filename[:-3]) 
     
    9798            widget.setAttribute("author", author) 
    9899            widget.setAttribute("contact", contact) 
    99  
    100             # description 
     100             
     101            # description             
    101102            if (description != ""): 
    102103                desc = doc.createElement("description") 
     
    123124        if (search == None): 
    124125            return None 
    125  
     126         
    126127        text = search.group(0) 
    127128        text = text[text.find(">")+1:-text[::-1].find("<")-1]    #delete the <...> </...> 
    128129        return text.strip() 
    129130 
    130  
     131         
    131132    def GetAllInputs(self, data): 
    132133        #result = re.search('self.inputs *= *[[].*]', data) 
     
    168169    dirs = __getDirectoryNames() 
    169170    parse = WidgetsToXML() 
    170     widgetDir = os.path.join(dirs["canvasDir"], "../OrangeWidgets") 
    171     parse.ParseWidgetRoot(widgetDir, dirs["outputDir"]) 
     171    parse.ParseWidgetRoot(dirs["widgetDir"], dirs["canvasSettingsDir"]) 
    172172 
    173173def readAdditionalCategories(): 
    174174    dirs = __getDirectoryNames() 
    175     addCatFile = os.path.join(dirs["outputDir"], "additionalCategories") 
     175    addCatFile = os.path.join(dirs["canvasDir"], "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["outputDir"], "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
     183    open(os.path.join(dirs["canvasDir"], "additionalCategories"), "w").write("\n".join(["\t".join(l) for l in categories])) 
    184184 
    185185def addWidgetCategory(category, directory, add = True): 
     
    190190 
    191191 
    192  
    193 def __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  
    245 def 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  
    261 directoryNames = __getDirectoryNames() 
    262 vars().update(directoryNames) 
    263  
    264192if __name__=="__main__": 
    265193    rebuildRegistry() 
  • orange/OrangeCanvas/orngSignalManager.py

    r3788 r3792  
    1818        self.type = signalType 
    1919        self.handler = handler 
    20  
    21         if isinstance(parameters, str): parameters = eval(parameters)   # in registry, parameters are stored as strings 
     20         
     21        if type(parameters) == str: parameters = eval(parameters)   # in registry, parameters are stored as strings 
    2222        # if we have the old definition of parameters then transform them 
    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 isinstance(parameters, str): parameters = eval(parameters) 
     37         
     38        if type(parameters) == str: parameters = eval(parameters) 
    3939        if parameters in [0,1]: # old definition of parameters 
    4040            self.default = not parameters 
    4141            return 
    42  
     42         
    4343        if not (parameters & Default or parameters & NonDefault): parameters += NonDefault 
    4444        self.default = parameters & Default 
     
    121121 
    122122        self.debugFile.write(strValue) 
    123         if isinstance(object, orange.ExampleTable): 
     123        if type(object) == orange.ExampleTable: 
    124124            name = " " + getattr(object, "name", "") 
    125125            self.debugFile.write(". Token type = ExampleTable" + name + ". len = " + str(len(object))) 
    126         elif isinstance(object, list): 
     126        elif type(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

    r3667 r3792  
    33#    tab for showing widgets and widget button class 
    44# 
    5 from qt import * 
     5from PyQt4.QtCore import * 
     6from PyQt4.QtGui import * 
    67import os.path, sys 
    78from string import strip 
     
    1011from xml.dom.minidom import Document, parse 
    1112 
     13ICONS_LARGE_SIZE = 80 
     14ICONS_SMALL_SIZE = 40 
     15 
    1216class DirectionButton(QToolButton): 
    1317    def __init__(self, parent, leftDirection = 1, useLargeIcons = 0): 
    1418        apply(QToolButton.__init__,(self, parent)) 
    15         self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     19        self.setAutoRaise(1) 
    1620        self.parent = parent 
    1721        self.leftDirection = leftDirection        # is direction to left or right 
     
    1923        self.setAutoRepeat(1) 
    2024 
    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          
     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 
    2428        if useLargeIcons == 1: 
    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                  
     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 
    3237    def clicked(self): 
    3338        if self.leftDirection:  self.parent.moveWidgetsToLeft() 
     
    3843    def __init__(self, *args): 
    3944        apply(QToolButton.__init__,(self,)+ args) 
    40         self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     45        self.setAutoRaise(1) 
    4146        self.shiftPressed = 0 
    4247 
     
    4853        inputs = self.getInputs() 
    4954        if len(inputs) == 0: 
    50             formatedInList = "<b>Inputs:</b><br> &nbsp &nbsp None" 
     55            formatedInList = "<b>Inputs:</b><br> &nbsp;&nbsp; None<br>" 
    5156        else: 
    5257            formatedInList = "<b>Inputs:</b><br>" 
    5358            for signal in inputs: 
    54                 formatedInList = formatedInList + " &nbsp &nbsp - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
    55             #formatedInList += "</ul>" 
     59                formatedInList += " &nbsp;&nbsp; - " + canvasDlg.getChannelName(signal.name) + " (" + signal.type + ")<br>" 
    5660 
    5761        outputs = self.getOutputs() 
    5862        if len(outputs) == 0: 
    59             formatedOutList = "<b>Outputs:</b><br> &nbsp &nbsp None<br>" 
     63            formatedOutList = "<b>Outputs:</b><br> &nbsp; &nbsp; None<br>" 
    6064        else: 
    6165            formatedOutList = "<b>Outputs:</b><br>" 
    6266            for signal in outputs: 
    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) 
     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) 
    7371 
    7472        self.canvasDlg = canvasDlg 
    75         self.setTextLabel(name, False) 
    76          
    77         self.setIconSet(QIconSet(QPixmap(self.getFullIconName()))) 
    78          
     73        self.setText(name) 
     74 
     75        self.setIcon(QIcon(self.getFullIconName())) 
     76 
    7977        if useLargeIcons == 1: 
    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) 
     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) 
    8786 
    8887    def getFileName(self): 
     
    9190    def getFullIconName(self): 
    9291        name = self.getIconName() 
    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          
     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 
    10699    def getIconName(self): 
    107100        return str(self.widgetTabs.widgetInfo[self.nameKey]["iconName"]) 
     
    156149    def getCategory(self): 
    157150        return self.nameKey[:self.nameKey.index("-")].strip() 
    158      
     151 
    159152    def clicked(self, rightClick = False): 
    160153        win = self.canvasDlg.workspace.activeWindow() 
     
    182175        x0, y0, x1, y1 = tl.x(), tl.y(), br.x(), br.y() 
    183176        wx, wy = e.globalX()-x0-ww2, e.globalY()-y0-wh2 
    184          
     177 
    185178        inwindow = (wx > 0) and (wy > 0) and (wx < vrect.width()-ww2) and (wy < vrect.height()-wh2) and isinstance(win, orngDoc.SchemaDoc) 
    186          
     179 
    187180        dinwin, widget = getattr(self, "widgetDragging", (None, None)) 
    188181        if dinwin and (dinwin != win or not inwindow): 
     
    215208    def mouseReleaseEvent(self, e): 
    216209        dinwin, widget = getattr(self, "widgetDragging", (None, None)) 
    217         self.shiftPressed = e.state() & e.ShiftButton 
     210        self.shiftPressed = e.modifiers() & Qt.ShiftModifier 
    218211        if widget: 
    219212            if widget.invalidPosition: 
     
    224217            delattr(self, "widgetDragging") 
    225218        else:  # not dragging, just a click 
    226             if e.button() == QMouseEvent.RightButton: 
     219            if e.button() == Qt.RightButton: 
    227220                self.clicked(True) 
    228221 
    229222        QToolButton.mouseReleaseEvent(self, e) 
    230              
     223 
    231224class WidgetTab(QWidget): 
    232225    def __init__(self, useLargeIcons = 0, *args): 
    233226        apply(QWidget.__init__,(self,)+ args) 
    234227        self.HItemBox = QHBoxLayout(self) 
     228        self.HItemBox.setSpacing(0) 
     229        self.HItemBox.setMargin(0) 
    235230        self.widgets = [] 
    236231        self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)) 
     
    238233        self.left  = DirectionButton(self, 1, useLargeIcons = useLargeIcons) 
    239234        self.right = DirectionButton(self, 0, useLargeIcons = useLargeIcons) 
     235        self.frameSpace = QFrame(self) 
     236        self.frameSpace.setMinimumWidth(10) 
     237        self.frameSpace.setMaximumWidth(10) 
     238 
    240239        self.HItemBox.addWidget(self.left) 
    241240        self.HItemBox.addWidget(self.right) 
    242          
    243         self.frameSpace = QFrame(self);  self.frameSpace.setMinimumWidth(10); self.frameSpace.setMaximumWidth(10) 
    244241        self.HItemBox.addWidget(self.frameSpace) 
    245242 
     
    249246        while self.widgetIndex > 0 and isinstance(self.widgets[self.widgetIndex], QFrame): 
    250247            self.widgetIndex -= 1 
    251          
     248 
    252249        self.updateLeftRightButtons() 
    253250 
     
    258255        while self.widgetIndex < len(self.widgets)-2 and isinstance(self.widgets[self.widgetIndex], QFrame): 
    259256            self.widgetIndex += 1 
    260          
     257 
    261258        self.updateLeftRightButtons() 
    262259 
     
    273270        for i in range(self.widgetIndex, len(self.widgets)): 
    274271            widgetsWidth += self.widgets[i].width() 
    275         windowWidth = self.width() - 2*self.left.width() - 20 
    276          
     272        windowWidth = self.visibleRegion().boundingRect().width() - 2*self.left.width() - 20 
     273 
    277274        while self.widgetIndex > 0 and windowWidth > widgetsWidth + self.widgets[self.widgetIndex-1].width(): 
    278275            widgetsWidth += self.widgets[self.widgetIndex-1].width() 
     
    286283        for widget in self.widgets[self.widgetIndex:]: 
    287284            widget.show() 
    288          
     285 
     286        self.right.setEnabled(windowWidth < widgetsWidth ) 
     287        self.left.setEnabled(self.widgetIndex > 0) 
     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) 
    299293 
    300294        self.HItemBox.invalidate() 
    301295 
    302296    def resizeEvent(self, e): 
     297        QWidget.resizeEvent(self, e) 
    303298        self.updateLeftRightButtons() 
    304299 
    305300 
     301 
    306302class WidgetTabs(QTabWidget): 
    307     def __init__(self, widgetInfo, *args): 
     303    def __init__(self, canvasDlg, widgetInfo, *args): 
    308304        apply(QTabWidget.__init__,(self,) + args) 
    309305        self.tabs = [] 
    310         self.canvasDlg = None 
     306        self.canvasDlg = canvasDlg 
    311307        self.allWidgets = [] 
    312308        self.useLargeIcons = False 
     
    314310        self.setMinimumWidth(10)    # this way the < and > button will show if tab dialog is too small 
    315311        self.widgetInfo = widgetInfo 
    316          
     312 
    317313    def insertWidgetTab(self, name): 
    318         tab = WidgetTab(self.useLargeIcons, self, name) 
     314        tab = WidgetTab(self.useLargeIcons, self) 
    319315        self.tabs.append(tab) 
    320         self.insertTab(tab, name) 
     316        self.addTab(tab, name) 
    321317        self.tabDict[name] = tab 
    322318        return tab 
    323          
    324     def setCanvasDlg(self, canvasDlg): 
    325         self.canvasDlg = canvasDlg 
    326319 
    327320    # read the xml registry and show all installed widgets 
     
    344337        for i in range(len(self.tabs)-1, -1, -1): 
    345338            if self.tabs[i].widgets == []: 
    346                 self.removePage(self.tabs[i]) 
     339                self.removeTab(self.indexOf(self.tabs[i])) 
    347340                self.tabs.remove(self.tabs[i]) 
    348341 
    349          
     342 
    350343    # add all widgets inside the category to the tab 
    351344    def addWidgetCategory(self, category): 
     
    356349        tab.builtIn = not category.hasAttribute("directory") 
    357350        directory = not tab.builtIn and str(category.getAttribute("directory")) 
    358          
     351 
    359352        priorityList = [] 
    360353        nameList = [] 
     
    365358        inputList = [] 
    366359        outputList = [] 
    367          
    368          
     360 
     361 
    369362        widgetList = category.getElementsByTagName("widget") 
    370363        for widget in widgetList: 
     
    377370                priority = int(widget.getAttribute("priority")) 
    378371                iconName = widget.getAttribute("icon") 
    379                  
     372 
    380373                # it's a complicated way to get to the widget description 
    381374                description = "" 
     
    406399 
    407400        exIndex = 0 
    408         for i in range(len(priorityList)):             
     401        for i in range(len(priorityList)): 
    409402            button = WidgetButton(tab) 
    410403            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

    r3788 r3792  
    33#    handling the mouse events inside documents 
    44# 
    5 from qt import * 
    6 from qtcanvas import * 
    75import orngCanvasItems 
     6from PyQt4.QtCore import * 
     7from PyQt4.QtGui import * 
    88 
    99# ######################################## 
    1010# ######## SCHEMA VIEW class 
    1111# ######################################## 
    12 class SchemaView(QCanvasView): 
     12class SchemaView(QGraphicsView): 
    1313    def __init__(self, doc, *args): 
    14         apply(QCanvasView.__init__,(self,) + args) 
     14        apply(QGraphicsView.__init__,(self,) + args) 
     15        #self.setAlignment(Qt.AlignLeft | Qt.AlignTop) 
    1516        self.doc = doc 
    1617        self.bMouseDown = False 
     
    2627        self.tempWidget = None 
    2728        self.selWidgets = [] 
     29        self.setRenderHint(QPainter.Antialiasing) 
    2830        self.createPopupMenus() 
    29         self.connect(self, SIGNAL("contentsMoving(int,int)"), self.contentsMoving) 
    30  
     31        self.ensureVisible(0,0,1,1) 
    3132 
    3233    def createPopupMenus(self): 
    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) 
     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) 
    4041        #self.widgetPopup.insertSeparator() 
    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() 
     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() 
    5051 
    5152 
     
    6465    def renameActiveWidget(self): 
    6566        exName = str(self.tempWidget.caption) 
    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) 
     67        (newName ,ok) = QInputDialog.getText(self, "Qt Rename Widget", "Enter new name for the widget \"" + exName + "\":", QLineEdit.Normal, exName) 
    7068        newName = str(newName) 
    7169        if ok and self.tempWidget != None and newName != exName: 
    7270            for widget in self.doc.widgets: 
    7371                if widget.caption.lower() == newName.lower(): 
    74                     QMessageBox.critical(self,'Orange Canvas','Unable to rename widget. An instance with that name already exists.',  QMessageBox.Ok + QMessageBox.Default) 
     72                    QMessageBox.information(self, 'Orange Canvas', 'Unable to rename widget. An instance with that name already exists.') 
    7573                    return 
    7674            self.tempWidget.updateText(newName) 
    7775            self.tempWidget.updateTooltip() 
    7876            self.tempWidget.updateLinePosition() 
    79             if (int(qVersion()[0]) < 3) and len(newName) < 3 or newName[:2].lower() != "qt": 
     77            if len(newName) < 3 or newName[:2].lower() != "qt": 
    8078                newName = "Qt " + newName 
    8179            self.tempWidget.instance.setCaption(newName) 
     
    8583    def removeActiveWidget(self): 
    8684        if self.doc.signalManager.signalProcessingInProgress: 
    87              QMessageBox.information( None, "Orange Canvas", "Unable to remove widgets while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
     85             QMessageBox.information( self, "Orange Canvas", "Unable to remove widgets while signal processing is in progress. Please wait.") 
    8886             return 
    8987        if not self.bMultipleSelection: 
     
    9391            self.doc.removeWidget(item) 
    9492 
    95         self.canvas().update() 
     93        self.scene().update() 
    9694        self.selWidgets = [] 
    9795        self.tempWidget = None 
     
    104102    def toggleEnabledLink(self): 
    105103        if self.selectedLine != None: 
    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) 
     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) 
    110108            self.selectedLine.inWidget.updateTooltip() 
    111109            self.selectedLine.outWidget.updateTooltip() 
     
    116114        if not self.selectedLine: return 
    117115        if self.doc.signalManager.signalProcessingInProgress: 
    118              QMessageBox.information( None, "Orange Canvas", "Unable to remove connection while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
     116             QMessageBox.information( self, "Orange Canvas", "Unable to remove connection while signal processing is in progress. Please wait.") 
    119117             return 
    120118        self.deleteLine(self.selectedLine) 
    121119        self.selectedLine = None 
    122         self.canvas().update() 
     120        self.scene().update() 
    123121 
    124122    def deleteLine(self, line): 
     
    147145    # return number of items in "items" of type "type" 
    148146    def findItemTypeCount(self, items, Type): 
    149         return sum([isinstance(item, Type) for item in items]) 
     147        return sum([type(item) == Type for item in items]) 
    150148 
    151149    # find and return first item of type Type 
    152150    def findFirstItemType(self, items, Type): 
    153151        for item in items: 
    154             if isinstance(item, Type): 
     152            if type(item) == Type: 
    155153                return item 
    156154        return None 
     
    160158        ret = [] 
    161159        for item in items: 
    162             if isinstance(item, Type): 
     160            if type(item) == Type: 
    163161                ret.append(item) 
    164162        return ret 
     
    170168 
    171169    # mouse button was pressed 
    172     def contentsMousePressEvent(self, ev): 
    173         self.mouseDownPosition = QPoint(ev.pos().x(), ev.pos().y()) 
     170    def mousePressEvent(self, ev): 
     171        self.mouseDownPosition = self.mapToScene(ev.pos()) 
     172 
    174173        if self.tempRect: 
    175174            self.tempRect.hide() 
    176             self.tempRect.setCanvas(None) 
    177175            self.tempRect = None 
    178176 
    179177        for item in self.doc.widgets: 
    180178            if item not in self.selWidgets: item.setSelected(0) 
    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 == []: 
     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: 
    187185            self.tempWidget = None 
    188186            self.tempRect = None 
     
    191189 
    192190        # we clicked on a widget or on a line 
    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 
     191        else: 
     192            if type(activeItem) == orngCanvasItems.CanvasWidget:        # if we clicked on a widget 
     193                self.tempWidget = activeItem 
    199194                self.tempWidget.setSelected(1) 
    200195 
    201196                # did we click inside the boxes to draw connections 
    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() 
     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() 
    234228 
    235229                # is we clicked the right mouse button we show the popup menu for widgets 
    236                 elif ev.button() == QMouseEvent.RightButton: 
     230                elif ev.button() == Qt.RightButton: 
    237231                    self.widgetPopup.popup(ev.globalPos()) 
    238232                else: 
     
    240234 
    241235            # if we right clicked on a line we show a popup menu 
    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  
     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()) 
    254242            else: 
    255243                self.unselectAllWidgets() 
    256244 
    257         self.doc.canvas.update() 
     245        self.scene().update() 
    258246        self.bMouseDown = True 
    259         self.lastMousePosition = QPoint(ev.pos().x(), ev.pos().y()) 
     247        self.lastMousePosition = self.mapToScene(ev.pos()) 
    260248 
    261249 
    262250    # ################################################################### 
    263251    # mouse button was pressed and mouse is moving ###################### 
    264     def contentsMouseMoveEvent(self, ev): 
     252    def mouseMoveEvent(self, ev): 
    265253        #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()): 
    266254        #    self.contentsMouseReleaseEvent(ev) 
    267255        #    return 
     256        point = self.mapToScene(ev.pos()) 
    268257        if self.tempRect: 
    269258            self.tempRect.hide() 
    270             self.tempRect.setCanvas(None) 
    271259            self.tempRect = None 
    272260 
     261        #print self.bWidgetDragging, self.selWidgets 
    273262        if self.bWidgetDragging: 
    274263            for item in self.selWidgets: 
    275264                ex_pos = QPoint(item.x(), item.y()) 
    276                 item.setCoordsBy(ev.pos().x() - self.lastMousePosition.x(), ev.pos().y() - self.lastMousePosition.y()) 
     265                item.setCoordsBy(point.x() - self.lastMousePosition.x(), point.y() - self.lastMousePosition.y()) 
    277266                if self.doc.canvasDlg.snapToGrid: 
    278267                    item.moveToGrid() 
     
    280269                    item.setCoords(item.xPos, item.yPos) 
    281270 
    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 
     271                items = self.scene().collidingItems(item) 
     272                item.invalidPosition = (self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) > 0) 
    286273                item.updateLineCoords() 
    287274 
    288275        elif self.bLineDragging: 
    289             if self.tempLine: self.tempLine.setPoints(self.tempLine.startPoint().x(), self.tempLine.startPoint().y(), ev.pos().x(), ev.pos().y()) 
     276            if self.tempLine: 
     277                self.tempLine.setLine(self.tempLine.line().x1(), self.tempLine.line().y1(), point.x(), point.y()) 
    290278 
    291279        elif self.bMultipleSelection: 
    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) 
     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()) 
    294282            self.tempRect.show() 
    295283 
    296284            # select widgets in rectangle 
    297             items = self.canvas().collisions(rect) 
     285            items = self.scene().collidingItems(self.tempRect) 
    298286            widgets = self.findAllItemType(items, orngCanvasItems.CanvasWidget) 
    299287 
     
    306294            self.selWidgets = widgets 
    307295 
    308         self.canvas().update() 
    309         self.lastMousePosition = QPoint(ev.pos().x(), ev.pos().y()) 
     296        self.scene().update() 
     297        self.lastMousePosition = point 
     298 
    310299 
    311300    # ################################################################### 
    312301    # mouse button was released ######################################### 
    313     def contentsMouseReleaseEvent(self, ev): 
     302    def mouseReleaseEvent(self, ev): 
     303        point = self.mapToScene(ev.pos()) 
    314304        if self.tempRect: 
    315305            self.tempRect.hide() 
    316             self.tempRect.setCanvas(None) 
    317306            self.tempRect = None 
    318307 
     
    321310            validPos = True 
    322311            for item in self.selWidgets: 
    323                 items = self.canvas().collisions(item.rect()) 
    324                 count = self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) 
    325                 if count > 1: 
    326                     validPos = False 
     312                items = self.scene().collidingItems(item) 
     313                validPos = validPos and (self.findItemTypeCount(items, orngCanvasItems.CanvasWidget) == 0) 
     314 
    327315 
    328316            for item in self.selWidgets: 
     
    334322                item.updateLineCoords() 
    335323                item.setAllLinesFinished(True) 
    336                 item.repaintWidget() 
    337                 item.repaintAllLines() 
     324##                item.repaintWidget() 
     325##                item.repaintAllLines() 
    338326 
    339327            self.doc.enableSave(True) 
     
    341329        # if we are drawing line 
    342330        elif self.bLineDragging: 
    343             items = self.canvas().collisions(ev.pos()) 
    344             item = self.findFirstItemType(items, orngCanvasItems.CanvasWidget) 
     331            item = self.scene().itemAt(QPointF(ev.pos())) 
    345332 
    346333            # we must check if we have really conected some output to input 
    347             if self.tempWidget and self.tempLine and item and item != self.tempWidget: 
    348                 if self.tempWidget.mouseInsideLeftChannel(self.tempLine.startPoint()): 
     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()): 
    349336                    outWidget = item 
    350337                    inWidget  = self.tempWidget 
     
    355342                # hide the temp line 
    356343                self.tempLine.hide() 
    357                 self.tempLine.setCanvas(None) 
    358344                self.tempLine = None 
    359345 
    360346                if self.doc.signalManager.signalProcessingInProgress: 
    361                      QMessageBox.information( None, "Orange Canvas", "Unable to connect widgets while signal processing is in progress. Please wait.", QMessageBox.Ok + QMessageBox.Default ) 
     347                     QMessageBox.information( self, "Orange Canvas", "Unable to connect widgets while signal processing is in progress. Please wait.") 
    362348                else: 
    363349                    line = self.doc.addLine(outWidget, inWidget) 
    364                     if line: line.repaintLine(self) 
     350##                    if line: line.repaintLine(self) 
    365351 
    366352            if self.tempLine != None: 
    367                 self.tempLine.setPoints(0,0,0,0) 
     353                self.tempLine.setLine(0,0,0,0) 
    368354                self.tempLine.hide() 
    369                 self.tempLine.setCanvas(None) 
    370355                self.tempLine = None 
    371356 
    372         self.canvas().update() 
     357        self.scene().update() 
    373358        self.bMouseDown = False 
    374359        self.bWidgetDragging = False 
    375360        self.bLineDragging = False 
    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 
     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 
    384367            self.openActiveWidget() 
    385         elif line: 
     368        elif type(activeItem) == orngCanvasItems.CanvasLine: 
    386369            if self.doc.signalManager.signalProcessingInProgress: 
    387                 QMessageBox.information( None, "Orange Canvas", "Please wait until Orange finishes processing signals.", QMessageBox.Ok + QMessageBox.Default ) 
     370                QMessageBox.information( self, "Orange Canvas", "Please wait until Orange finishes processing signals.") 
    388371                return 
    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() 
     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 
    402377 
    403378    def progressBarHandler(self, widgetInstance, value): 
     
    427402#    def drawContents(self, painter, x, y, w, h): 
    428403#        rect = QRect(x,y,w,h) 
    429 #        activeItems = self.canvas().collisions(rect) 
     404#        activeItems = self.scene().collisions(rect) 
    430405#        for item in activeItems: 
    431406#            item.drawShape(painter) 
Note: See TracChangeset for help on using the changeset viewer.