Changeset 8423:38b77a0b9e4d in orange


Ignore:
Timestamp:
07/23/11 14:32:55 (3 years ago)
Author:
Noughmad <Noughmad@…>
Branch:
default
Convert:
f3c510323f39c033bb876f7fd6f044b379bc292e
Message:

Add a Point item, make Curve and NetworkCurve use it.

NetworkCurve's NodeItem is also changes to be a subclass of Point, and EdgeItem is a subclass of QGraphicsLineItem.

Files:
4 added
16 edited

Legend:

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

    r8363 r8423  
    158158             
    159159            for val, freq in freqhigh: 
    160                 c = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = [val, val], yData = [1.0, 1.0 - max(.02, freqfac * freq)], autoScale = 1) 
     160                c = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = [val, val], yData = [1.0, 1.0 - max(.02, freqfac * freq)], autoScale = 1) 
    161161                c.setYAxis(yRight) 
    162162                self.rugKeys.append(c) 
    163163 
    164164            for val, freq in freqlow: 
    165                 c = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = [val, val], yData = [0.04, 0.04 + max(.02, freqfac * freq)], autoScale = 1) 
     165                c = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = [val, val], yData = [0.04, 0.04 + max(.02, freqfac * freq)], autoScale = 1) 
    166166                c.setYAxis(yRight) 
    167167                self.rugKeys.append(c) 
     
    182182                self.baseCurveX, self.baseCurveY = self.computeAddedScore(list(self.curCutPoints)) 
    183183             
    184             self.baseCurveKey = self.addCurve("", Qt.black, Qt.black, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = self.baseCurveX, yData = self.baseCurveY, lineWidth = 2, autoScale = 1) 
     184            self.baseCurveKey = self.addCurve("", Qt.black, Qt.black, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = self.baseCurveX, yData = self.baseCurveY, lineWidth = 2, autoScale = 1) 
    185185            self.baseCurveKey.setYAxis(yLeft) 
    186186 
     
    195195 
    196196        if self.lookaheadCurveX and self.master.showLookaheadLine: 
    197             self.lookaheadCurveKey = self.addCurve("", Qt.black, Qt.black, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = self.lookaheadCurveX, yData = self.lookaheadCurveY, lineWidth = 1, autoScale = 1) 
     197            self.lookaheadCurveKey = self.addCurve("", Qt.black, Qt.black, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = self.lookaheadCurveX, yData = self.lookaheadCurveY, lineWidth = 1, autoScale = 1) 
    198198            self.lookaheadCurveKey.setYAxis(yLeft) 
    199199            #self.lookaheadCurveKey.setVisible(1) 
     
    210210        if self.contingency and self.condProb and self.master.showTargetClassProb: 
    211211            xData = self.contingency.keys()[1:-1] 
    212             self.probCurveKey = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = xData, yData = [self.condProb(x)[self.master.targetClass] for x in xData], lineWidth = 2, autoScale = 1) 
     212            self.probCurveKey = self.addCurve("", Qt.gray, Qt.gray, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = xData, yData = [self.condProb(x)[self.master.targetClass] for x in xData], lineWidth = 2, autoScale = 1) 
    213213            self.probCurveKey.setYAxis(yRight) 
    214214 
     
    226226 
    227227        for cut in self.curCutPoints: 
    228             c = self.addCurve("", Qt.blue, Qt.blue, 1, style = Qt.DashLine, symbol = OWCurve.NoSymbol, xData = [cut, cut], yData = [.9, 0.1], autoScale = 1) 
     228            c = self.addCurve("", Qt.blue, Qt.blue, 1, style = Qt.DashLine, symbol = OWPoint.NoSymbol, xData = [cut, cut], yData = [.9, 0.1], autoScale = 1) 
    229229            c.setYAxis(yRight) 
    230230            self.cutLineKeys.append(c) 
     
    256256    def addCutPoint(self, cut): 
    257257        self.curCutPoints.append(cut) 
    258         c = self.addCurve("", Qt.blue, Qt.blue, 1, style = Qt.DashLine, symbol = OWCurve.NoSymbol, xData = [cut, cut], yData = [1.0, 0.015], autoScale = 1) 
     258        c = self.addCurve("", Qt.blue, Qt.blue, 1, style = Qt.DashLine, symbol = OWPoint.NoSymbol, xData = [cut, cut], yData = [1.0, 0.015], autoScale = 1) 
    259259        c.setYAxis(yRight) 
    260260        self.cutLineKeys.append(c) 
  • orange/OrangeWidgets/Prototypes/OWDistributionsQt.py

    r8405 r8423  
    272272            else: 
    273273                key.setColor(Qt.black) 
    274                 key.setSymbol(OWCurve.Diamond) 
     274                key.setSymbol(OWPoint.Diamond) 
    275275                key.setPointSize(7) 
    276276        else: 
     
    379379            ## (re)set the curves 
    380380            if self.variableContinuous: 
    381                 newSymbol = OWCurve.NoSymbol 
     381                newSymbol = OWPoint.NoSymbol 
    382382            else: 
    383                 newSymbol = OWCurve.Diamond 
     383                newSymbol = OWPoint.Diamond 
    384384                 
    385385            self.probCurveKey.setData(xs, mps) 
  • orange/OrangeWidgets/Prototypes/OWLinProjGraphQt.py

    r8406 r8423  
    131131                XAnchors = [a[0] for a in shownAnchorData] 
    132132                YAnchors = [a[1] for a in shownAnchorData] 
    133                 self._extra_curves.append(self.addCurve("dots", QColor(160,160,160), QColor(160,160,160), 10, style = Qt.NoPen, symbol = OWCurve.Ellipse, xData = XAnchors, yData = YAnchors, showFilledSymbols = 1)) 
     133                self._extra_curves.append(self.addCurve("dots", QColor(160,160,160), QColor(160,160,160), 10, style = Qt.NoPen, symbol = OWPoint.Ellipse, xData = XAnchors, yData = YAnchors, showFilledSymbols = 1)) 
    134134 
    135135                # draw text at anchors 
     
    305305                if not validData[i]: continue 
    306306                newColor = self.contPalette.getRGB(self.noJitteringScaledData[self.dataClassIndex][i]) 
    307                 self.addCurve(str(i), QColor(*newColor+ (self.alphaValue,)), QColor(*newColor+ (self.alphaValue,)), self.pointWidth, symbol = OWCurve.Ellipse, xData = [x_positions[i]], yData = [y_positions[i]]) 
     307                self.addCurve(str(i), QColor(*newColor+ (self.alphaValue,)), QColor(*newColor+ (self.alphaValue,)), self.pointWidth, symbol = OWPoint.Ellipse, xData = [x_positions[i]], yData = [y_positions[i]]) 
    308308                if self.showValueLines: 
    309309                    self.addValueLineCurve(x_positions[i], y_positions[i], newColor, i, indices) 
     
    481481                        attrVal = self.scaledData[self.attributeNameIndex[label]][index] 
    482482                        markerX, markerY = xAnchor*(attrVal+0.03), yAnchor*(attrVal+0.03) 
    483                         curve = self.addCurve("", color, color, 1, style = Qt.SolidLine, symbol = OWCurve.NoSymbol, xData = [0, xAnchor*attrVal], yData = [0, yAnchor*attrVal], lineWidth=3) 
     483                        curve = self.addCurve("", color, color, 1, style = Qt.SolidLine, symbol = OWPoint.NoSymbol, xData = [0, xAnchor*attrVal], yData = [0, yAnchor*attrVal], lineWidth=3) 
    484484 
    485485                        marker = None 
  • orange/OrangeWidgets/Prototypes/OWScatterPlotGraphQt.py

    r8363 r8423  
    323323            if colorIndex != -1: 
    324324                num = len(self.dataDomain[colorIndex].values) 
    325                 val = [[], [], [self.pointWidth]*num, [OWCurve.Ellipse]*num] 
     325                val = [[], [], [self.pointWidth]*num, [OWPoint.Ellipse]*num] 
    326326                varValues = getVariableValuesSorted(self.dataDomain[colorIndex]) 
    327327                for ind in range(num): 
     
    344344                num = len(self.dataDomain[sizeIndex].values) 
    345345                if legendKeys.has_key(sizeIndex):  val = legendKeys[sizeIndex] 
    346                 else:                               val = [[], [Qt.black]*num, [], [OWCurve.Ellipse]*num] 
     346                else:                               val = [[], [Qt.black]*num, [], [OWPoint.Ellipse]*num] 
    347347                val[2] = []; val[0] = [] 
    348348                varValues = getVariableValuesSorted(self.dataDomain[sizeIndex]) 
     
    406406##                color = self.discPalette[classIndices[self.rawData.domain.classVar[classValue[key]].value]] 
    407407##                for (p1, p2) in clusterLines: 
    408 ##                    self.addCurve("", color, color, 1, QwtPlotCurve.Lines, OWCurve.NoSymbol, xData = [float(shortData[p1][0]), float(shortData[p2][0])], yData = [float(shortData[p1][1]), float(shortData[p2][1])], lineWidth = width) 
     408##                    self.addCurve("", color, color, 1, QwtPlotCurve.Lines, OWPoint.NoSymbol, xData = [float(shortData[p1][0]), float(shortData[p2][0])], yData = [float(shortData[p1][1]), float(shortData[p2][1])], lineWidth = width) 
    409409##        else: 
    410410##            colorIndex = self.discPalette[classIndices[self.rawData.domain.classVar[classValue].value]] 
    411411##            for (p1, p2) in closure: 
    412 ##                self.addCurve("", color, color, 1, QwtPlotCurve.Lines, OWCurve.NoSymbol, xData = [float(shortData[p1][0]), float(shortData[p2][0])], yData = [float(shortData[p1][1]), float(shortData[p2][1])], lineWidth = width) 
     412##                self.addCurve("", color, color, 1, QwtPlotCurve.Lines, OWPoint.NoSymbol, xData = [float(shortData[p1][0]), float(shortData[p2][0])], yData = [float(shortData[p1][1]), float(shortData[p2][1])], lineWidth = width) 
    413413 
    414414    def addTip(self, x, y, attrIndices = None, dataindex = None, text = None): 
  • orange/OrangeWidgets/plot/owlegend.py

    r8413 r8423  
    2222                               PointColor : Qt.black,  
    2323                               PointSize : 8,  
    24                                PointSymbol : OWCurve.Ellipse 
     24                               PointSymbol : OWPoint.Ellipse 
    2525                               } 
    2626        self.box_rect = QRectF() 
  • orange/OrangeWidgets/plot/owpalette.py

    r8374 r8423  
    4343 
    4444class OWLineStyle: 
    45     def __init__(self,  color=Qt.black,  width=1,  type=Qt.SolidLine,  point_shape=OWCurve.Ellipse, point_size=5): 
     45    def __init__(self,  color=Qt.black,  width=1,  type=Qt.SolidLine,  point_shape=OWPoint.Ellipse, point_size=5): 
    4646        self.color = color 
    4747        self.width = width 
  • orange/OrangeWidgets/plot/owplot.py

    r8413 r8423  
    321321         
    322322    def add_curve(self, name, brushColor = Qt.black, penColor = Qt.black, size = 5, style = Qt.NoPen,  
    323                  symbol = OWCurve.Ellipse, enableLegend = False, xData = [], yData = [], showFilledSymbols = None, 
     323                 symbol = OWPoint.Ellipse, enableLegend = False, xData = [], yData = [], showFilledSymbols = None, 
    324324                 lineWidth = 1, pen = None, autoScale = 0, antiAlias = None, penAlpha = 255, brushAlpha = 255,  
    325325                 x_axis_key = xBottom, y_axis_key = yLeft): 
  • orange/OrangeWidgets/plot/owpoint.py

    r8374 r8423  
    33from PyQt4.QtCore import Qt, QPointF 
    44 
    5 from owcurve import * 
     5from orangeplot import Point 
    66 
    7 def point_item(x, y, color = Qt.black, symbol = OWCurve.Ellipse, size = 5, parent = None): 
    8     path = OWCurve.pathForSymbol(symbol, size) 
    9     item = QGraphicsPathItem(path, parent) 
    10     item.setPen(QPen(Qt.NoPen)) 
    11     item.setBrush(QBrush(color)) 
    12     item.setPos(QPointF(x, y)) 
    13     return item 
    14      
     7class OWPoint(Point): 
     8    pass 
  • source/orangeplot/CMakeLists.txt

    r8371 r8423  
    1414 
    1515#### orangeplot sources #### 
    16 set(orangeplot_SRCS plotitem.cpp curve.cpp unconnectedlinescurve.cpp plot.cpp networkcurve.cpp) 
     16set(orangeplot_SRCS plotitem.cpp point.cpp curve.cpp unconnectedlinescurve.cpp plot.cpp networkcurve.cpp) 
    1717qt4_automoc(${orangeplot_SRCS}) 
    1818 
  • source/orangeplot/curve.cpp

    r8386 r8423  
    77#include <QtCore/qmath.h> 
    88#include <QtCore/QtConcurrentRun> 
     9#include "point.h" 
    910 
    1011Curve::Curve(const QList< double >& xData, const QList< double >& yData, QGraphicsItem* parent, QGraphicsScene* scene): PlotItem(parent, scene) 
     
    4748  for (int i = 0; i < m; ++i) 
    4849  { 
    49     m_pointItems << new QGraphicsPathItem(this); 
     50    m_pointItems << new Point(m_symbol, m_color, m_pointSize, this); 
    5051  } 
    5152   
     
    8990  Q_ASSERT(m_pointItems.size() == n); 
    9091   
    91   m_path = pathForSymbol(m_symbol, m_pointSize); 
    9292   
    9393  // Move, resize, reshape and/or recolor the items 
     
    104104  if (m_needsUpdate & (UpdateZoom | UpdateBrush | UpdatePen | UpdateSize | UpdateSymbol) ) 
    105105  { 
    106     updateItems(m_pointItems, Updater(1.0/m_zoom_factor, m_pen, m_brush, m_path)); 
     106    updateItems(m_pointItems, PointUpdater(m_symbol, m_color, m_pointSize, Point::DisplayPath, 1.0/m_zoom_factor), UpdateSymbol); 
    107107  } 
    108108  m_needsUpdate = 0; 
     
    125125    int n = m_data.size(); 
    126126    QBrush brush(m_color); 
    127     m_path = pathForSymbol(m_symbol, m_pointSize); 
    128127    QPointF p; 
    129128    for (int i = 0; i < n; ++i) 
    130129    { 
    131       QGraphicsPathItem* item = m_pointItems[i]; 
     130      Point* item = m_pointItems[i]; 
    132131      DataPoint& point = m_data[i]; 
    133       item->setPath(m_path); 
    134132      p = QPointF(point.x, point.y); 
    135133      item->setPos(p * m_graphTransform); 
    136       item->setBrush(brush); 
    137     } 
     134      } 
    138135  } 
    139136  m_needsUpdate = 0; 
     
    141138 
    142139 
    143 QGraphicsItem* Curve::pointItem(qreal x, qreal y, int size, QGraphicsItem* parent) 
     140Point* Curve::pointItem(qreal x, qreal y, int size, QGraphicsItem* parent) 
    144141{ 
    145142  if (size == 0) 
     
    151148    parent = this; 
    152149  } 
    153   QGraphicsPathItem* item = new QGraphicsPathItem(pathForSymbol(symbol(),size), parent); 
     150  Point* item = new Point(m_symbol, m_color, m_pointSize, parent); 
    154151  item->setPos(x,y); 
    155   item->setPen(Qt::NoPen); 
    156   item->setBrush(m_color); 
    157152  return item; 
    158 } 
    159  
    160 QPainterPath Curve::pathForSymbol(int symbol, int size) 
    161 { 
    162   QPainterPath path; 
    163   qreal d = 0.5 * size; 
    164   switch (symbol) 
    165   { 
    166     case NoSymbol: 
    167       break; 
    168        
    169     case Ellipse: 
    170       path.addEllipse(-d,-d,2*d,2*d); 
    171       break; 
    172        
    173     case Rect: 
    174       path.addRect(-d,-d,2*d,2*d); 
    175       break; 
    176        
    177     case Diamond: 
    178       path.addRect(-d,-d,2*d,2*d); 
    179       path = QTransform().rotate(45).map(path); 
    180       break; 
    181        
    182     case Triangle: 
    183     case UTriangle: 
    184       path = trianglePath(d, 0); 
    185       break; 
    186        
    187     case DTriangle: 
    188       path = trianglePath(d, 180); 
    189       break; 
    190        
    191     case LTriangle: 
    192       path = trianglePath(d, -90); 
    193       break; 
    194      
    195     case RTriangle: 
    196       path = trianglePath(d, 90); 
    197       break; 
    198  
    199     case Cross: 
    200       path = crossPath(d, 0); 
    201       break; 
    202      
    203     case XCross: 
    204       path = crossPath(d, 45); 
    205       break; 
    206        
    207     case HLine: 
    208       path.moveTo(-d,0); 
    209       path.lineTo(d,0); 
    210       break; 
    211        
    212     case VLine: 
    213       path.moveTo(0,-d); 
    214       path.lineTo(0,d); 
    215       break; 
    216        
    217     case Star1: 
    218       path.addPath(crossPath(d,0)); 
    219       path.addPath(crossPath(d,45)); 
    220       break; 
    221        
    222     case Star2: 
    223       path = hexPath(d, true); 
    224       break; 
    225        
    226     case Hexagon: 
    227       path = hexPath(d, false); 
    228       break; 
    229        
    230     default: 
    231       qWarning() << "Unsupported symbol" << symbol; 
    232   } 
    233   return path; 
    234153} 
    235154 
     
    469388} 
    470389 
    471 QPainterPath Curve::trianglePath(double d, double rot) { 
    472     QPainterPath path; 
    473     path.moveTo(-d, d*sqrt(3)/3); 
    474     path.lineTo(d, d*sqrt(3)/3); 
    475     path.lineTo(0, -2*d*sqrt(3)/3); 
    476     path.closeSubpath(); 
    477     return QTransform().rotate(rot).map(path); 
    478 } 
    479  
    480 QPainterPath Curve::crossPath(double d, double rot) 
    481 { 
    482     QPainterPath path; 
    483     path.lineTo(0,d); 
    484     path.moveTo(0,0); 
    485     path.lineTo(0,-d); 
    486     path.moveTo(0,0);  
    487     path.lineTo(d,0); 
    488     path.moveTo(0,0); 
    489     path.lineTo(-d,0); 
    490     return QTransform().rotate(rot).map(path); 
    491 } 
    492 QPainterPath Curve::hexPath(double d, bool star) { 
    493     QPainterPath path; 
    494     if (!star) 
    495     { 
    496         path.moveTo(d,0); 
    497     } 
    498     for (int i = 0; i < 6; ++i) 
    499     { 
    500         path.lineTo( d * cos(M_PI/3*i), d*sin(M_PI/3*i) ); 
    501         if (star) 
    502         { 
    503             path.lineTo(0,0); 
    504         } 
    505     } 
    506     path.closeSubpath(); 
    507     return path; 
    508 } 
    509  
    510390void Curve::setDirty(Curve::UpdateFlags flags) 
    511391{ 
     
    525405    checkForUpdate(); 
    526406} 
    527  
    528 void Curve::updateItems(const QList< QGraphicsPathItem* >& items, Updater updater) 
    529 { 
    530     if (m_currentUpdate.isRunning()) 
    531     { 
    532         m_currentUpdate.cancel(); 
    533         m_currentUpdate.waitForFinished(); 
    534     } 
    535     m_currentUpdate = QtConcurrent::map(items, updater); 
    536 } 
  • source/orangeplot/curve.h

    r8386 r8423  
    33 
    44#include "plotitem.h" 
     5#include "point.h" 
    56 
    67#include <QtGui/QPen> 
     
    1314  qreal x; 
    1415  qreal y; 
     16}; 
     17 
     18struct ScaleUpdater 
     19{ 
     20    ScaleUpdater(qreal scale) {m_scale = scale;} 
     21    void operator()(QGraphicsItem* item) {item->setScale(m_scale);} 
     22     
     23private: 
     24    qreal m_scale; 
     25}; 
     26 
     27struct PointUpdater 
     28{ 
     29    PointUpdater(int symbol, QColor color, int size, Point::DisplayMode mode, qreal scale) 
     30    { 
     31        m_symbol = symbol; 
     32        m_color = color; 
     33        m_size = size; 
     34        m_mode = mode; 
     35        m_scale = scale; 
     36    } 
     37     
     38    void operator()(Point* point) 
     39    { 
     40        point->set_symbol(m_symbol); 
     41        point->set_color(m_color); 
     42        point->set_size(m_size); 
     43        point->set_display_mode(m_mode); 
     44        point->setScale(m_scale); 
     45    } 
     46     
     47    private: 
     48     int m_symbol; 
     49     QColor m_color; 
     50     int m_size; 
     51     Point::DisplayMode m_mode; 
     52     qreal m_scale; 
    1553}; 
    1654 
     
    4583   
    4684public: 
    47   /** 
    48    * @brief Point symbol 
    49    *  
    50    * The symbols list here matches the one from QwtPlotCurve.  
    51    **/ 
    52   enum Symbol { 
    53     NoSymbol = -1, 
    54     Ellipse = 0, 
    55     Rect = 1, 
    56     Diamond = 2, 
    57     Triangle = 3, 
    58     DTriangle = 4, 
    59     UTriangle = 5, 
    60     LTriangle = 6, 
    61     RTriangle = 7, 
    62     Cross = 8, 
    63     XCross = 9, 
    64     HLine = 10, 
    65     VLine = 11, 
    66     Star1 = 12, 
    67     Star2 = 13, 
    68     Hexagon = 14, 
    69     UserStyle = 1000 
    70   }; 
    71    
    7285  enum Style { 
    7386    NoCurve = Qt::NoPen, 
     
    118131  virtual void updateAll(); 
    119132   
    120   void updateItems(const QList< QGraphicsPathItem* >& items, Updater updater); 
    121   template <class T> 
    122   void updateItems(const QList<T*>& items, Updater updater); 
    123    
    124133  /** 
    125134   * @brief ... 
     
    131140   * @return QGraphicsItem* 
    132141   **/ 
    133   QGraphicsItem* pointItem(qreal x, qreal y, int size = 0, QGraphicsItem* parent = 0); 
     142  Point* pointItem(qreal x, qreal y, int size = 0, QGraphicsItem* parent = 0); 
    134143   
    135144  QColor color() const; 
     
    174183  qreal min_y_value() const; 
    175184     
    176   /** 
    177    * Creates a path from a symbol and a size 
    178    * 
    179    * @param symbol the point symbol to use 
    180    * @param size the size of the resulting path 
    181    * @return a path that can be used in a QGraphicsPathItem 
    182    **/ 
    183   static QPainterPath pathForSymbol(int symbol, int size); 
    184  
    185185  enum UpdateFlag 
    186186  { 
     
    200200  void setDirty(UpdateFlags flags = UpdateAll); 
    201201   
     202  template <class Sequence, class Updater> 
     203  void updateItems(Sequence& sequence, Updater updater, Curve::UpdateFlag flag); 
     204   
    202205private:     
    203206 
     
    212215  void changeContinuous(); 
    213216  void updateBounds(); 
    214    
    215   static QPainterPath trianglePath(double d, double rot); 
    216   static QPainterPath crossPath(double d, double rot); 
    217   static QPainterPath hexPath(double d, bool star); 
    218217   
    219218  QColor m_color; 
     
    225224  QTransform m_graphTransform; 
    226225  QPainterPath m_path; 
    227   QList<QGraphicsPathItem*> m_pointItems; 
     226  QList<Point*> m_pointItems; 
    228227  UpdateFlags m_needsUpdate; 
    229228  bool m_autoUpdate; 
     
    237236  QBrush m_brush; 
    238237  double m_zoom_factor; 
    239   QFuture<void> m_currentUpdate; 
    240 }; 
    241  
    242 template <class T> 
    243 void Curve::updateItems(const QList< T* >& items, Updater updater) 
    244 { 
    245     updateItems(reinterpret_cast< const QList<QGraphicsPathItem*>& >(items), updater); 
     238  QMap<UpdateFlag, QFuture<void> > m_currentUpdate; 
     239}; 
     240 
     241template <class Sequence, class Updater> 
     242void Curve::updateItems(Sequence& sequence, Updater updater, Curve::UpdateFlag flag) 
     243{ 
     244    if (m_currentUpdate.contains(flag) && m_currentUpdate[flag].isRunning()) 
     245    { 
     246        m_currentUpdate[flag].cancel(); 
     247    } 
     248    m_currentUpdate[flag] = QtConcurrent::map(sequence, updater); 
    246249} 
    247250 
  • source/orangeplot/curve.sip

    r8382 r8423  
    5252 
    5353public: 
    54  
    55 enum Symbol { 
    56     NoSymbol = -1, 
    57     Ellipse = 0, 
    58     Rect = 1, 
    59     Diamond = 2, 
    60     Triangle = 3, 
    61     DTriangle = 4, 
    62     UTriangle = 5, 
    63     LTriangle = 6, 
    64     RTriangle = 7, 
    65     Cross = 8, 
    66     XCross = 9, 
    67     HLine = 10, 
    68     VLine = 11, 
    69     Star1 = 12, 
    70     Star2 = 13, 
    71     Hexagon = 14, 
    72     UserStyle = 1000 
    73   }; 
    74  
    75  
    7654  enum Style { 
    7755    NoCurve = Qt::NoPen, 
     
    9270  virtual void updateProperties(); 
    9371  void updateAll(); 
    94    
    95   void updateItems(QList<QAbstractGraphicsShapeItem*> items, Updater u); 
    96    
    97   QGraphicsItem* pointItem(qreal x, qreal y, int size = 0, QGraphicsItem* parent = 0); 
     72     
     73  Point* pointItem(qreal x, qreal y, int size = 0, QGraphicsItem* parent = 0); 
    9874   
    9975  QColor color() const; 
     
    129105  bool autoUpdate() const; 
    130106  void setAutoUpdate(bool autoUpdate); 
    131  
    132   static QPainterPath pathForSymbol(int symbol, int size); 
    133    
    134   qreal max_x_value() const; 
    135   qreal min_x_value() const; 
    136   qreal max_y_value() const; 
    137   qreal min_y_value() const; 
    138107   
    139108  enum UpdateFlag 
  • source/orangeplot/networkcurve.cpp

    r8419 r8423  
    33#include <QtCore/QMap> 
    44#include <QtCore/QList> 
     5 
     6#include <QtCore/qmath.h> 
     7 
     8NodeItem::NodeItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent): Point(symbol, color, size, parent) 
     9{ 
     10    set_index(index); 
     11} 
     12 
     13NodeItem::~NodeItem() 
     14{ 
     15 
     16} 
     17 
     18void NodeItem::set_index(int index) 
     19{ 
     20    m_index = index; 
     21} 
     22 
     23int NodeItem::index() const 
     24{ 
     25    return m_index; 
     26} 
     27 
     28void NodeItem::set_graph_transform(const QTransform& transform) 
     29{ 
     30    m_graph_transform = transform; 
     31} 
     32 
     33QTransform NodeItem::graph_transform() const 
     34{ 
     35    return m_graph_transform; 
     36} 
     37 
     38void NodeItem::set_x(double x) 
     39{ 
     40    set_coordinates(x, m_y); 
     41} 
     42 
     43void NodeItem::set_y(double y) 
     44{ 
     45    set_coordinates(m_x, y); 
     46} 
     47 
     48void NodeItem::set_coordinates(double x, double y) 
     49{ 
     50    m_x = x; 
     51    m_y = y; 
     52    setPos(QPointF(m_x, m_y) * m_graph_transform); 
     53} 
     54 
     55double NodeItem::x() const 
     56{ 
     57    return m_x; 
     58} 
     59 
     60double NodeItem::y() const 
     61{ 
     62    return m_y; 
     63} 
     64 
     65void NodeItem::set_label(const QString& label) 
     66{ 
     67    m_label = label; 
     68} 
     69 
     70QString NodeItem::label() const 
     71{ 
     72    return m_label; 
     73} 
     74 
     75void NodeItem::set_tooltip(const QString& tooltip) 
     76{ 
     77    setToolTip(tooltip); 
     78} 
     79 
     80void NodeItem::set_uuid(int uuid) 
     81{ 
     82    m_uuid = uuid; 
     83} 
     84 
     85int NodeItem::uuid() const 
     86{ 
     87    return m_uuid; 
     88} 
     89 
     90void NodeItem::add_connected_edge(EdgeItem* edge) 
     91{ 
     92    m_connected_edges << edge; 
     93} 
     94 
     95void NodeItem::remove_connected_edge(EdgeItem* edge) 
     96{ 
     97    m_connected_edges.removeAll(edge); 
     98} 
     99 
     100EdgeItem::EdgeItem(NodeItem* u, NodeItem* v, QGraphicsItem* parent, QGraphicsScene* scene): QGraphicsLineItem(parent, scene) 
     101{ 
     102    set_u(u); 
     103    set_v(v); 
     104} 
     105 
     106EdgeItem::~EdgeItem() 
     107{ 
     108 
     109} 
     110 
     111void EdgeItem::set_u(NodeItem* item) 
     112{ 
     113    m_u = item; 
     114} 
     115 
     116NodeItem* EdgeItem::u() 
     117{ 
     118    return m_u; 
     119} 
     120 
     121void EdgeItem::set_v(NodeItem* item) 
     122{ 
     123    m_v = item; 
     124} 
     125 
     126NodeItem* EdgeItem::v() 
     127{ 
     128    return m_v; 
     129} 
     130 
     131void EdgeItem::set_tooltip(const QString& tooltip) 
     132{ 
     133    setToolTip(tooltip); 
     134} 
     135 
     136void EdgeItem::set_label(const QString& label) 
     137{ 
     138    m_label = label; 
     139} 
     140 
     141QString EdgeItem::label() const 
     142{ 
     143    return m_label; 
     144} 
     145 
     146void EdgeItem::set_links_index(int index) 
     147{ 
     148    m_links_index = index; 
     149} 
     150 
     151int EdgeItem::links_index() const 
     152{ 
     153    return m_links_index; 
     154} 
     155 
     156void EdgeItem::set_arrow(EdgeItem::Arrow arrow, bool enable) 
     157{ 
     158    if (enable) 
     159    { 
     160        set_arrows(arrows() | arrow); 
     161    } 
     162    else 
     163    { 
     164        set_arrows(arrows() & ~arrow); 
     165    } 
     166} 
     167 
     168EdgeItem::Arrows EdgeItem::arrows() 
     169{ 
     170    return m_arrows; 
     171} 
     172 
     173void EdgeItem::set_arrows(EdgeItem::Arrows arrows) 
     174{ 
     175    m_arrows = arrows; 
     176    // TODO: Update the QGraphicsItem element, add arrows 
     177} 
     178 
     179void EdgeItem::set_weight(double weight) 
     180{ 
     181    m_weight = weight; 
     182    QPen p = pen(); 
     183    p.setWidthF(weight); 
     184    setPen(p); 
     185} 
     186 
     187double EdgeItem::weight() const 
     188{ 
     189    return m_weight; 
     190} 
    5191 
    6192NetworkCurve::NetworkCurve(QGraphicsItem* parent, QGraphicsScene* scene): Curve(parent, scene) 
     
    19205    const QTransform t = graphTransform(); 
    20206    int m, n; 
    21      
    22     const Nodes nodes = get_nodes(); 
    23      
    24     if (m_vertex_items.keys() != nodes.keys()) 
    25     { 
    26         qDeleteAll(m_vertex_items); 
    27         m_vertex_items.clear(); 
    28         Nodes::ConstIterator it = nodes.constBegin(); 
    29         Nodes::ConstIterator end = nodes.constEnd(); 
    30         for (; it != end; ++it) 
    31         { 
    32             m_vertex_items.insert(it.key(), new QGraphicsPathItem(this)); 
    33         } 
    34     } 
    35      
    36     NodeItem node; 
    37     QGraphicsPathItem* item; 
    38     Nodes::ConstIterator nit = nodes.constBegin(); 
    39     Nodes::ConstIterator nend = nodes.constEnd(); 
     207 
     208    Nodes::ConstIterator nit = m_nodes.constBegin(); 
     209    Nodes::ConstIterator nend = m_nodes.constEnd(); 
    40210    for (; nit != nend; ++nit) 
    41211    { 
    42         node = nit.value(); 
    43         item = m_vertex_items[nit.key()]; 
    44         item->setPos( t.map(QPointF(node.x, node.y)) ); 
    45         item->setBrush(brush()); 
    46         item->setPen(node.pen); 
    47         item->setToolTip(node.tooltip); 
    48         item->setPath(pathForSymbol(node.style, node.size)); 
    49     } 
    50      
    51     Q_ASSERT(m_vertex_items.size() == nodes.size()); 
    52      
    53     const Edges edges = get_edges(); 
    54      
    55     n = edges.size(); 
    56     m = m_edge_items.size(); 
    57      
    58     for (int i = n; i < m; ++i) 
    59     { 
    60         delete m_edge_items.takeLast(); 
    61     } 
    62      
    63     for (int i = m; i < n; ++i) 
    64     { 
    65         m_edge_items << new QGraphicsLineItem(this); 
    66     } 
    67      
    68     Q_ASSERT(m_edge_items.size() == edges.size()); 
     212        NodeItem* node = nit.value(); 
     213        node->setPos( t.map(QPointF(node->x(), node->y())) ); 
     214    } 
    69215     
    70216    QLineF line; 
    71     QGraphicsLineItem* line_item; 
    72     n = edges.size(); 
     217    n = m_edges.size(); 
    73218    for (int i = 0; i < n; ++i) 
    74219    { 
    75         EdgeItem edge = edges[i]; 
    76         node = nodes[edge.u->index]; 
    77         line.setP1(QPointF(node.x, node.y)); 
    78         node = nodes[edge.v->index]; 
    79         line.setP2(QPointF(node.x, node.y)); 
    80         line_item = m_edge_items[i]; 
    81         line_item->setLine( t.map(line) ); 
    82         line_item->setPen(edges[i].pen); 
     220        EdgeItem* edge = m_edges[i]; 
     221        NodeItem* node = m_nodes[edge->u()->index()]; 
     222        line.setP1(QPointF(node->x(), node->y())); 
     223        node = m_nodes[edge->v()->index()]; 
     224        line.setP2(QPointF(node->x(), node->y())); 
     225        edge->setLine(line * t); 
    83226    } 
    84227} 
     
    88231    QRectF r; 
    89232    bool first = true; 
    90     foreach (const NodeItem& node, get_nodes()) 
     233    foreach (const NodeItem* node, m_nodes) 
    91234    { 
    92235        if (first) 
    93236        { 
    94             r = QRectF(node.x, node.y, 0, 0); 
     237            r = QRectF(node->x(), node->y(), 0, 0); 
    95238            first = false; 
    96239        } 
    97240        else 
    98241        { 
    99             r.setTop( qMin(r.top(), node.y) ); 
    100             r.setBottom( qMax(r.bottom(), node.y) ); 
    101             r.setLeft( qMin(r.left(), node.x) ); 
    102             r.setRight( qMax(r.right(), node.y) ); 
     242            r.setTop( qMin(r.top(), node->y()) ); 
     243            r.setBottom( qMax(r.bottom(), node->y()) ); 
     244            r.setLeft( qMin(r.left(), node->x()) ); 
     245            r.setRight( qMax(r.right(), node->x()) ); 
    103246        } 
    104247    } 
     
    110253{ 
    111254    int i, j; 
    112     NodeItem u, v; 
    113     EdgeItem edge; 
    114     Nodes nodes = get_nodes(); 
    115     Edges edges = get_edges(); 
     255    NodeItem *u, *v; 
     256    EdgeItem *edge; 
    116257    QRectF data_rect = dataRect(); 
    117258 
    118259    QMap<int, DataPoint> disp; 
    119     foreach (const NodeItem& node, get_nodes()) 
     260    foreach (const NodeItem* node, m_nodes) 
    120261    { 
    121262        DataPoint point; 
    122263        point.x = 0; 
    123264        point.y = 0; 
    124         disp[node.index] = point; 
     265        disp[node->index()] = point; 
    125266    } 
    126267 
    127268    qreal area = data_rect.width() * data_rect.height(); 
    128269 
    129     qreal k2 = area / nodes.size(); 
     270    qreal k2 = area / m_nodes.size(); 
    130271    qreal k = sqrt(k2); 
    131272    qreal kk = 2 * k; 
     
    146287 
    147288        // calculate repulsive force 
    148         Nodes::ConstIterator uit = nodes.constBegin(); 
    149         Nodes::ConstIterator uend = nodes.constEnd(); 
     289        Nodes::ConstIterator uit = m_nodes.constBegin(); 
     290        Nodes::ConstIterator uend = m_nodes.constEnd(); 
    150291        for (; uit != uend; ++uit) 
    151292        { 
     
    156297            { 
    157298                v = vit.value(); 
    158                 qreal difx = u.x - v.x; 
    159                 qreal dify = u.y - v.y; 
     299                qreal difx = u->x() - v->x(); 
     300                qreal dify = u->y() - v->y(); 
    160301 
    161302                qreal dif2 = difx * difx + dify * dify; 
     
    169310                    qreal dY = dify * k2 / dif2; 
    170311 
    171                     disp[u.index].x = disp[u.index].x + dX; 
    172                     disp[u.index].y = disp[u.index].y + dY; 
    173  
    174                     disp[v.index].x = disp[v.index].x - dX; 
    175                     disp[v.index].y = disp[v.index].y - dY; 
     312                    disp[u->index()].x = disp[u->index()].x + dX; 
     313                    disp[u->index()].y = disp[u->index()].y + dY; 
     314 
     315                    disp[v->index()].x = disp[v->index()].x - dX; 
     316                    disp[v->index()].y = disp[v->index()].y - dY; 
    176317                } 
    177318            } 
     
    181322        if (weighted) 
    182323        { 
    183             for (j = 0; j < edges.size(); ++j) 
     324            for (j = 0; j < m_edges.size(); ++j) 
    184325            { 
    185                 edge = edges[j]; 
    186                 qreal difx = edge.u->x - edge.v->x; 
    187                 qreal dify = edge.u->y - edge.v->y; 
     326                edge = m_edges[j]; 
     327                qreal difx = edge->u()->x() - edge->v()->x(); 
     328                qreal dify = edge->u()->y() - edge->v()->y(); 
    188329 
    189330                qreal dif = sqrt(difx * difx + dify * dify); 
    190331 
    191                 qreal dX = difx * dif / k * edge.weight; 
    192                 qreal dY = dify * dif / k * edge.weight; 
    193  
    194                 disp[edge.u->index].x = disp[edge.u->index].x + dX; 
    195                 disp[edge.u->index].y = disp[edge.u->index].y + dY; 
    196  
    197                 disp[edge.v->index].x = disp[edge.v->index].x - dX; 
    198                 disp[edge.v->index].y = disp[edge.v->index].y - dY; 
     332                qreal dX = difx * dif / k * edge->weight(); 
     333                qreal dY = dify * dif / k * edge->weight(); 
     334 
     335                disp[edge->u()->index()].x = disp[edge->u()->index()].x + dX; 
     336                disp[edge->u()->index()].y = disp[edge->u()->index()].y + dY; 
     337 
     338                disp[edge->v()->index()].x = disp[edge->v()->index()].x - dX; 
     339                disp[edge->v()->index()].y = disp[edge->v()->index()].y - dY; 
    199340            } 
    200341        } 
    201342        else 
    202343        { 
    203             for (j = 0; j < edges.size(); ++j) 
     344            for (j = 0; j < m_edges.size(); ++j) 
    204345            { 
    205                 edge = edges[j]; 
    206                 qreal difx = edge.u->x - edge.v->x; 
    207                 qreal dify = edge.u->y - edge.v->y; 
     346                edge = m_edges[j]; 
     347                qreal difx = edge->u()->x() - edge->v()->x(); 
     348                qreal dify = edge->u()->y() - edge->v()->y(); 
    208349 
    209350                qreal dif = sqrt(difx * difx + dify * dify); 
     
    212353                qreal dY = dify * dif / k; 
    213354 
    214                 disp[edge.u->index].x = disp[edge.u->index].x + dX; 
    215                 disp[edge.u->index].y = disp[edge.u->index].y + dY; 
    216  
    217                 disp[edge.v->index].x = disp[edge.v->index].x - dX; 
    218                 disp[edge.v->index].y = disp[edge.v->index].y - dY; 
     355                disp[edge->u()->index()].x = disp[edge->u()->index()].x + dX; 
     356                disp[edge->u()->index()].y = disp[edge->u()->index()].y + dY; 
     357 
     358                disp[edge->v()->index()].x = disp[edge->v()->index()].x - dX; 
     359                disp[edge->v()->index()].y = disp[edge->v()->index()].y - dY; 
    219360            } 
    220361        } 
    221362        // limit the maximum displacement to the temperature t 
    222363        // and then prevent from being displaced outside frame 
    223         Nodes::Iterator nit = nodes.begin(); 
    224         for (; nit != nodes.end(); ++nit) 
     364        Nodes::Iterator nit = m_nodes.begin(); 
     365        for (; nit != m_nodes.end(); ++nit) 
    225366        { 
    226367            u = nit.value(); 
    227             qreal dif = sqrt(disp[u.index].x * disp[u.index].x + disp[u.index].y * disp[u.index].y); 
     368            qreal dif = sqrt(disp[u->index()].x * disp[u->index()].x + disp[u->index()].y * disp[u->index()].y); 
    228369 
    229370            if (dif == 0) 
    230371                dif = 1; 
    231372 
    232             qDebug() << i << " old " << u.x << " " << u.y; 
    233             u.x = u.x + (disp[u.index].x * std::min(fabs(disp[u.index].x), temperature) / dif); 
    234             u.y = u.y + (disp[u.index].y * std::min(fabs(disp[u.index].y), temperature) / dif); 
    235             qDebug() << i << " new " << u.x << " " << u.y; 
     373            qDebug() << i << " old " << u->x() << " " << u->y(); 
     374            u->setX(u->x() + (disp[u->index()].x * qMin(fabs(disp[u->index()].x), temperature) / dif)); 
     375            u->setY(u->y() + (disp[u->index()].y * qMin(fabs(disp[u->index()].y), temperature) / dif)); 
     376            qDebug() << i << " new " << u->x() << " " << u->y(); 
    236377        } 
    237378 
     
    241382    return 0; 
    242383} 
     384 
     385void NetworkCurve::set_edges(NetworkCurve::Edges edges) 
     386{ 
     387    qDeleteAll(m_edges); 
     388    m_edges = edges; 
     389} 
     390 
     391void NetworkCurve::set_nodes(NetworkCurve::Nodes nodes) 
     392{ 
     393    qDeleteAll(m_nodes); 
     394    m_nodes = nodes; 
     395} 
     396 
     397 
  • source/orangeplot/networkcurve.h

    r8419 r8423  
    33 
    44#include "curve.h" 
    5 #include <math.h> 
     5#include "point.h" 
    66 
    7 struct NodeItem 
     7class EdgeItem; 
     8 
     9class NodeItem : public Point 
    810{ 
    9     double x; 
    10     double y; 
     11public: 
     12    NodeItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent = 0); 
     13    virtual ~NodeItem(); 
    1114     
    12     int index; 
    13     bool marked; 
    14     bool show; 
    15     bool highlight; 
    16     QString label; 
    17     QString tooltip; 
    18     int uuid; 
     15    void set_coordinates(double x, double y); 
     16    void set_x(double x); 
     17    void set_y(double y); 
     18    double x() const; 
     19    double y() const; 
    1920     
    20     QPixmap* image; 
    21     QPen pen; 
    22     QColor nocolor; 
    23     QColor color; 
    24     int size; 
    25     int style; 
     21    void set_graph_transform(const QTransform& transform); 
     22    QTransform graph_transform() const; 
     23     
     24    void set_index(int index); 
     25    int index() const; 
     26     
     27    void set_label(const QString& label); 
     28    QString label() const; 
     29    void set_tooltip(const QString& tooltip); 
     30     
     31    void set_uuid(int uuid); 
     32    int uuid() const; 
     33     
     34    /** 
     35     * @brief Connect an edge to this node 
     36     *  
     37     * A connected edge is automatically updated whenever this node is moved 
     38     * 
     39     * @param edge the edge to be connected 
     40     **/ 
     41    void add_connected_edge(EdgeItem* edge); 
     42    void remove_connected_edge(EdgeItem* edge); 
     43     
     44private: 
     45    double m_x; 
     46    double m_y; 
     47     
     48    int m_index; 
     49    bool m_marked; 
     50    bool m_highlight; 
     51    QString m_label; 
     52    int m_uuid; 
     53     
     54    QList<EdgeItem*> m_connected_edges; 
     55     QTransform m_graph_transform; 
    2656}; 
    2757 
    28 struct EdgeItem 
     58struct EdgeItem : public QGraphicsLineItem 
    2959{ 
    30     NodeItem* u; 
    31     NodeItem* v; 
    32     int links_index; 
    33     bool arrowu; 
    34     bool arrowv; 
    35     double weight; 
    36     QString label; 
    37     QPen pen; 
     60public: 
     61    enum Arrow 
     62    { 
     63        ArrowU = 0x01, 
     64        ArrowV = 0x02 
     65    }; 
     66    Q_DECLARE_FLAGS(Arrows, Arrow) 
     67     
     68    EdgeItem(NodeItem* u, NodeItem* v, QGraphicsItem* parent = 0, QGraphicsScene* scene = 0); 
     69    virtual ~EdgeItem(); 
     70    
     71    void set_u(NodeItem* item); 
     72    NodeItem* u(); 
     73    void set_v(NodeItem* item); 
     74    NodeItem* v(); 
     75     
     76    void set_label(const QString& label); 
     77    QString label() const; 
     78    void set_tooltip(const QString& tooltip); 
     79     
     80    void set_links_index(int index); 
     81    int links_index() const; 
     82     
     83    void set_weight(double weight); 
     84    double weight() const; 
     85     
     86    void set_arrows(Arrows arrows); 
     87    void set_arrow(Arrow arrow, bool enable); 
     88     Arrows arrows(); 
     89     
     90private: 
     91    Arrows m_arrows; 
     92    NodeItem* m_u; 
     93    NodeItem* m_v; 
     94    int m_links_index; 
     95    double m_weight; 
     96    QString m_label; 
    3897}; 
    3998 
     
    41100{ 
    42101public: 
    43     typedef QList<EdgeItem> Edges; 
    44     typedef QMap<int, NodeItem> Nodes; 
     102    typedef QList<EdgeItem*> Edges; 
     103    typedef QMap<int, NodeItem*> Nodes; 
    45104 
    46105    NetworkCurve(QGraphicsItem* parent = 0, QGraphicsScene* scene = 0); 
     
    48107     
    49108    virtual void updateProperties(); 
    50      
    51     virtual Nodes get_nodes() const = 0; 
    52     virtual Edges get_edges() const = 0; 
    53  
    54109    virtual QRectF dataRect() const; 
    55110     
    56111    int fr(int steps, bool weighted, double temperature, double cooling); 
     112     
     113    void set_nodes(Nodes nodes); 
     114    void set_edges(Edges edges); 
    57115 
    58116private: 
    59     QMap<int, QGraphicsPathItem*> m_vertex_items; 
    60     QList<QGraphicsLineItem*> m_edge_items; 
     117    Nodes m_nodes; 
     118    Edges m_edges; 
    61119}; 
    62120 
  • source/orangeplot/networkcurve.sip

    r8419 r8423  
    33%End 
    44 
    5 struct NodeItem 
     5class NodeItem : Point 
    66{ 
    7     double x; 
    8     double y; 
    9  
    10     int index; 
    11     bool marked; 
    12     bool show; 
    13     bool highlight; 
    14     QString label; 
    15     QString tooltip; 
    16     int uuid; 
     7public: 
     8    NodeItem(int index, int symbol, QColor color, int size, QGraphicsItem* parent /TransferThis/ = 0); 
     9    virtual ~NodeItem(); 
    1710     
    18     QPixmap* image; 
    19     QPen pen; 
    20     QColor nocolor; 
    21     QColor color; 
    22     int size; 
    23     int style; 
     11    void set_coordinates(double x, double y); 
     12    void set_x(double x); 
     13    void set_y(double y); 
     14    double x() const; 
     15    double y() const; 
     16     
     17    void set_graph_transform(const QTransform& transform); 
     18    QTransform graph_transform() const; 
     19     
     20    void set_index(int index); 
     21    int index() const; 
     22     
     23    void set_label(const QString& label); 
     24    QString label() const; 
     25    void set_tooltip(const QString& tooltip); 
     26     
     27    void set_uuid(int uuid); 
     28    int uuid() const; 
     29     
     30    void add_connected_edge(EdgeItem* edge); 
     31    void remove_connected_edge(EdgeItem* edge); 
    2432}; 
    2533 
    26 struct EdgeItem 
     34class EdgeItem : QGraphicsLineItem 
    2735{ 
    28     NodeItem* u; 
    29     NodeItem* v; 
    30     int links_index; 
    31     bool arrowu; 
    32     bool arrowv; 
    33     double weight; 
    34     QString label; 
    35     QPen pen; 
     36public: 
     37    enum Arrow 
     38    { 
     39        ArrowU = 0x01, 
     40        ArrowV = 0x02 
     41    }; 
     42    typedef QFlags<EdgeItem::Arrow> Arrows; 
     43     
     44    EdgeItem(NodeItem* u, NodeItem* v, QGraphicsItem* parent /TransferThis/ = 0, QGraphicsScene* scene /TransferThis/ = 0); 
     45    virtual ~EdgeItem(); 
     46     
     47    void set_u(NodeItem* item); 
     48    NodeItem* u(); 
     49    void set_v(NodeItem* item); 
     50    NodeItem* v(); 
     51     
     52    void set_label(const QString& label); 
     53    QString label() const; 
     54    void set_tooltip(const QString& tooltip); 
     55     
     56    void set_links_index(int index); 
     57    int links_index() const; 
     58     
     59    void set_weight(double weight); 
     60    double weight() const; 
     61     
     62    void set_arrows(EdgeItem::Arrows arrows); 
     63    void set_arrow(EdgeItem::Arrow arrow, bool enable); 
    3664}; 
    3765 
    3866class NetworkCurve : Curve 
    3967{ 
     68public: 
     69    typedef QList<EdgeItem*> Edges /NoTypeName/; 
     70    typedef QMap<int, NodeItem*> Nodes /NoTypeName/; 
    4071 
    41 %TypeHeaderCode 
    42 #include "networkcurve.h" 
    43 %End 
    44  
    45 public: 
    46     typedef QMap<int, NodeItem> Nodes; 
    47     typedef QList<EdgeItem> Edges; 
    48      
    4972    NetworkCurve(QGraphicsItem* parent /TransferThis/ = 0, QGraphicsScene* scene /TransferThis/ = 0); 
    5073    virtual ~NetworkCurve(); 
    5174     
    5275    virtual void updateProperties(); 
    53      
    54     virtual NetworkCurve::Edges get_edges() const = 0; 
    55     virtual NetworkCurve::Nodes get_nodes() const = 0; 
    56  
    5776    virtual QRectF dataRect() const; 
    5877     
    5978    int fr(int steps, bool weighted, double temperature, double cooling); 
     79     
     80    void set_nodes(QMap<int, NodeItem*> nodes); 
     81    void set_edges(Edges edges); 
    6082}; 
     83 
  • source/orangeplot/orangeplot.sip

    r8370 r8423  
    33%Import QtGui/QtGuimod.sip 
    44 
     5%Include types.sip 
    56%Include plot.sip 
    67%Include plotitem.sip 
     8%Include point.sip 
    79%Include curve.sip 
    810%Include unconnectedlinescurve.sip 
Note: See TracChangeset for help on using the changeset viewer.