Changeset 6979:de023b5aa04d in orange


Ignore:
Timestamp:
09/21/10 10:40:36 (4 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
5cb0b5eb62f5026691d12580cc05e4cc3660f909
Message:
  • removed Domain box
  • added Add class label button
  • added Select tool
  • changed how the tool's GUI gets rendered on top of OWGraph (saved to pixmap in DataTool.paintEvent and then drawn in OWGraph.drawCanvas) due to problems with some versions of PyQwt (no access to QwtPlot.canvas().paintEvent)
File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Prototypes/OWDataGenerator.py

    r6937 r6979  
    1 """<name>Data generator</name> 
     1"""<name>Generate data</name> 
     2<description>Generate artificial dataset with a simple 'paint' like interface</description> 
     3<contact>ales.erjavec(@at@)fri.uni-lj.si</contact> 
     4<icon>icons/GenerateData.png</icon> 
    25""" 
    36 
     
    3437        self.replot() 
    3538         
     39    def drawCanvas(self, painter): 
     40        OWGraph.drawCanvas(self, painter) 
     41        pixmap = getattr(self, "_tool_pixmap", None) 
     42        if pixmap: 
     43            painter.drawPixmap(0, 0, pixmap) 
     44         
    3645class DataTool(QObject): 
    3746    """ A base class for data tools that operate on OWGraph 
    3847    widgets by installing itself as its event filter. 
    3948    """ 
    40     clusterIndex = 0 
     49    classIndex = 0 
    4150    class optionsWidget(QFrame): 
    4251        def __init__(self, tool, parent=None): 
     
    5665            self.graph.canvas().installEventFilter(self) 
    5766            self.graph._data_tool_event_filter = self 
     67            self.graph._tool_pixmap = None 
    5868            self.graph.replot() 
    5969         
     
    6979        elif event.type() == QEvent.Paint: 
    7080            return self.paintEvent(event) 
     81        elif event.type() == QEvent.HoverLeave: 
     82            return self.leaveEvent(event) 
     83        elif event.type() == QEvent.HoverEnter: 
     84            return self.enterEvent(event) 
    7185        return False   
    7286     
     
    8498     
    8599    def mouseDoubleClickEvent(self, event): 
     100        return False 
     101     
     102    def enterEvent(self, event): 
     103        return False 
     104     
     105    def leaveEvent(self, event): 
    86106        return False 
    87107     
     
    107127        pass 
    108128     
     129class GraphSelections(QObject): 
     130    def __init__(self, parent, movable=True, multipleSelection=False): 
     131        QObject.__init__(self, parent) 
     132        self.selection = [] 
     133        self.movable = movable 
     134        self.multipleSelection = multipleSelection 
     135         
     136        self._moving_index, self._moving_pos, self._selection_region = -1, QPointF(), (QPointF(), QPointF()) 
     137         
     138    def getPos(self, event): 
     139        graph = self.parent() 
     140        pos = event.pos() 
     141        x = graph.invTransform(QwtPlot.xBottom, pos.x()) 
     142        y = graph.invTransform(QwtPlot.yLeft, pos.y()) 
     143        return QPointF(x, y) 
     144     
     145    def toPath(self, region): 
     146        path = QPainterPath() 
     147        if isinstance(region, QRectF) or isinstance(region, QRect): 
     148            path.addRect(rect.normalized()) 
     149        elif isinstance(region, tuple): 
     150            path.addRect(QRectF(*region).normalized()) 
     151        return path 
     152             
     153     
     154    def addSelectionRegion(self, region): 
     155        self.selection.append(region) 
     156        self.emit(SIGNAL("selectionRegionAdded(int, QPainterPath)"), len(self.selection) - 1, self.toPath(region)) 
     157         
     158    def setSelectionRegion(self, index, region): 
     159        self.selection[index] = region 
     160        self.emit(SIGNAL("selectionRegionUpdated(int, QPainterPath)"), index, self.toPath(region)) 
     161         
     162    def clearSelection(self): 
     163        for i, region in enumerate(self.selection): 
     164            self.emit(SIGNAL("selectionRegionRemoved(int, QPainterPath)"), i, self.toPath(region)) 
     165        self.selection = [] 
     166         
     167    def start(self, event): 
     168        pos = self.getPos(event) 
     169        index = self.regionAt(event) 
     170        if index == -1 or not self.movable: 
     171            if event.modifiers() & Qt.ControlModifier and self.multipleSelection:  
     172                self.addSelectionRegion((pos, pos)) 
     173            else: 
     174                self.clearSelection() 
     175                self.addSelectionRegion((pos, pos)) 
     176            self._moving_index = -1 
     177        else: 
     178            self._moving_index, self._moving_pos, self._selection_region = index, pos, self.selection[index] 
     179            self.emit(SIGNAL("selectionRegionMoveStarted(int, QPointF, QPainterPath)"), index, pos, self.toPath(self.selection[index]))   
     180        self.emit(SIGNAL("selectionGeometryChanged()")) 
     181     
     182    def update(self, event): 
     183        pos = self.getPos(event) 
     184        index = self._moving_index 
     185        if index == -1: 
     186            self.selection[-1] = self.selection[-1][:-1] + (pos,) 
     187            self.emit(SIGNAL("selectionRegionUpdated(int, QPainterPath)"), len(self.selection) - 1 , self.toPath(self.selection[-1])) 
     188        else: 
     189            diff = self._moving_pos - pos 
     190            self.selection[index] = tuple([p - diff for p in self._selection_region]) 
     191            self.emit(SIGNAL("selectionRegionMoved(int, QPointF, QPainterPath)"), index, pos, self.toPath(self.selection[index])) 
     192             
     193        self.emit(SIGNAL("selectionGeometryChanged()")) 
     194     
     195    def end(self, event, index=-1): 
     196        self.update(event) 
     197        if self._moving_index != -1: 
     198            self.emit(SIGNAL("selectionRegionMoveEnd(int)"), self._moving_index) 
     199        self._moving_index = -1 
     200                       
     201         
     202    def regionAt(self, event): 
     203        pos = self.getPos(event) 
     204        for i, (p1, p2) in enumerate(self.selection): 
     205            if QRectF(p1, p2).contains(pos): 
     206                return i 
     207        return -1 
     208         
     209    def testSelection(self, data): 
     210        data = numpy.asarray(data) 
     211        region = QPainterPath() 
     212        for p1, p2 in self.selection: 
     213            region.addRect(QRectF(p1, p2).normalized()) 
     214        def test(point): 
     215            return region.contains(QPointF(point[0], point[1])) 
     216        test = numpy.apply_along_axis(test, 1, data) 
     217        return test 
     218     
     219    def __nonzero__(self): 
     220        return bool(self.selection) 
     221     
     222    def __bool__(self): 
     223        return bool(self.selection) 
     224     
     225    def path(self): 
     226        region = QPainterPath() 
     227        for p1, p2 in self.selection: 
     228            p = QPainterPath() 
     229            p.addRect(QRectF(p1, p2).normalized()) 
     230            region = region.united(p) 
     231        return region 
     232     
     233    def qTransform(self): 
     234        graph = self.parent() 
     235        invTransform = graph.invTransform 
     236        e1 = graph.canvas().mapFrom(graph, QPoint(1, 0)) 
     237        e2 = graph.canvas().mapFrom(graph, QPoint(0, 1)) 
     238        e1x, e1y = e1.x(), e1.y() 
     239        e2x, e2y = e2.x(), e2.y() 
     240        sx = invTransform(QwtPlot.xBottom, 1) - invTransform(QwtPlot.xBottom, 0) 
     241        sy = invTransform(QwtPlot.yLeft, 1) - invTransform(QwtPlot.yLeft, 0) 
     242        dx = invTransform(QwtPlot.xBottom, 0) 
     243        dy = invTransform(QwtPlot.yLeft, 0) 
     244        return QTransform(sx, 0.0, 0.0, sy, dx, dy) 
     245     
     246class SelectTool(DataTool): 
     247    def __init__(self, graph, parent=None): 
     248        DataTool.__init__(self, graph, parent) 
     249        self.selection = GraphSelections(graph) 
     250        self.pen = QPen(Qt.red, 1, Qt.DashDotLine) 
     251        self.pen.setCosmetic(True) 
     252        self.pen.setJoinStyle(Qt.RoundJoin) 
     253        self.pen.setCapStyle(Qt.RoundCap) 
     254        self.connect(self.selection, SIGNAL("selectionRegionMoveStarted(int, QPointF, QPainterPath)"), self.onMoveStarted) 
     255        self.connect(self.selection, SIGNAL("selectionRegionMoved(int, QPointF, QPainterPath)"), self.onMove) 
     256         
     257    def setGraph(self, graph): 
     258        DataTool.setGraph(self, graph) 
     259        if graph and hasattr(self, "selection"): 
     260            self.selection.setParent(graph) 
     261 
     262    def paintEvent(self, event): 
     263        if self.selection: 
     264            pixmap = QPixmap(self.graph.canvas().size()) 
     265            pixmap.fill(QColor(255, 255, 255, 0)) 
     266            painter = QPainter(pixmap) 
     267            painter.setRenderHints(QPainter.Antialiasing) 
     268            inverted, singular = self.selection.qTransform().inverted() 
     269            painter.setPen(self.pen) 
     270             
     271            painter.setTransform(inverted) 
     272            for p1, p2 in self.selection.selection: 
     273                painter.drawRect(QRectF(p1, p2)) 
     274            del painter 
     275            self.graph._tool_pixmap = pixmap 
     276        return False 
     277         
     278    def mousePressEvent(self, event): 
     279        if event.button() == Qt.LeftButton: 
     280            self.selection.start(event) 
     281            self.graph.replot() 
     282        return True 
     283     
     284    def mouseMoveEvent(self, event): 
     285        index = self.selection.regionAt(event) 
     286        if index != -1: 
     287            self.graph.canvas().setCursor(Qt.OpenHandCursor) 
     288        else: 
     289            self.graph.canvas().setCursor(self.graph._cursor) 
     290             
     291        if event.buttons() & Qt.LeftButton: 
     292            self.selection.update(event) 
     293            self.graph.replot() 
     294        return True 
     295     
     296    def mouseReleaseEvent(self, event): 
     297        if event.button() == Qt.LeftButton: 
     298            self.selection.end(event) 
     299            self.graph.replot() 
     300        return True 
     301         
     302    def onMoveStarted(self, index, pos, path): 
     303        data = self.graph.data 
     304        attr1, attr2 = self.graph.attr1, self.graph.attr2 
     305        self._moving = [(i, float(ex[attr1]), float(ex[attr2])) for i, ex in enumerate(data)] 
     306        self._moving = [(i, x, y) for i, x, y in self._moving if path.contains(QPointF(x, y))] 
     307        self._moving_pos = pos 
     308         
     309    def onMove(self, index, pos, path): 
     310        data = self.graph.data 
     311        attr1, attr2 = self.graph.attr1, self.graph.attr2 
     312         
     313        diff = pos - self._moving_pos 
     314        for i, x, y in self._moving: 
     315            ex = data[i] 
     316            ex[attr1] = x + diff.x() 
     317            ex[attr2] = y + diff.y() 
     318        self.graph.updateGraph() 
     319             
     320         
    109321class ZoomTool(DataTool): 
    110322    def __init__(self, graph, parent=None): 
     
    134346            QFrame.__init__(self, parent) 
    135347             
    136         def setClusterListModel(self, model): 
     348        def setClassListModel(self, model): 
    137349            self.cb.setModel(model) 
    138350             
    139351        def onClusterChanged(self, index): 
    140             self.tool.clusterIndex = index 
    141              
     352            self.tool.classIndex = index 
    142353     
    143354    def mousePressEvent(self, event): 
     
    155366        example.setclass(self.graph.data.domain.classVar(self.graph.data.domain.classVar.baseValue)) 
    156367        self.graph.data.append(example) 
    157         self.graph.updateGraph() 
     368        self.graph.updateGraph(dataInterval=(-1, sys.maxint)) 
    158369         
    159370class BrushTool(DataTool): 
    160371    brushRadius = 20 
    161     intensity = 5 
     372    density = 5 
    162373     
    163374    class optionsWidget(QFrame): 
     
    168379            self.radiusSlider = QSlider(Qt.Horizontal) 
    169380            self.radiusSlider.pyqtConfigure(minimum=10, maximum=30, value=self.tool.brushRadius) 
    170             self.intensitySlider = QSlider(Qt.Horizontal) 
    171             self.intensitySlider.pyqtConfigure(minimum=3, maximum=10, value=self.tool.intensity) 
     381            self.densitySlider = QSlider(Qt.Horizontal) 
     382            self.densitySlider.pyqtConfigure(minimum=3, maximum=10, value=self.tool.density) 
    172383             
    173384            layout.addRow("Radius", self.radiusSlider) 
    174             layout.addRow("Intensity", self.intensitySlider) 
     385            layout.addRow("Density", self.densitySlider) 
    175386            self.setLayout(layout) 
    176387             
     
    178389                         lambda value: setattr(self.tool, "brushRadius", value)) 
    179390             
    180             self.connect(self.intensitySlider, SIGNAL("valueChanged(int)"), 
    181                          lambda value: setattr(self.tool, "intensity", value)) 
    182          
     391            self.connect(self.densitySlider, SIGNAL("valueChanged(int)"), 
     392                         lambda value: setattr(self.tool, "density", value)) 
    183393     
    184394    def __init__(self, graph, parent=None): 
     
    192402            attr1, attr2 = self.attributes() 
    193403            self.dataTransform(attr1, x, rx, attr2, y, ry) 
     404        self.graph.replot() 
    194405        return True 
    195406         
     
    200411            attr1, attr2 = self.attributes() 
    201412            self.dataTransform(attr1, x, rx, attr2, y, ry) 
    202         self.graph.canvas().update() 
     413        self.graph.replot() 
    203414        return True 
    204415     
    205416    def mouseReleseEvent(self, event): 
     417        sself.graph.replot() 
    206418        return True 
    207419     
     420    def leaveEvent(self, event): 
     421        self.graph._tool_pixmap = None 
     422        self.graph.replot() 
     423        return False 
     424         
    208425    def paintEvent(self, event): 
    209         self.graph.canvas().paintEvent(event) 
    210         painter = QPainter(self.graph.canvas()) 
     426#        self.graph.canvas().paintEvent(event) 
     427        pixmap = QPixmap(self.graph.canvas().size()) 
     428        pixmap.fill(QColor(255, 255, 255, 0)) 
     429        painter = QPainter(pixmap) 
     430#        painter = QPainter(self.graph.canvas()) 
    211431        painter.setRenderHint(QPainter.Antialiasing) 
    212432        try: 
     
    217437            print ex 
    218438        del painter 
    219         return True 
     439        self.graph._tool_pixmap = pixmap 
     440        return False 
    220441         
    221442    def brushGeometry(self, point): 
     
    229450        import random 
    230451        new = [] 
    231         for i in range(self.intensity): 
     452        for i in range(self.density): 
    232453            ex = orange.Example(self.graph.data.domain) 
    233454            ex[attr1] = random.normalvariate(x, rx) 
     
    236457            new.append(ex) 
    237458        self.graph.data.extend(new) 
    238         self.graph.updateGraph(dataInterval=(-len(new), -1)) 
    239          
    240          
    241      
     459        self.graph.updateGraph(dataInterval=(-len(new), sys.maxint)) 
     460         
    242461class AddClusterTool(DataTool): 
    243462    class optionsWidget(QFrame): 
     
    249468            layout.addWidget(self.listView) 
    250469             
    251      
    252470    def __init__(self, graph, parent=None): 
    253471        DataTool.__init__(graph, parent) 
     
    265483            x = numpy.multiply(x, cov) 
    266484            y = numpy.multiply(y, cov) 
    267              
    268485     
    269486class MagnetTool(BrushTool): 
     
    273490        for ex in self.graph.data: 
    274491            x1, y1 = float(ex[attr1]), float(ex[attr2]) 
    275             dist = ((x1 - x)/rx)**2 + ((y1 - y)/ry)**2 
    276             alpha =  lambda d: min(1.0 / d, 1) 
    277             dx = numpy.sign(x - x1) * alpha(dist) 
    278             dy = numpy.sign(y - y1) * alpha(dist) 
    279             ex[attr1] = x1 + dx * self.intensity 
    280             ex[attr2] = y1 + dy * self.intensity 
     492            distsq = (x1 - x)**2 + (y1 - y)**2 
     493            dist = math.sqrt(distsq) 
     494            attraction = self.density / 100.0 
     495            advance = 0.005 
     496            dx = -(x1 - x)/dist * attraction / max(distsq, rx) * advance 
     497            dy = -(y1 - y)/dist * attraction / max(distsq, ry) * advance 
     498            ex[attr1] = x1 + dx 
     499            ex[attr2] = y1 + dy 
    281500        self.graph.updateGraph() 
    282501         
     
    295514        for ex in self.graph.data: 
    296515            x1, y1 = float(ex[attr1]), float(ex[attr2]) 
    297             dist = ((x1 - x)/rx)**2 + ((y1 - y)/ry)**2 
    298             alpha =  lambda d: min(1.0 / d, 1) 
    299             dx = numpy.sign(x - x1) * alpha(dist) 
    300             dy = numpy.sign(y - y1) * alpha(dist)  
    301             ex[attr1] = x1 - random.normalvariate(0, dx*self.intensity) 
    302             ex[attr2] = y1 - random.normalvariate(0, dy*self.intensity) 
     516            distsq = (x1 - x)**2 + (y1 - y)**2 
     517            dist = math.sqrt(distsq) 
     518            attraction = self.density / 100.0 
     519            advance = 0.005 
     520            dx = -(x1 - x)/dist * attraction / max(distsq, rx) * advance 
     521            dy = -(y1 - y)/dist * attraction / max(distsq, ry) * advance 
     522            ex[attr1] = x1 - random.normalvariate(0, dx*self.density) 
     523            ex[attr2] = y1 - random.normalvariate(0, dy*self.density) 
    303524        self.graph.updateGraph() 
    304525         
    305526class OWDataGenerator(OWWidget): 
    306     TOOLS = [("Zoom", "Zoom", ZoomTool), 
    307              ("Put", "Put individual instances", PutInstanceTool), 
    308              ("Brush", "Create multiple instances", BrushTool), 
    309 #             ("Add cluster", "Create a new cluster", AddClusterTool), 
    310              ("Magnet", "Move (drag) multiple instances", MagnetTool), 
    311              ("Jitter", "Jitter instances", JitterTool), 
    312 #             ("Multiply","Multiply instances", MultiplyTool) 
     527    TOOLS = [("Brush", "Create multiple instances", BrushTool, "GenerateDataBrushTool.png"), 
     528             ("Put", "Put individual instances", PutInstanceTool, "GenerateDataPutTool.png"), 
     529             ("Select", "Select and move instances", SelectTool, "GenerateDataSelectTool.png"), 
     530             ("Jitter", "Jitter instances", JitterTool, "GenerateDataJitterTool.png"), 
     531             ("Magnet", "Move (drag) multiple instances", MagnetTool, "GenerateDataMagnetTool.png"), 
     532             ("Zoom", "Zoom", ZoomTool, "GenerateDataZoomTool.png") 
    313533             ] 
    314534    def __init__(self, parent=None, signalManager=None, name="Data Generator"): 
     
    317537        self.outputs = [("Example Table", ExampleTable)] 
    318538         
    319         self.addClustersAsMeta = True 
     539        self.addClassAsMeta = False 
    320540        self.attributes = [] 
    321541        self.cov = [] 
     
    323543        self.loadSettings() 
    324544         
    325         box = OWGUI.widgetBox(self.controlArea, "Domain") 
    326         self.varListView = QListView(self) 
    327         self.varListView.setItemDelegate(VariableDelegate(self)) 
     545#        box = OWGUI.widgetBox(self.controlArea, "Domain") 
     546#        self.varListView = QListView(self) 
     547#        self.varListView.setItemDelegate(VariableDelegate(self)) 
    328548        self.variablesModel = VariableListModel([orange.FloatVariable(name) for name in ["X", "Y"]], self, flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable) 
    329         self.varListView.setModel(self.variablesModel) 
    330         box.layout().addWidget(self.varListView) 
    331          
    332         self.connect(self.variablesModel, SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.onDomainChanged) 
    333          
    334         self.addDomainFeatureAction = QAction("+", self) 
    335         self.removeDomainFeatureAction = QAction("-", self) 
    336         self.connect(self.addDomainFeatureAction, SIGNAL("triggered()"), self.onAddFeature) 
    337         self.connect(self.removeDomainFeatureAction, SIGNAL("triggered()"), self.onRemoveFeature) 
    338          
    339         hlayout = QHBoxLayout() 
    340         button1 = QToolButton() 
    341         button1.setDefaultAction(self.addDomainFeatureAction) 
    342         button2 = QToolButton() 
    343         button2.setDefaultAction(self.removeDomainFeatureAction) 
    344          
    345         hlayout.addWidget(button1) 
    346 #        hlayout.addWidget(button2) 
    347         hlayout.addStretch(10) 
    348         box.layout().addLayout(hlayout) 
    349          
    350         self.clusterVariable = orange.EnumVariable("Cluster", values=["Cluster 1", "Cluster 2"], baseValue=0) 
    351          
    352         cb = OWGUI.comboBox(self.controlArea, self, "clusterIndex", "Cluster") 
    353         self.clusterValuesModel = PyListModel([], self) 
    354         self.clusterValuesModel.wrap(self.clusterVariable.values) 
    355         cb.setModel(self.clusterValuesModel) 
    356         self.connect(cb, SIGNAL("currentIndexChanged(int)"), lambda base: setattr(self.clusterVariable, "baseValue", base)) 
    357          
     549#        self.varListView.setModel(self.variablesModel) 
     550#        box.layout().addWidget(self.varListView) 
     551#         
     552#        self.connect(self.variablesModel, SIGNAL("dataChanged(QModelIndex, QModelIndex)"), self.onDomainChanged) 
     553         
     554#        self.addDomainFeatureAction = QAction("+", self) 
     555#        self.removeDomainFeatureAction = QAction("-", self) 
     556#        self.connect(self.addDomainFeatureAction, SIGNAL("triggered()"), self.onAddFeature) 
     557#        self.connect(self.removeDomainFeatureAction, SIGNAL("triggered()"), self.onRemoveFeature) 
     558         
     559#        self.connect(self.varListView.selectionModel(), SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), self.onVariableSelectionChange) 
     560         
     561#        hlayout = QHBoxLayout() 
     562#        button1 = QToolButton() 
     563#        button1.setDefaultAction(self.addDomainFeatureAction) 
     564#        button2 = QToolButton() 
     565#        button2.setDefaultAction(self.removeDomainFeatureAction) 
     566#         
     567#        hlayout.addWidget(button1) 
     568##        hlayout.addWidget(button2) 
     569#        hlayout.addStretch(10) 
     570#        box.layout().addLayout(hlayout) 
     571         
     572        self.classVariable = orange.EnumVariable("Class label", values=["Class 1", "Class 2"], baseValue=0) 
     573         
     574        cb = OWGUI.comboBox(self.controlArea, self, "classIndex", "Class Label") 
     575        self.classValuesModel = PyListModel([], self) 
     576        self.classValuesModel.wrap(self.classVariable.values) 
     577        cb.setModel(self.classValuesModel) 
     578        self.connect(cb, SIGNAL("currentIndexChanged(int)"), lambda base: setattr(self.classVariable, "baseValue", base)) 
     579        cb.box.layout().addSpacing(4) 
     580        OWGUI.button(cb.box, self, "Add new class label", callback=self.onAddClassLabel) 
    358581         
    359582        toolbox = OWGUI.widgetBox(self.controlArea, "Tools", orientation=QGridLayout()) 
    360583        self.toolActions = QActionGroup(self) 
    361584        self.toolActions.setExclusive(True) 
    362         for i, (name, tooltip, tool) in enumerate(self.TOOLS): 
     585        for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS): 
    363586            action = QAction(name, self) 
    364587            action.setToolTip(tooltip) 
     
    374597        optionsbox = OWGUI.widgetBox(self.controlArea, "Options", orientation=self.optionsLayout) 
    375598         
    376         OWGUI.checkBox(self.controlArea, self, "addClustersAsMeta", "Add cluster ids as meta attributes") 
     599#        OWGUI.checkBox(self.controlArea, self, "addClassAsMeta", "Add class ids as meta attributes") 
     600         
     601        OWGUI.rubber(self.controlArea) 
    377602        OWGUI.button(self.controlArea, self, "Commit", callback=self.commit) 
    378603         
    379604        self.graph = DataGeneratorGraph(self) 
     605        self.graph.setAxisScale(QwtPlot.xBottom, 0.0, 1.0) 
     606        self.graph.setAxisScale(QwtPlot.yLeft, 0.0, 1.0) 
     607        self.graph.setAttribute(Qt.WA_Hover, True) 
    380608        self.mainArea.layout().addWidget(self.graph) 
    381609         
     
    385613         
    386614        self.onDomainChanged() 
    387 #        self.setCurrentTool(PutInstanceTool) 
    388615        self.toolActions.actions()[0].trigger() 
    389616         
     
    396623    def onRemoveFeature(self): 
    397624        pass 
     625     
     626    def onVariableSelectionChange(self, selected, deselected): 
     627        self.selected 
    398628     
    399629    def onToolAction(self, tool): 
     
    414644    def onDomainChanged(self, *args): 
    415645        if self.variablesModel: 
    416             self.domain = orange.Domain(list(self.variablesModel), self.clusterVariable) 
     646            self.domain = orange.Domain(list(self.variablesModel), self.classVariable) 
    417647            if self.data: 
    418648                self.data = orange.ExampleTable(self.domain, self.data) 
    419649            else: 
    420650                self.data = orange.ExampleTable(self.domain) 
    421             print list(self.data) 
     651#            print list(self.data) 
    422652            self.graph.setData(self.data, 0, 1) 
     653             
     654    def onAddClassLabel(self): 
     655        dialog = QDialog() 
     656        dialog.setWindowTitle("New class label") 
     657        form = QFormLayout() 
     658        lineEdit = QLineEdit() 
     659        form.addRow("Class label", lineEdit) 
     660        self.connect(lineEdit, SIGNAL("editingFinished"), dialog.accept) 
     661        blayout = QHBoxLayout() 
     662        b1 = QPushButton("Ok") 
     663        b2 = QPushButton("Cancel") 
     664        self.connect(b1, SIGNAL("clicked()"), dialog.accept) 
     665        self.connect(b2, SIGNAL("clicked()"), dialog.reject) 
     666        blayout.addStretch(10) 
     667        blayout.addWidget(b1) 
     668        blayout.addWidget(b2) 
     669        form.addRow(blayout) 
     670        dialog.setLayout(form) 
     671        if dialog.exec_() == QDialog.Accepted: 
     672            label = str(lineEdit.text()) 
     673            if label: 
     674                self.classValuesModel.append(label) 
    423675         
    424676    def commit(self): 
    425         if self.addClustersAsMeta: 
     677        if self.addClassAsMeta: 
    426678            domain = orange.Domain(self.graph.data.domain.attributes, None) 
    427679            domain.addmeta(orange.newmetaid(), self.graph.data.domain.classVar) 
Note: See TracChangeset for help on using the changeset viewer.