An abstract layer to plot AbstractLine. More...

#include <LineLayer.h>

Inheritance diagram for SciFigs::LineLayer:

Public Types
typedef QList< AbstractLine * > ::const_iterator	const_iterator
enum	ErrorBar { NoBar, VerticalBar, HorizontalBar, VerticalLogBar, HorizontalLogBar }
enum	TrackingModes { Select = 0, Pick, PickOrdered, Edit }
Public Slots
Q_SCRIPTABLE void	attributesHelp ()
Q_SCRIPTABLE void	rmStdDev (int curveIndex)
virtual Q_SCRIPTABLE void	setLegend (Legend legend)
Q_SCRIPTABLE void	setPenColor (int curveIndex, int red, int green, int blue)
Q_SCRIPTABLE void	setPenStyle (int curveIndex, double width, QString lineStyle, QString capStyle, QString joinStyle)
Q_SCRIPTABLE void	setSymBrushColor (int curveIndex, int red, int green, int blue)
Q_SCRIPTABLE void	setSymBrushStyle (int curveIndex, QString brushStyle)
Q_SCRIPTABLE void	setSymPenColor (int curveIndex, int red, int green, int blue)
Q_SCRIPTABLE void	setSymPenStyle (int curveIndex, double width, QString lineStyle, QString capStyle, QString joinStyle)
Q_SCRIPTABLE void	setSymSize (int curveIndex, double size)
Q_SCRIPTABLE void	setSymType (int curveIndex, QString type)
Signals
void	lineEdited (int lineIndex)
void	pickLine (AbstractLine *line)
void	pointAdded (AbstractLine *line, int pointIndex)
Public Member Functions
AbstractLine *	addLine ()
AbstractLine *	addLine (const Pen &pen, const Symbol &sym)
virtual void	addProperties (PropertyProxy *pp)
const_iterator	begin () const
virtual Rect	boundingRect () const
void	clear ()
int	count () const
void	divYbyX (double constant)
const_iterator	end () const
ErrorBar	errorBar () const
QString	errorBarString () const
virtual bool	hasProperties ()
virtual bool	keyPressEvent (QKeyEvent *e)
virtual Legend	legend () const
AbstractLine *	line (int i)
const AbstractLine *	line (int i) const
	LineLayer (AxisWindow *parent=0)
QList< AbstractLine * >	lines () const
virtual void	mouseMoveEvent (const QPoint &pt, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
virtual bool	mousePressEvent (QMouseEvent *e, int id=-1)
virtual bool	mouseReleaseEvent (QMouseEvent *e, int id=-1)
void	mulYbyX (double constant)
virtual void	paintData (const LayerPainterRequest &lp, QPainter &p, double dotpercm) const
const CurvePointOptions *	pointOptions () const
void	removeEmptyLines ()
void	removeLine (int i)
void	removeLine (AbstractLine *l)
virtual void	removeProperties (PropertyProxy *pp)
void	resetLineProperties ()
void	setErrorBar (ErrorBar b)
void	setErrorBar (QString b)
void	setLogErrorBar (bool b)
void	setPointOptions (CurvePointOptions *o)
void	setReferenceLine (AbstractLine *l)
void	setReferencePen (const Pen &p)
void	setReferenceSymbol (const Symbol &s)
void	setSelected (int i, bool s)
void	setVisible (int i, bool v)
virtual void	toggleTrackingAction (bool checked, int id=-1)
virtual bool	trackRectangle (int, double rx1, double ry1, double rx2, double ry2, Qt::KeyboardModifiers m)
virtual bool	wheelEvent (QWheelEvent *e)
virtual const QString &	xml_tagName () const
	~LineLayer ()
Static Public Attributes
static const QString	xmlLineLayerTag = "LineLayer"
Protected Member Functions
virtual XMLMember	xml_member (XML_MEMBER_ARGS)
virtual bool	xml_setProperty (XML_SETPROPERTY_ARGS)
virtual void	xml_writeChildren (XML_WRITECHILDREN_ARGS) const
Protected Attributes
int	_currentLine
ErrorBar	_errorBar
LineEditor *	_lineEditor
CurvePointOptions *	_pointOptions
Properties
QString	errorBar
bool	logErrorBars

Detailed Description

An abstract layer to plot AbstractLine.

Full description of class still missing

Member Typedef Documentation

typedef QList<AbstractLine *>::const_iterator SciFigs::LineLayer::const_iterator

Member Enumeration Documentation

enum SciFigs::LineLayer::ErrorBar

Enumerator:

NoBar
VerticalBar
HorizontalBar
VerticalLogBar
HorizontalLogBar

{NoBar, VerticalBar, HorizontalBar, VerticalLogBar, HorizontalLogBar};

enum SciFigs::LineLayer::TrackingModes

Enumerator:

Select
Pick
PickOrdered
Edit

{Select=0, Pick, PickOrdered, Edit};

Constructor & Destructor Documentation

SciFigs::LineLayer::LineLayer ( AxisWindow * parent = 0 )

References TRACE.

                                        :
    GraphContentLayer(parent)
{
  TRACE;
  _currentLine=-1;
  _errorBar=VerticalBar;
  _lineEditor=0;
  _referenceLine=0;
  _pointOptions=0;
}

SciFigs::LineLayer::~LineLayer ( )

References _pointOptions, clear(), and TRACE.

{
  TRACE;
  clear();
  delete _referenceLine;
  delete _pointOptions;
}

Member Function Documentation

AbstractLine * SciFigs::LineLayer::addLine ( )

Adds one new line with default pen and symbol.

Reimplemented in SciFigs::NameLineLayer.

References SciFigs::AbstractLine::clone(), line(), and TRACE.

Referenced by SciFigs::ActivityMonitor::ActivityMonitor(), QGpGuiWave::DispersionLimitLayer::addArrayLimits(), RefractionTargetWidget::addCurve(), MagnetoTelluricTargetWidget::addCurve(), AutocorrTargetWidget::addCurve(), QGpGuiWave::ModalCurveBrowser::addCurve(), Seismic1DThread::addModel(), MagnetoTelluricThread::addModel(), SciFigs::CurveBrowser::average(), DampingResults::compute(), createCurve(), createCurvePlot(), ArrayGui::ArrayResponse::createObjects(), HistogramWidget::HistogramWidget(), Seismic1DThread::initModelGraphs(), MagnetoTelluricThread::initModelGraphs(), SciFigs::CurveBrowser::loadMultiColumns(), DinverDCGui::GroundModelViewer::minMaxProfiles(), Simulator::on_addSource_clicked(), Results::Results(), MonoStation::AbstractSummary::setAverageValues(), MonoStation::StationResults::setGraph(), StatGridAnalyser::setGrid(), MonoStation::AbstractSummary::setStackedValues(), MonoStation::StatisticResults::setStatPlot(), DinverDCGui::MagnetoTelluricViewer::setTarget(), DinverDCGui::EllipticityViewer::setTarget(), DinverDCGui::DispersionViewer::setTarget(), DinverDCGui::AutocorrViewer::setTarget(), DinverDCGui::RefractionVpViewer::setTarget(), DinverDCGui::RefractionVsViewer::setTarget(), SpacSelector::SpacSelector(), LinearFKActiveResults::stackGrids(), MonoStation::StatisticResults::studentTest(), toggleTrackingAction(), and ProcessStatus::updateMisfitCurve().

{
  TRACE;
  AbstractLine * line=_referenceLine->clone();
  LayerLocker ll(this);
  _lines.append(line);
  resetLayerProperties();
  return line;
}

AbstractLine * SciFigs::LineLayer::addLine	(	const Pen &	pen,
		const Symbol &	sym
	)

Adds one new line with pen pen and symbol sym.

Reimplemented in SciFigs::NameLineLayer.

References SciFigs::AbstractLine::clone(), line(), SciFigs::AbstractLine::setPen(), SciFigs::AbstractLine::setSymbol(), and TRACE.

{
  TRACE;
  AbstractLine * line=_referenceLine->clone();
  line->setPen(pen);
  line->setSymbol(sym);
  LayerLocker ll(this);
  _lines.append(line);
  resetLayerProperties();
  return line;
}

void SciFigs::LineLayer::addProperties ( PropertyProxy * pp ) [virtual]

Setup property editor

Reimplemented from SciFigs::GraphContentLayer.

Reimplemented in SciFigs::NameLineLayer, and SciFigs::GridMaxFollower.

References SciFigs::LineLayerProperties::addLayer(), QGpGuiTools::PropertyProxy::addReference(), QGpGuiTools::PropertyProxy::addTab(), QGpGuiTools::PropertyProxy::currentTabWidget(), QGpGuiTools::PropertyProxy::setCurrentTab(), QGpCoreTools::tr(), TRACE, and w.

{
  TRACE;
  if(pp->setCurrentTab(_tabLineLayer)) {
    pp->addReference(this);
    LineLayerProperties * w=static_cast<LineLayerProperties *>(pp->currentTabWidget());
    w->addLayer(this);
  } else {
    LineLayerProperties * w=new LineLayerProperties;
    pp->addTab(_tabLineLayer, tr("Lines"), w, this);
    w->addLayer(this);
  }
}

void SciFigs::LineLayer::attributesHelp ( ) [slot]

References TRACE.

{
  TRACE;
  qDebug("SYMBOL TYPE: NoSymbol, Cross, Square, Circle, Triangle, "
         "Losange, Star\n"
         "PEN STYLE: NoPen, SolidLine, DashLine, DotLine, DashDotLine, "
         "DashDotDotLine\n"
         "PEN CAP STYLE: FlatCap, SquareCap, RoundCap\n"
         "PEN JOIN STYLE: MiterJoin, BevelJoin, RoundJoin\n"
         "BRUSH STYLES: NoBrush, SolidPattern, Dense1Pattern, Dense2Pattern, "
         "Dense3Pattern, Dense4Pattern, Dense5Pattern, Dense6Pattern, "
         "Dense7Pattern, HorPattern, VerPattern, CrossPattern, BDiagPattern, "
         "FDiagPattern, DiagCrossPattern\n");
}

const_iterator SciFigs::LineLayer::begin ( ) const [inline]

Referenced by boundingRect(), divYbyX(), lines(), mulYbyX(), SciFigs::SlopeEstimator::paintData(), SciFigs::NameLineLayer::paintData(), paintData(), SciFigs::SlopeEstimator::paintText(), SciFigs::NameLineLayer::paintText(), and trackRectangle().

{return _lines.begin();}

Rect SciFigs::LineLayer::boundingRect ( ) const [virtual]

Implements SciFigs::GraphContentLayer.

References _pointOptions, begin(), SciFigs::AbstractLine::count(), end(), SciFigs::AbstractLine::isValid(), line(), SciFigs::AbstractLine::point(), TRACE, QGpCoreTools::Point2D::x(), and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationResults::maximumAmplitude(), ProcessStatus::setCostMinMax(), MapWindow::setLimits(), AutocorrTargetWidget::setLimits(), MonoStation::WinResults::setLimits(), MonoStation::AbstractSummary::setLimits(), GeopsyGui::ArrayMap::setLimitsArray(), GeopsyGui::ArrayMap::setLimitsCoArray(), CurvesThread::setResultsLimits(), MagnetoTelluricThread::setResultsLimits(), MonoStation::StatisticResults::studentTest(), and ProcessStatus::synchronize().

{
  TRACE;
  QList<AbstractLine *>::const_iterator it;
  // Find the first non null curve with valid points
  AbstractLine * line=0;
  int j;
  for(it=begin() ;it!=end();++it) {
    line=*it;
    int n=line->count();
    for(j=0;j < n;j++ ) {
      if(line->isValid(j)) break;
    }
    if(j < n) break;
  }
  if(it==end()) {
    return Rect();
  }
  Point p=line->point(j, _pointOptions);
  Rect r(p.x(), p.y(), p.x(), p.y());
  for( ;it!=end();++it) {
    AbstractLine& line=**it;
    int n=line.count();
    for(int j=0;j < n;j++ ) {
      if(line.isValid(j))
        r.add(line.point(j, _pointOptions));
    }
  }
  return r;
}

void SciFigs::LineLayer::clear ( )

References _currentLine, _lineEditor, and TRACE.

Referenced by Seismic1DThread::clear(), CurvesThread::clear(), MagnetoTelluricThread::clear(), ProcessStatus::clear(), DampingResults::compute(), MonoStation::AbstractSummary::setAverageValues(), MonoStation::AbstractSummary::setStackedValues(), MonoStation::StatisticResults::setStatPlot(), MapWindow::signalsUpdate(), MonoStation::StatisticResults::studentTest(), ~LineLayer(), and SciFigs::NameLineLayer::~NameLineLayer().

{
  TRACE;
  delete _lineEditor;
  _lineEditor=0;
  _currentLine=-1;
  LayerLocker ll(this);
  qDeleteAll(_lines);
  _lines.clear();
  resetLayerProperties();
}

int SciFigs::LineLayer::count ( ) const [inline]

Referenced by Seismic1DThread::addModel(), MagnetoTelluricThread::addModel(), SciFigs::CurveBrowser::clear(), SciFigs::CurveBrowser::count(), GeopsyGui::ArrayMap::countPoints(), AutocorrTargetWidget::curves(), LinearFKActiveResults::exportCurves(), SciFigs::NameLineLayer::legend(), legend(), SciFigs::CurveBrowser::loadMultiColumns(), mouseReleaseEvent(), GeopsyGui::ArrayMap::optimizeRing(), removeEmptyLines(), rmStdDev(), SciFigs::NameLineItem::rowCount(), MonoStation::AbstractSummary::setBubbleValues(), SciFigs::CurveBrowser::setCurrentLayer(), QGpGuiWave::DispersionLimitLayer::setFrequencySampling(), SciFigs::NameLineLayer::setLegend(), setLegend(), setPenColor(), setPenStyle(), setSymBrushColor(), setSymBrushStyle(), setSymPenColor(), setSymPenStyle(), setSymSize(), setSymType(), toggleTrackingAction(), ProcessStatus::updateMisfitCurve(), and xml_writeChildren().

{return _lines.count();}

void SciFigs::LineLayer::divYbyX ( double constant )

References _pointOptions, begin(), SciFigs::AbstractLine::count(), end(), SciFigs::AbstractLine::point(), SciFigs::AbstractLine::setY(), TRACE, QGpCoreTools::Point2D::x(), and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationResults::integrate().

{
  TRACE;
  QList<AbstractLine *>::const_iterator it;
  LayerLocker ll(this);
  for(it=begin() ;it!=end();++it) {
    AbstractLine& line=**it;
    int n=line.count();
    for(int i =0; i<n; i++) {
      Point p=line.point(i, _pointOptions);
      line.setY(i, p.y()/(constant * p.x()), _pointOptions);
    }
  }
}

const_iterator SciFigs::LineLayer::end ( ) const [inline]

Referenced by boundingRect(), divYbyX(), lines(), mulYbyX(), SciFigs::SlopeEstimator::paintData(), SciFigs::NameLineLayer::paintData(), paintData(), SciFigs::SlopeEstimator::paintText(), SciFigs::NameLineLayer::paintText(), and trackRectangle().

{return _lines.end();}

ErrorBar SciFigs::LineLayer::errorBar ( ) const [inline]

{return _errorBar;}

QString SciFigs::LineLayer::errorBarString ( ) const

References _errorBar, HorizontalBar, HorizontalLogBar, NoBar, TRACE, and VerticalLogBar.

{
  TRACE;
  switch(_errorBar) {
  case NoBar:
    return "NoBar";
  case HorizontalBar:
    return "HorizontalBar";
  case HorizontalLogBar:
    return "HorizontalLogBar";
  case VerticalLogBar:
    return "VerticalLogBar";
  default:
    return "VerticalBar";
  }
}

virtual bool SciFigs::LineLayer::hasProperties ( ) [inline, virtual]

Reimplemented from SciFigs::GraphContentLayer.

Reimplemented in SciFigs::NameLineLayer, and SciFigs::GridMaxFollower.

{return true;}

bool SciFigs::LineLayer::keyPressEvent ( QKeyEvent * e ) [virtual]

Reimplemented from SciFigs::GraphContentLayer.

References _lineEditor, SciFigs::GraphContentLayer::deepUpdate(), and TRACE.

{
  TRACE;
  if(_lineEditor && e->key()==Qt::Key_Escape) {
    delete _lineEditor;
    _lineEditor=0;
    deepUpdate();
    return true;
  }
  return false;
}

Legend SciFigs::LineLayer::legend ( ) const [virtual]

Reimplemented in SciFigs::NameLineLayer.

References count(), line(), SciFigs::AbstractLine::pen(), SciFigs::Legend::setPen(), SciFigs::Legend::setSymbol(), SciFigs::Legend::setText(), SciFigs::AbstractLine::symbol(), and TRACE.

Referenced by SciFigs::CurveBrowser::legend().

{
  TRACE;
  int n=count();
  Legend leg(n);
  for(int i=0;i < n;i++ ) {
    const AbstractLine& l=* line(i);
    leg.setText(i , QString::number(i));
    leg.setPen(i, l.pen());
    leg.setSymbol(i, l.symbol());
  }
  return leg;
}

AbstractLine* SciFigs::LineLayer::line ( int i ) [inline]

Reimplemented in SciFigs::NameLineLayer.

Referenced by addLine(), MonoStation::StationResults::averageCurve(), boundingRect(), MonoStation::StationResults::clear(), createCurve(), AutocorrTargetWidget::curves(), Simulator::displaySource(), LinearFKActiveResults::exportCurves(), SpacSelector::inverseAt(), legend(), MonoStation::StationResults::maximumCurve(), MonoStation::StationResults::minimumCurve(), StatGridAnalyser::on_freqScroll_valueChanged(), SciFigs::SlopeEstimator::paintData(), SciFigs::SlopeEstimator::paintText(), SpacSelector::selectSamples(), ArrayGui::ArrayResponse::setArray(), ArrayGui::ArrayResponse::setAzimuth(), SciFigs::CurveBrowser::setCurrentLayer(), Seismic1DThread::setModel(), MagnetoTelluricThread::setModel(), MonoStation::StatisticResults::setStatPlot(), MonoStation::StatisticResults::studentTest(), HistogramWidget::toStream(), ProcessStatus::updateMisfitCurve(), xml_member(), and xml_writeChildren().

{return _lines.at(i);}

const AbstractLine* SciFigs::LineLayer::line ( int i ) const [inline]

Reimplemented in SciFigs::NameLineLayer.

{return _lines.at(i);}

void SciFigs::LineLayer::lineEdited ( int lineIndex ) [signal]

Referenced by mouseMoveEvent().

QList< AbstractLine * > SciFigs::LineLayer::lines ( ) const

Return a clone of its internal list of lines. Mainly used by DynLineProperties

References begin(), end(), and TRACE.

{
  TRACE;
  QList<AbstractLine *> llist;
  for(QList<AbstractLine *>::const_iterator it=begin() ;it!=end();++it) {
    llist.append((*it)->clone());
  }
  return llist;
}

void SciFigs::LineLayer::mouseMoveEvent	(	const QPoint &	pt,
		Qt::MouseButtons	buttons,
		Qt::KeyboardModifiers	modifiers
	)		`[virtual]`

Reimplemented from SciFigs::GraphContentLayer.

References _lineEditor, SciFigs::GraphContentLayer::deepUpdate(), lineEdited(), SciFigs::LineEditor::lineIndex(), SciFigs::LineEditor::mouseMoveEvent(), and TRACE.

{
  TRACE;
  if(_lineEditor) {
    _lineEditor->mouseMoveEvent(pt);
    emit lineEdited(_lineEditor->lineIndex());
    deepUpdate();
  }
}

bool SciFigs::LineLayer::mousePressEvent	(	QMouseEvent *	e,
		int	id = `-1`
	)		`[virtual]`

Reimplemented from SciFigs::GraphContentLayer.

References _lineEditor, SciFigs::GraphContentLayer::deepUpdate(), Edit, SciFigs::LineEditor::mousePressEvent(), and TRACE.

{
  TRACE;
  if(e->button()==Qt::LeftButton) {
    if(id==Edit) {
      if(_lineEditor) {
        if(_lineEditor->mousePressEvent(e)) { // If return true, means that user accept the modification
          delete _lineEditor;
          _lineEditor=0;
          deepUpdate();
        }
        return false;
      } else {
        _lineEditor=new LineEditor(this);
        if(_lineEditor->mousePressEvent(e)) {
          delete _lineEditor;
          _lineEditor=0;
          deepUpdate();
        }
        return false;
      }
    }
  }
  return true;
}

bool SciFigs::LineLayer::mouseReleaseEvent	(	QMouseEvent *	e,
		int	id = `-1`
	)		`[virtual]`

Reimplemented from SciFigs::GraphContentLayer.

References _currentLine, _pointOptions, SciFigs::AbstractLine::append(), SciFigs::AbstractLine::count(), count(), SciFigs::GraphContentLayer::deepUpdate(), SciFigs::GraphContentLayer::graphContent(), SciFigs::AbstractLine::insert(), SciFigs::GraphContent::options(), Pick, PickOrdered, SciFigs::AbstractLine::point(), pointAdded(), Select, SciFigs::AbstractLine::setX(), SciFigs::AbstractLine::setY(), TRACE, QGpCoreTools::Point2D::x(), and SciFigs::GraphContentOptions::xs2r().

{
  TRACE;
  if(e->button()==Qt::LeftButton) {
    switch(id) {
    case Select:    // This mode uses rectangle, hence directly handled by GraphContent
      return false;
    case Pick:
      if(_currentLine>-1 && _currentLine<count()) {
        AbstractLine * l=_lines.at(_currentLine);
        int i=l->count();
        LayerLocker ll(this);
        l->append();
        l->setX(i, graphContent()->options().xs2r(e->pos().x()) );
        l->setY(i, graphContent()->options().ys2r(e->pos().y()), _pointOptions);
        emit pointAdded(l, i);
        deepUpdate();
      }
      return true;
    case PickOrdered:
      if(_currentLine>-1 && _currentLine<count()) {
        AbstractLine * l=_lines.at(_currentLine);
        double x=graphContent()->options().xs2r(e->pos().x());
        int i, n=l->count();
        for(i=0; i<n; i++ ) {
          if(l->point(i, _pointOptions).x() > x) break;
        }
        LayerLocker ll(this);
        l->insert(i);
        l->setX(i, x);
        l->setY(i, graphContent()->options().ys2r(e->pos().y()), _pointOptions);
        emit pointAdded(l, i);
        deepUpdate();
      }
      return true;
    default:
      break;
    }
  }
  return false;
}

void SciFigs::LineLayer::mulYbyX ( double constant )

References _pointOptions, begin(), SciFigs::AbstractLine::count(), end(), SciFigs::AbstractLine::point(), SciFigs::AbstractLine::setY(), TRACE, QGpCoreTools::Point2D::x(), and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationResults::derivate().

{
  TRACE;
  QList<AbstractLine *>::const_iterator it;
  LayerLocker ll(this);
  for(it=begin() ;it!=end();++it) {
    AbstractLine& line=**it;
    int n=line.count();
    for(int i =0; i<n; i++) {
      Point p=line.point(i, _pointOptions);
      line.setY(i, p.y() * constant * p.x(), _pointOptions);
    }
  }
}

void SciFigs::LineLayer::paintData	(	const LayerPainterRequest &	lp,
		QPainter &	p,
		double	dotpercm
	)		const `[virtual]`

Implements SciFigs::GraphContentLayer.

Reimplemented in SciFigs::NameLineLayer, and SciFigs::SlopeEstimator.

References begin(), SciFigs::AbstractLine::count(), end(), SciFigs::LayerPainterRequest::options(), SciFigs::LayerPainterRequest::size(), SciFigs::LayerPainterRequest::terminated(), TRACE, SciFigs::GraphContentOptions::xVisMax(), SciFigs::GraphContentOptions::xVisMin(), SciFigs::GraphContentOptions::yVisMax(), and SciFigs::GraphContentOptions::yVisMin().

{
  TRACE;
  QList<AbstractLine *>::const_iterator it;
  const GraphContentOptions& gc=lp.options();
  int h=lp.size().height();
  Rect r(gc.xVisMin(), gc.yVisMin(), gc.xVisMax(), gc.yVisMax());
  for(it=begin() ;it!=end();++it) {
    if(lp.terminated()) return;
    AbstractLine& line=**it;
    drawCurve(gc, p, dotpercm, h, r, line, 0, line.count());
  }
}

void SciFigs::LineLayer::pickLine ( AbstractLine * line ) [signal]

Referenced by toggleTrackingAction().

void SciFigs::LineLayer::pointAdded	(	AbstractLine *	line,
		int	pointIndex
	)		`[signal]`

Referenced by mouseReleaseEvent().

const CurvePointOptions* SciFigs::LineLayer::pointOptions ( ) const [inline]

Referenced by SciFigs::LineItem::data(), SciFigs::SlopeEstimator::paintData(), SciFigs::NameLineLayer::paintData(), SciFigs::SlopeEstimator::paintText(), SciFigs::CurveProperties::resample(), and SciFigs::LineItem::setData().

{return _pointOptions;}

void SciFigs::LineLayer::removeEmptyLines ( )

References _currentLine, _lineEditor, SciFigs::AbstractLine::count(), count(), and TRACE.

{
  TRACE;
  delete _lineEditor;
  _lineEditor=0;
  LayerLocker ll(this);
  for(int i=count() - 1;i >= 0;i-- ) {
    AbstractLine * l=_lines.at(i);
    if(l->count()==0) {
      delete l;
      _lines.removeAt(i);
      if(i==_currentLine) _currentLine=-1;
    }
  }
  resetLayerProperties();
}

void SciFigs::LineLayer::removeLine ( int i )

References _currentLine, _lineEditor, and TRACE.

Referenced by ProcessStatus::clearThread(), Simulator::on_removeSource_clicked(), SciFigs::CurveBrowser::remove(), SciFigs::CurveBrowser::removeLine(), and ProcessStatus::removeThread().

{
  TRACE;
  delete _lineEditor;
  _lineEditor=0;
  AbstractLine * l=_lines.at(i);
  if(i==_currentLine) _currentLine=-1;
  LayerLocker ll(this);
  delete l;
  _lines.removeAt(i);
  resetLayerProperties();
}

void SciFigs::LineLayer::removeLine ( AbstractLine * l )

References _currentLine, _lineEditor, and TRACE.

{
  TRACE;
  delete _lineEditor;
  _lineEditor=0;
  int i=_lines.indexOf(l);
  if(i==_currentLine) _currentLine=-1;
  LayerLocker ll(this);
  delete l;
  _lines.removeAt(i);
  resetLayerProperties();
}

void SciFigs::LineLayer::removeProperties ( PropertyProxy * pp ) [virtual]

Reimplemented from SciFigs::GraphContentLayer.

Reimplemented in SciFigs::NameLineLayer.

References QGpGuiTools::PropertyProxy::currentTabWidget(), SciFigs::LineLayerProperties::removeLayer(), QGpGuiTools::PropertyProxy::removeTab(), QGpGuiTools::PropertyProxy::setCurrentTab(), TRACE, and w.

{
  TRACE;
  if(pp->setCurrentTab(_tabLineLayer)) {
    LineLayerProperties * w=static_cast<LineLayerProperties *>(pp->currentTabWidget());
    w->removeLayer(this);
    pp->removeTab(_tabLineLayer, this);
  }
}

void SciFigs::LineLayer::resetLineProperties ( )

Update the property tab, if active. Call this function after changing the number of samples in a curve or changing its values.

References QGpGuiTools::PropertyProxy::currentTabWidget(), SciFigs::GraphContentLayer::graph(), SciFigs::GraphicObject::proxy(), QGpGuiTools::PropertyProxy::setCurrentTab(), TRACE, SciFigs::LineLayerProperties::updateCurrentLayer(), and w.

Referenced by rmStdDev(), MonoStation::StationResults::setAverageLayer(), and ArrayGui::ArrayResponse::setAzimuth().

{
  TRACE;
  PropertyProxy * pp=graph()->proxy();
  if(pp) {
    if(pp->setCurrentTab(_tabLineLayer)) {
      LineLayerProperties * w=static_cast<LineLayerProperties *>(pp->currentTabWidget());
      w->updateCurrentLayer();
    }
  }
}

void SciFigs::LineLayer::rmStdDev ( int curveIndex ) [slot]

References _pointOptions, SciFigs::AbstractLine::count(), count(), resetLineProperties(), SciFigs::AbstractLine::setZ(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine& l=* _lines.at(curveIndex);
  int n=l.count();
  LayerLocker ll(this);
  for(int i =0; i<n; i++) {
    l.setZ(i, 0.0, _pointOptions);
  }
  resetLineProperties();
}

void SciFigs::LineLayer::setErrorBar ( ErrorBar b ) [inline]

Referenced by GeopsyGui::ArrayMap::ArrayMap(), MonoStation::AbstractSummary::createBubbleGraph(), EllipticityCurveTargetWidget::EllipticityCurveTargetWidget(), HistogramWidget::initGrid(), setErrorBar(), and DinverDCGui::EllipticityViewer::setTarget().

{_errorBar=b;}

void SciFigs::LineLayer::setErrorBar ( QString b )

References HorizontalBar, HorizontalLogBar, NoBar, setErrorBar(), TRACE, VerticalBar, and VerticalLogBar.

{
  TRACE;
  if(b.count()>0) {
    switch(b[0].unicode()) {
    case 'N':
      setErrorBar(NoBar);
      break;
    case 'H':
      if(b=="HorizontalLogBar")
        setErrorBar(HorizontalLogBar);
      else
        setErrorBar(HorizontalBar);
      break;
    default:
      if(b=="VerticalLogBar")
        setErrorBar(VerticalLogBar);
      else
        setErrorBar(VerticalBar);
      break;
    }
  }
}

void SciFigs::LineLayer::setLegend ( Legend legend ) [virtual, slot]

Reimplemented in SciFigs::NameLineLayer.

References count(), SciFigs::GraphContentLayer::deepUpdate(), SciFigs::Legend::pen(), SciFigs::AbstractLine::setPen(), SciFigs::AbstractLine::setSymbol(), SciFigs::Legend::symbol(), and TRACE.

Referenced by SciFigs::CurveBrowser::legend(), and ProcessStatus::updatePens().

{
  TRACE;
  LayerLocker ll(this);
  int n=count();
  for(int i=0; i< n; i++ ) {
    AbstractLine * l=_lines.at(i);
    l->setPen(legend.pen(i) );
    l->setSymbol(legend.symbol(i) );
  }
  deepUpdate();
}

void SciFigs::LineLayer::setLogErrorBar ( bool b ) [inline]

{_errorBar=b ? VerticalLogBar : VerticalBar;} // Compatibility

void SciFigs::LineLayer::setPenColor	(	int	curveIndex,
		int	red,
		int	green,
		int	blue
	)		`[slot]`

References count(), SciFigs::AbstractLine::pen(), SciFigs::Pen::setColor(), SciFigs::AbstractLine::setPen(), and TRACE.

{
  TRACE;
  if(curveIndex<count()) {
    AbstractLine * l=_lines.at(curveIndex);
    Pen p=l->pen();
    p.setColor(QColor(red,green,blue));
    LayerLocker ll(this);
    l->setPen(p);
  }
}

void SciFigs::LineLayer::setPenStyle	(	int	curveIndex,
		double	width,
		QString	lineStyle,
		QString	capStyle,
		QString	joinStyle
	)		`[slot]`

References SciFigs::Pen::capStyleValue(), count(), SciFigs::Pen::joinStyleValue(), SciFigs::AbstractLine::pen(), SciFigs::Pen::setCapStyle(), SciFigs::Pen::setJoinStyle(), SciFigs::AbstractLine::setPen(), SciFigs::Pen::setStyle(), SciFigs::Pen::setWidth(), SciFigs::Pen::styleValue(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Pen p=l->pen();
  p.setWidth(width);
  p.setStyle(Pen::styleValue(lineStyle) );
  p.setCapStyle(Pen::capStyleValue(capStyle) );
  p.setJoinStyle(Pen::joinStyleValue(joinStyle) );
  LayerLocker ll(this);
  l->setPen(p);
}

void SciFigs::LineLayer::setPointOptions ( CurvePointOptions * o ) [inline]

Referenced by MagnetoTelluricTargetWidget::initLayer(), MagnetoTelluricThread::initResultsGraphs(), and DinverDCGui::MagnetoTelluricViewer::setTarget().

{_pointOptions=o;}

void SciFigs::LineLayer::setReferenceLine ( AbstractLine * l )

Defines the type of line implementation to use with this object

References TRACE.

Referenced by SciFigs::ActivityMonitor::ActivityMonitor(), GeopsyGui::ArrayMap::ArrayMap(), MonoStation::AbstractSummary::createAverageGraph(), MonoStation::AbstractSummary::createBubbleGraph(), createCurveNamePlot(), createCurvePlot(), MonoStation::AbstractSummary::createGridCrossSectionGraph(), DampingResults::createObjects(), ArrayGui::ArrayResponse::createObjects(), MonoStation::AbstractSummary::createStackedGraph(), QGpGuiWave::DispersionLimitLayer::DispersionLimitLayer(), SciFigs::GridMaxFollower::GridMaxFollower(), HistogramWidget::HistogramWidget(), Simulator::init(), DinverDCGui::DCModelViewer::initGraphs(), MagnetoTelluricTargetWidget::initLayer(), QGpGuiWave::ModalCurveBrowser::initLayer(), Seismic1DThread::initModelGraphs(), MagnetoTelluricThread::initModelGraphs(), CurvesThread::initResultsGraphs(), MagnetoTelluricThread::initResultsGraphs(), DinverDCGui::GroundModelViewer::minMaxProfiles(), ProcessStatus::ProcessStatus(), MonoStation::StationResults::setGraph(), StatGridAnalyser::setGrid(), SciFigs::SlopeEstimator::SlopeEstimator(), SpacSelector::SpacSelector(), LinearFKActiveResults::stackGrids(), xml_member(), and xml_setProperty().

{
  TRACE;
  ASSERT(!_referenceLine);
  _referenceLine=l;
}

void SciFigs::LineLayer::setReferencePen ( const Pen & p )

References SciFigs::AbstractLine::setPen(), and TRACE.

Referenced by HistogramWidget::HistogramWidget(), and StatGridAnalyser::setGrid().

{
  TRACE;
  _referenceLine->setPen(p);
}

void SciFigs::LineLayer::setReferenceSymbol ( const Symbol & s )

References SciFigs::AbstractLine::setSymbol(), and TRACE.

{
  TRACE;
  _referenceLine->setSymbol(s);
}

void SciFigs::LineLayer::setSelected	(	int	i,
		bool	s
	)

{
  LayerLocker ll(this);
  _lines.at(i)->setSelected(s);
}

void SciFigs::LineLayer::setSymBrushColor	(	int	curveIndex,
		int	red,
		int	green,
		int	blue
	)		`[slot]`

References SciFigs::Symbol::brush(), count(), SciFigs::Symbol::setBrush(), SciFigs::AbstractLine::setSymbol(), SciFigs::AbstractLine::symbol(), and TRACE.

{
  TRACE;
  if(curveIndex>=(int)count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  Brush b=s.brush();
  b.setColor(QColor(red,green,blue));
  s.setBrush(b);
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setSymBrushStyle	(	int	curveIndex,
		QString	brushStyle
	)		`[slot]`

References SciFigs::Symbol::brush(), count(), SciFigs::Symbol::setBrush(), SciFigs::AbstractLine::setSymbol(), SciFigs::Brush::styleValue(), SciFigs::AbstractLine::symbol(), and TRACE.

{
  TRACE;
  if(curveIndex>=(int)count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  Brush b=s.brush();
  b.setStyle(Brush::styleValue(brushStyle) );
  s.setBrush(b);
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setSymPenColor	(	int	curveIndex,
		int	red,
		int	green,
		int	blue
	)		`[slot]`

References count(), SciFigs::Symbol::pen(), SciFigs::Pen::setColor(), SciFigs::Symbol::setPen(), SciFigs::AbstractLine::setSymbol(), SciFigs::AbstractLine::symbol(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  Pen p=s.pen();
  p.setColor(QColor(red,green,blue));
  s.setPen(p);
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setSymPenStyle	(	int	curveIndex,
		double	width,
		QString	lineStyle,
		QString	capStyle,
		QString	joinStyle
	)		`[slot]`

References SciFigs::Pen::capStyleValue(), count(), SciFigs::Pen::joinStyleValue(), SciFigs::Symbol::pen(), SciFigs::Pen::setCapStyle(), SciFigs::Pen::setJoinStyle(), SciFigs::Symbol::setPen(), SciFigs::Pen::setStyle(), SciFigs::AbstractLine::setSymbol(), SciFigs::Pen::setWidth(), SciFigs::Pen::styleValue(), SciFigs::AbstractLine::symbol(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  Pen p=s.pen();
  p.setWidth(width);
  p.setStyle(Pen::styleValue(lineStyle) );
  p.setCapStyle(Pen::capStyleValue(capStyle) );
  p.setJoinStyle(Pen::joinStyleValue(joinStyle));
  s.setPen(p);
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setSymSize	(	int	curveIndex,
		double	size
	)		`[slot]`

References count(), SciFigs::Symbol::setSize(), SciFigs::AbstractLine::setSymbol(), SciFigs::AbstractLine::symbol(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  s.setSize(size);
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setSymType	(	int	curveIndex,
		QString	type
	)		`[slot]`

References count(), SciFigs::AbstractLine::setSymbol(), SciFigs::Symbol::setType(), SciFigs::AbstractLine::symbol(), SciFigs::Symbol::symbolValue(), and TRACE.

{
  TRACE;
  if(curveIndex>=count()) return;
  AbstractLine * l=_lines.at(curveIndex);
  Symbol s=l->symbol();
  s.setType(Symbol::symbolValue(type) );
  LayerLocker ll(this);
  l->setSymbol(s);
}

void SciFigs::LineLayer::setVisible	(	int	i,
		bool	v
	)

{
  LayerLocker ll(this);
  _lines.at(i)->setVisible(v);
}

void SciFigs::LineLayer::toggleTrackingAction	(	bool	checked,
		int	id = `-1`
	)		`[virtual]`

Reimplemented from SciFigs::GraphContentLayer.

References _currentLine, addLine(), SciFigs::GraphContentLayer::beginMouseTracking(), count(), Edit, SciFigs::GraphContentLayer::endMouseTracking(), SciFigs::GraphContentLayer::isMouseTracking(), Pick, pickLine(), PickOrdered, Select, SciFigs::LayerMouseTracking::setId(), SciFigs::LayerMouseTracking::setIdleCursor(), SciFigs::LayerMouseTracking::setRectangle(), SciFigs::LayerMouseTracking::showRectangle(), and TRACE.

{
  TRACE;
  if(id==-1) {
    QAction * a=qobject_cast<QAction *>(sender());
    if(!a) return;
    id=a->data().toInt();
  }
  if(checked) {
    if(!isMouseTracking(id)) {
      LayerMouseTracking mt(this);
      mt.setId(id);
      switch (id) {
      case Select:
        mt.setIdleCursor(QPixmap(":/images/selectcursor.png"), 4, 4);
        mt.setRectangle(true);
        mt.showRectangle();
        break;
      case Pick: {
          mt.setIdleCursor(QPixmap(":/images/pickcursor.png"), 4, 4);
          _currentLine=count();
          emit pickLine(addLine());
          break;
        }
      case PickOrdered: {
          mt.setIdleCursor(QPixmap(":/images/pickorderedcursor.png"), 4, 4);
          _currentLine=count();
          emit pickLine(addLine());
          break;
        }
      case Edit:
        mt.setIdleCursor(QPixmap(":/images/editcursor.png"), 4, 4);
        break;
      default:
        return; // Do not start mouse tracking
      }
      beginMouseTracking(mt);
    }
  } else {
    if(isMouseTracking(id)) {
      endMouseTracking(id);
    }
  }
}

bool SciFigs::LineLayer::trackRectangle	(	int	,
		double	rx1,
		double	ry1,
		double	rx2,
		double	ry2,
		Qt::KeyboardModifiers	m
	)		`[virtual]`

Reimplemented from SciFigs::GraphContentLayer.

References _pointOptions, begin(), SciFigs::AbstractLine::count(), SciFigs::GraphContent::deepUpdate(), end(), SciFigs::GraphContentLayer::graphContent(), QGpCoreTools::Rect::includes(), SciFigs::AbstractLine::point(), SciFigs::AbstractLine::setSelected(), and TRACE.

{
  TRACE;
  Rect r(rx1, ry1, rx2, ry2);
  QList<AbstractLine *>::const_iterator it;
  Point2D p;
  for(it=begin() ;it!=end();++it) {
    AbstractLine& line=**it;
    int n=line.count();
    bool hit=false;
    for(int j=0;j < n;j++ ) {
      p=line.point(j, _pointOptions);
      if(r.includes(p, Rect::AllRect) ) {
        hit=true;
        break;
      }
    }
    if(hit) line.setSelected(true);
    else if( !(m & Qt::SHIFT) ) line.setSelected(false);
  }
  graphContent() ->deepUpdate();
  return true;
}

bool SciFigs::LineLayer::wheelEvent ( QWheelEvent * e ) [virtual]

Reimplemented from SciFigs::GraphContentLayer.

References _lineEditor, SciFigs::GraphContentLayer::deepUpdate(), TRACE, and SciFigs::LineEditor::wheelEvent().

{
  TRACE;
  if(_lineEditor) {
    _lineEditor->wheelEvent(e);
    deepUpdate();
    return false;
  }
  return true;
}

XMLMember SciFigs::LineLayer::xml_member ( XML_MEMBER_ARGS ) [protected, virtual]

Re-implement this function to offer XML restore (children and properties) support to your class.

From tag and map (with contains the attibute value) return a unique identifier under the format of a XMLMember. XMLMember is initialized with 3 types of contructors:

An integer: id number of a property
A XMLClass * : a child of this object identified by tag
Default constructor: error, unknow child or property

Map of attributes can be inspected in this way (can be achived also in xml_setProperty()):

    static const QString tmp("childrenName");
    XMLRestoreAttributeIterator it=map.find(tmp);
    if(it!=map.end()) {
      // found attribute "childrenName"
    }

If the map of attributes is not used:

    Q_UNUSED(attributes);
    if(tag=="x1") return XMLMember(0);
    else if(tag=="y1") return XMLMember(1);
    else if(tag=="x2") return XMLMember(2);
    else if(tag=="y2") return XMLMember(3);
    else return XMLMember(XMLMember::Unknown);

Arithmetic operations + and - apply to XMLMember to avoid confusion of property id numbers between inherited objects. Offset 3 corresponds to the number of properties defined in this object.

    if(tag=="anInteger") return XMLMember(0);
    else if(tag=="aString") return XMLMember(1);
    else if(tag=="aDouble") return XMLMember(2);
    return AbstractLine::xml_member(tag, attributes, context)+3;

For the arguments of this function use Macro XML_MEMBER_ARGS.

Reimplemented from SciFigs::GraphContentLayer.

References _pointOptions, SciFigs::AbstractLine::clone(), SciFigs::LineFactory::create(), SciFigs::XMLSciFigs::data(), QGpCoreTools::endl(), SciFigs::LineFactory::instance(), line(), setReferenceLine(), QGpCoreTools::tr(), TRACE, and SciFigs::AbstractLine::xml_tagName().

{
  TRACE;
  static const QString att="index";
  XMLSciFigs * scifigsContext=static_cast<XMLSciFigs *>(context);
  if(_referenceLine) {
    bool correctType;
    if(tag==_referenceLine->xml_tagName()) {
      correctType=true;
    } else { // Recognition of synonyms when comparing to reference type
      AbstractLine * line=LineFactory::instance()->create(tag.toString());
      correctType=line ? (line->xml_tagName()==_referenceLine->xml_tagName()) : false;
      delete line;
    }
    if(correctType) {
      AbstractLine * line;
      XMLRestoreAttributeIterator it=attributes.find(att);
      if(it!=attributes.end() && it.value().toString()=="reference") {
        line=_referenceLine;
      } else {
        if(scifigsContext->data()) {
          line=_referenceLine->clone();
          _lines.append(line);
        } else {
          if(it==attributes.end()) {
            App::stream() << tr("Make-up for line: index attribute is mising") << endl;
            return XMLMember(XMLMember::Skip);
          }
          int index=it.value().toInt();
          if(index<0 || index>=_lines.count()) {
            App::stream() << tr("Make-up for line: index is out of range") << endl;
            return XMLMember(XMLMember::Skip);
          }
          line=_lines.at(index);
        }
      }
      return XMLMember(line, false, new LineLayerContext(scifigsContext, _pointOptions));
    }
  } else {
    AbstractLine * line=LineFactory::instance()->create(tag.toString());
    if(line) {
      XMLRestoreAttributeIterator it=attributes.find(att);
      if(it!=attributes.end() && it.value().toString()=="reference") {
        setReferenceLine(line);
      } else if(scifigsContext->data()) { // For compatibility if reference line is missing
        setReferenceLine(line);
        line=line->clone();
        _lines.append(line);
      }
      return XMLMember(line, false, new LineLayerContext(scifigsContext, _pointOptions));
    }
  }
  return GraphContentLayer::xml_member(tag, attributes, context);
}

bool SciFigs::LineLayer::xml_setProperty ( XML_SETPROPERTY_ARGS ) [protected, virtual]

Re-implement this function to offer XML restore properties support to your class.

From memberID set the corresponding property with value content. The map of attributes is given as a supplementary information (not useful in all cases).

For a general case:

  Q_UNUSED(attributes);
  double val=content.toDouble();
  switch (memberID) {
  case 0:
    _x1=val;
    return true;
  case 1:
    _y1=val;
    return true;
  case 2:
    _x2=val;
    return true;
  case 3:
    _y2=val;
    return true;
  default:
    return false;
  }

For classes inheriting other classes (see also xml_member())

  switch (memberID) {
  case 0:
    _anInteger=content.toString();
    return true;
  case 1:
    _aString=content.toInt();
    return true;
  case 2:
    _aDouble=content.toDouble();
    return true;
  default:
    return AbstractLine::xml_setProperty(memberID-3, map, content);

For the arguments of this function use Macro XML_SETPROPERTY_ARGS.

Reimplemented from SciFigs::GraphContentLayer.

References SciFigs::LineFactory::create(), QGpCoreTools::endl(), SciFigs::LineFactory::instance(), setReferenceLine(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  Q_UNUSED(attributes);
  switch (memberID) {
  case 0: {
      AbstractLine * line=LineFactory::instance()->create(content.toString());
      if(line) {
        setReferenceLine(line);
        return true;
      } else {
        App::stream() << tr("Unknown line type: %1").arg(content.toString()) << endl;
        return false;
      }
    }
  default:
    return GraphContentLayer::xml_setProperty(memberID, tag, attributes, content, context);
  }
}

virtual const QString& SciFigs::LineLayer::xml_tagName ( ) const [inline, virtual]

Reimplemented from SciFigs::GraphContentLayer.

Reimplemented in SciFigs::NameLineLayer, and SciFigs::SlopeEstimator.

{return xmlLineLayerTag;}

void SciFigs::LineLayer::xml_writeChildren ( XML_WRITECHILDREN_ARGS ) const [protected, virtual]

Reimplemented from QGpCoreTools::XMLClass.

References _pointOptions, QGpCoreTools::XMLSaveAttributes::add(), count(), line(), TRACE, and QGpCoreTools::XMLClass::xml_save().

{
  TRACE;
  int n=count();
  XMLSciFigs * scifigsContext=static_cast<XMLSciFigs *>(context);
  LineLayerContext lineContext(scifigsContext, _pointOptions);
  static const QString key("index");
  XMLSaveAttributes att;
  QString& value=att.add(key);
  if(_referenceLine) {
    value="reference";
    _referenceLine->xml_save(s, &lineContext, att);
  }
  for(int i=0; i< n ; i++) {
    if(line(i)->count()>0) {
      value=QString::number(i);
      _lines.at(i)->xml_save(s, &lineContext, att);
    }
  }
}