C++ ScaleDraw类代码示例

int Plot::axisLabelFormat(int axis)
{
	if (axisValid(axis)){
		ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
		return sd->labelNumericFormat();
	}
	return 0;
}

/*!
  Change the number format for the major scale of a selected axis
  \param axis axis index
  \param f format
  \param prec precision
*/
void Plot::setAxisLabelFormat(int axis, char f, int prec)
{
    if (axisValid(axis))
		{
		ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
        sd->setLabelFormat(f, prec);
		}
}

/*!
  \return the number format for the major scale labels of a specified axis
  \param axis axis index
  \retval f format character
  \retval prec precision
  */
void Plot::axisLabelFormat(int axis, char &f, int &prec) const
{
	if (axisValid(axis)){
		ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
		sd->labelFormat(f, prec);
	} else {//for a bad call we return the default values
		f = 'g';
		prec = 4;
	}
}

int Plot::axisLabelPrecision(int axis)
{
if (axisValid(axis))
	{
	ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
    return sd->labelNumericPrecision();
	}

//for a bad call we return the default values
return 4;
}

void Plot::drawItems (QPainter *painter, const QRect &rect,
			const QwtScaleMap map[axisCnt], const QwtPlotPrintFilter &pfilter) const
{
    painter->save();
    painter->setRenderHint(QPainter::Antialiasing);
    for (int i=0; i<QwtPlot::axisCnt; i++){
		if (!axisEnabled(i))
			continue;
        drawBreak(painter, rect, map[i], i);
    }
    painter->restore();

    for (int i=0; i<QwtPlot::axisCnt; i++){
		if (!axisEnabled(i))
			continue;

		ScaleEngine *sc_engine = (ScaleEngine *)axisScaleEngine(i);
		if (!sc_engine->hasBreak())
			continue;

		QwtScaleMap m = map[i];
		int lb = m.transform(sc_engine->axisBreakLeft());
		int rb = m.transform(sc_engine->axisBreakRight());
		int start = lb, end = rb;
		if (sc_engine->testAttribute(QwtScaleEngine::Inverted)){
			end = lb;
			start = rb;
		}
		QRegion cr(rect);
		if (i == QwtPlot::xBottom || i == QwtPlot::xTop)
			painter->setClipRegion(cr.subtracted(QRegion(start, rect.y(), abs(end - start), rect.height())), Qt::IntersectClip);
		else if (i == QwtPlot::yLeft || i == QwtPlot::yRight)
			painter->setClipRegion(cr.subtracted(QRegion(rect.x(), end, rect.width(), abs(end - start))), Qt::IntersectClip);
	}

	QwtPlot::drawItems(painter, rect, map, pfilter);

	for (int i=0; i<QwtPlot::axisCnt; i++){
		if (!axisEnabled(i))
			continue;

		ScaleDraw *sd = (ScaleDraw *) axisScaleDraw (i);
		int majorTicksType = sd->majorTicksStyle();
		int minorTicksType = sd->minorTicksStyle();

		bool min = (minorTicksType == ScaleDraw::In || minorTicksType == ScaleDraw::Both);
		bool maj = (majorTicksType == ScaleDraw::In || majorTicksType == ScaleDraw::Both);

		if (min || maj)
			drawInwardTicks(painter, rect, map[i], i, min, maj);
	}
}

QValueList <int> Plot::getMinorTicksType()
{
QValueList <int> minorTicksType;
for (int axis=0; axis<QwtPlot::axisCnt; axis++)
	{
	if (axisEnabled(axis))
		{
		ScaleDraw *sd = (ScaleDraw *) axisScaleDraw (axis);
		minorTicksType << sd->minorTicksStyle();
		}
	else
		minorTicksType << ScaleDraw::Out;
	}
return minorTicksType;
}

int Plot::axisLabelFormat(int axis)
{
if (axisValid(axis))
	{
	int prec;
	char format;

	ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
    sd->labelFormat(format, prec);

	if (format == 'g')
		return Automatic;
	else if (format == 'e')
		return Scientific;
	else if (format == 'f')
		return Decimal;
	else
		return Superscripts;
	}

return 0; 
}

//.........这里部分代码省略.........
    }
  } else if (xColType == Table::Date) {
    for (int i = d_start_row; i <= d_end_row; i++) {
      QString xval = d_table->text(i, xcol);
      if (!xval.isEmpty()) {
        date0 = QDateTime::fromString(xval, date_time_fmt);
        if (date0.isValid())
          break;
      }
    }
  }

  int size = 0;
  for (int i = d_start_row; i <= d_end_row; i++) {
    QString xval = d_table->text(i, xcol);
    QString yval = d_table->text(i, ycol);
    if (!xval.isEmpty() && !yval.isEmpty()) {
      bool valid_data = true;
      if (xColType == Table::Text) {
        xLabels << xval;
        X[size] = (double)(size + 1);
      } else if (xColType == Table::Time) {
        QTime time = QTime::fromString(xval, date_time_fmt);
        if (time.isValid())
          X[size] = time0.msecsTo(time);
      } else if (xColType == Table::Date) {
        QDateTime d = QDateTime::fromString(xval, date_time_fmt);
        if (d.isValid())
          X[size] = (double)date0.secsTo(d);
      } else
        X[size] = plot->locale().toDouble(xval, &valid_data);

      if (yColType == Table::Text) {
        yLabels << yval;
        Y[size] = (double)(size + 1);
      } else
        Y[size] = plot->locale().toDouble(yval, &valid_data);

      if (valid_data)
        size++;
    }
  }

  X.resize(size);
  Y.resize(size);

  // The code for calculating the waterfall offsets, that is here in QtiPlot,
  // has been moved up to
  // PlotCurve so that MantidCurve can access it as well.
  if (g->isWaterfallPlot()) {
    // Calculate the offsets
    double a, b;
    computeWaterfallOffsets(a, b);
  }
  // End re-jigged waterfall offset code

  if (!size) {
    remove();
    return;
  } else {
    if (d_type == GraphOptions::HorizontalBars) {
      setData(Y.data(), X.data(), size);
      foreach (DataCurve *c, d_error_bars)
        c->setData(Y.data(), X.data(), size);
    } else {
      setData(X.data(), Y.data(), size);
      foreach (DataCurve *c, d_error_bars)
        c->setData(X.data(), Y.data(), size);
    }

    if (xColType == Table::Text) {
      if (d_type == GraphOptions::HorizontalBars)
        g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, d_x_column,
                               xLabels);
      else
        g->setLabelsTextFormat(QwtPlot::xBottom, ScaleDraw::Text, d_x_column,
                               xLabels);
    } else if (xColType == Table::Time || xColType == Table::Date) {
      int axis = QwtPlot::xBottom;
      if (d_type == GraphOptions::HorizontalBars)
        axis = QwtPlot::yLeft;
      ScaleDraw *old_sd = static_cast<ScaleDraw *>(plot->axisScaleDraw(axis));
      ScaleDraw *sd = new ScaleDraw(plot, old_sd);
      if (xColType == Table::Date)
        sd->setDateTimeOrigin(date0);
      else
        sd->setDateTimeOrigin(QDateTime(QDate::currentDate(), time0));
      plot->setAxisScaleDraw(axis, sd);
    }

    if (yColType == Table::Text)
      g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, title().text(),
                             yLabels);
  }

  if (!d_labels_list.isEmpty()) {
    (static_cast<Graph *>(plot->parent()))->updatePlot();
    loadLabels();
  }
}

void Plot::setMinorTicksType(int axis, int type)
{
ScaleDraw *sd = (ScaleDraw *)axisScaleDraw (axis);
if (sd)
	sd->setMinorTicksStyle((ScaleDraw::TicksStyle)type);
}

Plot::Plot(QWidget *parent, const char *name)
		: QwtPlot(parent)
{
marker_key = 0;
curve_key = 0;

minTickLength = 5;
majTickLength = 9;

movedGraph=FALSE;
graphToResize=FALSE;
ShiftButton=FALSE;

setGeometry(QRect(0,0,500,400));
setAxisTitle(QwtPlot::yLeft, tr("Y Axis Title"));
setAxisTitle(QwtPlot::xBottom, tr("X Axis Title"));	

// grid 
d_grid = new Grid;
d_grid->enableX(false);
d_grid->enableY(false);
d_grid->setMajPen(QPen(Qt::blue, 0, Qt::SolidLine));
d_grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
d_grid->attach(this);

//custom scale
for (int i= 0; i<QwtPlot::axisCnt; i++)
	{
	QwtScaleWidget *scale = (QwtScaleWidget *) axisWidget(i);
	if (scale)
		{
		scale->setMargin(0);

		//the axis title color must be initialized
		QwtText title = scale->title();
		title.setColor(Qt::black);
		scale->setTitle(title);

		ScaleDraw *sd = new ScaleDraw();
		sd->setTickLength  	(QwtScaleDiv::MinorTick, minTickLength); 
		sd->setTickLength  	(QwtScaleDiv::MediumTick, minTickLength);
		sd->setTickLength  	(QwtScaleDiv::MajorTick, majTickLength);

		setAxisScaleDraw (i, sd);
		}
	}
	
QwtPlotLayout *pLayout=plotLayout();
pLayout->setCanvasMargin(0);

QwtPlotCanvas* plCanvas = canvas();
plCanvas->setFocusPolicy(QWidget::StrongFocus);
plCanvas->setFocusIndicator(QwtPlotCanvas::ItemFocusIndicator);
plCanvas->setFocus();
plCanvas->setFrameShadow(QwtPlot::Plain);
plCanvas->setCursor(Qt::arrowCursor);
plCanvas->setLineWidth(0);

setFocusPolicy(QWidget::StrongFocus);
setFocusProxy(plCanvas);
setFrameShape (QFrame::Box);
setLineWidth(0);
}

/** Applies this axis' parameters to the graph
 *
 */
void ScaleDetails::apply() {
  if (m_modified && valid()) {
    // as the classes are separate now this may cause a problem as ideally i'd
    // get this from the axis tab,
    // but at the moment there's nothing to cause a problem as the only other
    // cases that are used are Date
    // and Time and Mantid doesn't support them in data yet i've been told
    ScaleDraw::ScaleType type = m_graph->axisType(m_mappedaxis);

    double start = 0.0, end = 0.0, step = 0.0, breakLeft = -DBL_MAX,
           breakRight = DBL_MAX;
    if (type == ScaleDraw::Date) {
      ScaleDraw *sclDraw = dynamic_cast<ScaleDraw *>(
          m_graph->plotWidget()->axisScaleDraw(m_mappedaxis));
      QDateTime origin = sclDraw->dateTimeOrigin();
      start = (double)origin.secsTo(m_dteStartDateTime->dateTime());
      end = (double)origin.secsTo(m_dteEndDateTime->dateTime());
    } else if (type == ScaleDraw::Time) {
      ScaleDraw *sclDraw = dynamic_cast<ScaleDraw *>(
          m_graph->plotWidget()->axisScaleDraw(m_mappedaxis));
      QTime origin = sclDraw->dateTimeOrigin().time();
      start = (double)origin.msecsTo(m_timStartTime->time());
      end = (double)origin.msecsTo(m_timEndTime->time());
    } else {
      start = m_dspnStart->value();
      end = m_dspnEnd->value();
    }

    if (m_radStep->isChecked()) {
      step = m_dspnStep->value();
      if (type == ScaleDraw::Time) {
        switch (m_cmbUnit->currentIndex()) {
        case 0:
          break;
        case 1:
          step *= 1e3;
          break;
        case 2:
          step *= 6e4;
          break;
        case 3:
          step *= 36e5;
          break;
        }
      } else if (type == ScaleDraw::Date) {
        switch (m_cmbUnit->currentIndex()) {
        case 0:
          step *= 86400;
          break;
        case 1:
          step *= 604800;
          break;
        }
      }
    }

    if (m_grpAxesBreaks->isChecked()) {
      breakLeft = qMin(m_dspnBreakStart->value(), m_dspnBreakEnd->value());
      breakRight = qMax(m_dspnBreakStart->value(), m_dspnBreakEnd->value());
    }
    m_graph->setScale(
        m_mappedaxis, start, end, step, m_spnMajorValue->value(),
        m_cmbMinorValue->currentText().toInt(), m_cmbScaleType->currentIndex(),
        m_chkInvert->isChecked(), breakLeft, breakRight,
        m_spnBreakPosition->value(), m_dspnStepBeforeBreak->value(),
        m_dspnStepAfterBreak->value(),
        m_cmbMinorTicksBeforeBreak->currentText().toInt(),
        m_cmbMinorTicksAfterBreak->currentText().toInt(),
        m_chkLog10AfterBreak->isChecked(), m_spnBreakWidth->value(),
        m_chkBreakDecoration->isChecked(), m_dspnN->value());
    m_graph->changeIntensity(true);
    m_graph->notifyChanges();
    m_modified = false;
  }
}

/** Initialisation method. Sets up all widgets and variables not done in the
 * constructor.
 *
 */
void ScaleDetails::initWidgets() {
  if (m_initialised) {
    return;
  } else {
    Plot *d_plot = m_graph->plotWidget();
    const QwtScaleDiv *scDiv = d_plot->axisScaleDiv(m_mappedaxis);
    double start = qMin(scDiv->lBound(), scDiv->hBound());
    double end = qMax(scDiv->lBound(), scDiv->hBound());
    ScaleDraw::ScaleType type = m_graph->axisType(m_mappedaxis);
    if (type == ScaleDraw::Date) {
      ScaleDraw *sclDraw =
          dynamic_cast<ScaleDraw *>(d_plot->axisScaleDraw(m_mappedaxis));
      if (!sclDraw) {
        throw std::runtime_error("Could not convert the axis Scale Draw object "
                                 "to a ScaleDraw object");
      }
      QDateTime origin = sclDraw->dateTimeOrigin();

      m_dspnStart->hide();
      m_timStartTime->hide();
      m_dteStartDateTime->show();
      m_dteStartDateTime->setDisplayFormat(sclDraw->format());
      m_dteStartDateTime->setDateTime(origin.addSecs((int)start));

      m_dspnEnd->hide();
      m_timEndTime->hide();
      m_dteEndDateTime->show();
      m_dteEndDateTime->setDisplayFormat(sclDraw->format());
      m_dteEndDateTime->setDateTime(origin.addSecs((int)end));

      m_cmbUnit->show();
      m_cmbUnit->addItem(tr("days"));
      m_cmbUnit->addItem(tr("weeks"));
      m_dspnStep->setValue(m_graph->axisStep(m_mappedaxis) / 86400.0);
      m_dspnStep->setSingleStep(1);
    } else if (type == ScaleDraw::Time) {
      if (ScaleDraw *sclDraw =
              dynamic_cast<ScaleDraw *>(d_plot->axisScaleDraw(m_mappedaxis))) {
        QTime origin = sclDraw->dateTimeOrigin().time();

        m_dspnStart->hide();
        m_dteStartDateTime->hide();
        m_timStartTime->show();
        m_timStartTime->setDisplayFormat(sclDraw->format());
        m_timStartTime->setTime(origin.addMSecs((int)start));

        m_dspnEnd->hide();
        m_dteEndDateTime->hide();
        m_timEndTime->show();
        m_timEndTime->setDisplayFormat(sclDraw->format());
        m_timEndTime->setTime(origin.addMSecs((int)end));

        m_cmbUnit->show();
        m_cmbUnit->addItem(tr("millisec."));
        m_cmbUnit->addItem(tr("sec."));
        m_cmbUnit->addItem(tr("min."));
        m_cmbUnit->addItem(tr("hours"));
        m_cmbUnit->setCurrentIndex(1);
        m_dspnStep->setValue(m_graph->axisStep(m_mappedaxis) / 1e3);
        m_dspnStep->setSingleStep(1000);
      }
    } else {
      m_dspnStart->show();
      m_dspnStart->setValue(start);
      m_timStartTime->hide();
      m_dteStartDateTime->hide();
      m_dspnEnd->show();
      m_dspnEnd->setValue(end);
      m_timEndTime->hide();
      m_dteEndDateTime->hide();
      m_dspnStep->setValue(m_graph->axisStep(m_mappedaxis));
      m_dspnStep->setSingleStep(0.1);
    }

    double range = fabs(scDiv->range());
    QwtScaleEngine *qwtsc_engine = d_plot->axisScaleEngine(m_mappedaxis);
    ScaleEngine *sc_engine = dynamic_cast<ScaleEngine *>(qwtsc_engine);
    if (sc_engine) {
      if (sc_engine->axisBreakLeft() > -DBL_MAX) {
        m_dspnBreakStart->setValue(sc_engine->axisBreakLeft());
      } else {
        m_dspnBreakStart->setValue(start + 0.25 * range);
      }

      if (sc_engine->axisBreakRight() < DBL_MAX) {
        m_dspnBreakEnd->setValue(sc_engine->axisBreakRight());
      } else {
        m_dspnBreakEnd->setValue(start + 0.75 * range);
      }
      m_grpAxesBreaks->setChecked(sc_engine->hasBreak());

      m_spnBreakPosition->setValue(sc_engine->breakPosition());
      m_spnBreakWidth->setValue(sc_engine->breakWidth());
      m_dspnStepBeforeBreak->setValue(sc_engine->stepBeforeBreak());
      m_dspnStepAfterBreak->setValue(sc_engine->stepAfterBreak());

//.........这里部分代码省略.........

Plot::Plot(int width, int height, QWidget *parent, const char *)
: QwtPlot(parent)
{
	setAutoReplot (false);

	marker_key = 0;
	curve_key = 0;

	minTickLength = 5;
	majTickLength = 9;

	setGeometry(QRect(0, 0, width, height));
	setAxisTitle(QwtPlot::yLeft, tr("Y Axis Title"));
	setAxisTitle(QwtPlot::xBottom, tr("X Axis Title"));
	//due to the plot layout updates, we must always have a non empty title
	setAxisTitle(QwtPlot::yRight, tr(" "));
	setAxisTitle(QwtPlot::xTop, tr(" "));

	// grid
	d_grid = new Grid();
	d_grid->attach(this);

	//custom scale
	for (int i= 0; i<QwtPlot::axisCnt; i++) {
		QwtScaleWidget *scale = (QwtScaleWidget *) axisWidget(i);
		if (scale) {
			scale->setMargin(0);

			//the axis title color must be initialized...
			QwtText title = scale->title();
			title.setColor(Qt::black);
			scale->setTitle(title);

            //...same for axis color
            QPalette pal = scale->palette();
            pal.setColor(QPalette::Foreground, QColor(Qt::black));
            scale->setPalette(pal);

			ScaleDraw *sd = new ScaleDraw(this);
			sd->setTickLength(QwtScaleDiv::MinorTick, minTickLength);
			sd->setTickLength(QwtScaleDiv::MediumTick, minTickLength);
			sd->setTickLength(QwtScaleDiv::MajorTick, majTickLength);

			setAxisScaleDraw (i, sd);
			setAxisScaleEngine (i, new ScaleEngine());
		}
	}

	QwtPlotLayout *pLayout = plotLayout();
	pLayout->setCanvasMargin(0);
	pLayout->setAlignCanvasToScales (true);

	QwtPlotCanvas* plCanvas = canvas();
	plCanvas->setFocusPolicy(Qt::StrongFocus);
	plCanvas->setFocusIndicator(QwtPlotCanvas::ItemFocusIndicator);
	//plCanvas->setFocus();
	plCanvas->setFrameShadow(QwtPlot::Plain);
	plCanvas->setCursor(Qt::arrowCursor);
	plCanvas->setLineWidth(0);
	plCanvas->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
	plCanvas->setPaintAttribute(QwtPlotCanvas::PaintPacked, false);

    QColor background = QColor(Qt::white);
    background.setAlpha(255);

	QPalette palette;
    palette.setColor(QPalette::Window, background);
    setPalette(palette);

	setCanvasBackground (background);
	setFocusPolicy(Qt::StrongFocus);
	//setFocusProxy(plCanvas);
	setFrameShape(QFrame::Box);
	setLineWidth(0);
}

void DataCurve::loadData()
{
	Graph *g = (Graph *)plot();
	if (!g)
		return;

	int xcol = d_table->colIndex(d_x_column);
	int ycol = d_table->colIndex(title().text());

	if (xcol < 0 || ycol < 0){
		remove();
		return;
	}

	int r = abs(d_end_row - d_start_row) + 1;
    QVarLengthArray<double> X(r), Y(r);
	int xColType = d_table->columnType(xcol);
	int yColType = d_table->columnType(ycol);

	QStringList xLabels, yLabels;// store text labels

	QTime time0;
	QDateTime date0;
	QString date_time_fmt = d_table->columnFormat(xcol);
	if (xColType == Table::Time){
		for (int i = d_start_row; i <= d_end_row; i++ ){
			QString xval=d_table->text(i,xcol);
			if (!xval.isEmpty()){
				time0 = QTime::fromString (xval, date_time_fmt);
				if (time0.isValid())
					break;
			}
		}
	} else if (xColType == Table::Date){
		for (int i = d_start_row; i <= d_end_row; i++ ){
			QString xval=d_table->text(i,xcol);
			if (!xval.isEmpty()){
				date0 = QDateTime::fromString (xval, date_time_fmt);
				if (date0.isValid())
					break;
			}
		}
	}

	int size = 0;
	for (int i = d_start_row; i <= d_end_row; i++ ){
		QString xval = d_table->text(i,xcol);
		QString yval = d_table->text(i,ycol);
		if (!xval.isEmpty() && !yval.isEmpty()){
		    bool valid_data = true;
			if (xColType == Table::Text){
				xLabels << xval;
				X[size] = (double)(size + 1);
			} else if (xColType == Table::Time){
				QTime time = QTime::fromString (xval, date_time_fmt);
				if (time.isValid())
					X[size]= time0.msecsTo (time);
			} else if (xColType == Table::Date){
				QDateTime d = QDateTime::fromString (xval, date_time_fmt);
				if (d.isValid())
					X[size] = (double) date0.secsTo(d);
			} else
				X[size] = g->locale().toDouble(xval, &valid_data);

			if (yColType == Table::Text){
				yLabels << yval;
				Y[size] = (double)(size + 1);
			} else
				Y[size] = g->locale().toDouble(yval, &valid_data);

            if (valid_data)
                size++;
		}
	}

    X.resize(size);
    Y.resize(size);

	if (!size){
		remove();
		return;
	} else {
		if (d_type == Graph::HorizontalBars){
			setData(Y.data(), X.data(), size);
			foreach(DataCurve *c, d_error_bars)
                c->setData(Y.data(), X.data(), size);
		} else {
			setData(X.data(), Y.data(), size);
			foreach(DataCurve *c, d_error_bars)
                c->setData(X.data(), Y.data(), size);
		}

		if (xColType == Table::Text){
			if (d_type == Graph::HorizontalBars)
				g->setLabelsTextFormat(QwtPlot::yLeft, ScaleDraw::Text, d_x_column, xLabels);
			else
                g->setLabelsTextFormat(QwtPlot::xBottom, ScaleDraw::Text, d_x_column, xLabels);
		} else if (xColType == Table::Time || xColType == Table::Date){
			int axis = QwtPlot::xBottom;
			if (d_type == Graph::HorizontalBars)
//.........这里部分代码省略.........

void FFT::outputGraphs()
{
	createOutputGraph();

	MultiLayer *ml = d_output_graph->multiLayer();

	d_output_graph->setTitle(QString::null);
	d_output_graph->setYAxisTitle(tr("Angle (deg)"));
	d_output_graph->enableAxis(QwtPlot::xTop, true);
	d_output_graph->enableAxis(QwtPlot::yRight, true);
	if (!d_inverse)
		d_output_graph->setAxisTitle(QwtPlot::xTop, tr("Frequency") + " (" + tr("Hz") + ")");
	else
		d_output_graph->setAxisTitle(QwtPlot::xTop, tr("Time") + + " (" + tr("s") + ")");

	ScaleDraw *sd = (ScaleDraw *)d_output_graph->axisScaleDraw(QwtPlot::yLeft);
	if (sd)
		sd->setShowTicksPolicy(ScaleDraw::HideBegin);
	sd = (ScaleDraw *)d_output_graph->axisScaleDraw(QwtPlot::yRight);
	if (sd)
		sd->setShowTicksPolicy(ScaleDraw::HideBegin);
	sd = (ScaleDraw *)d_output_graph->axisScaleDraw(QwtPlot::xBottom);
	if (sd){
		sd->setShowTicksPolicy(ScaleDraw::HideBeginEnd);
		sd->enableComponent(QwtAbstractScaleDraw::Backbone, false);
	}

	QString tableName = d_result_table->objectName();
	PlotCurve *pc = d_output_graph->insertCurve(d_result_table, 0, tableName + "_" + tr("Angle"), 0);
	pc->setPen(QPen(d_curveColor, 1));
	d_output_graph->removeLegend();
	d_output_graph->updatePlot();

	Graph *g = ml->addLayer(0, 0, 0, 0, true);
	g->setTitle(QString::null);
	if (!d_inverse)
		g->setXAxisTitle(tr("Frequency") + " (" + tr("Hz") + ")");
	else
		g->setXAxisTitle(tr("Time") + + " (" + tr("s") + ")");
	g->setYAxisTitle(tr("Amplitude"));
	g->removeLegend();

	sd = (ScaleDraw *)g->axisScaleDraw(QwtPlot::xTop);
	if (sd)
		sd->setShowTicksPolicy(ScaleDraw::HideBeginEnd);

	PlotCurve *c = g->insertCurve(d_result_table, 0, tableName + "_" + tr("Amplitude"), 0);
	c->setPen(QPen(d_curveColor, 1));
	g->updatePlot();

	double rb = g->axisScaleDiv(QwtPlot::xBottom)->upperBound();
	d_output_graph->setAxisScale(QwtPlot::xBottom, 0, rb);
	d_output_graph->setAxisScale(QwtPlot::xTop, 0, rb);
	g->setAxisScale(QwtPlot::xBottom, 0, rb);
	g->setAxisScale(QwtPlot::xTop, 0, rb);

	ml->setAlignPolicy(MultiLayer::AlignCanvases);
	ml->setRows(2);
	ml->setCols(1);
	ml->setSpacing(0, 0);
	ml->linkXLayerAxes();
	ml->setCommonLayerAxes(false, true);
	ml->arrangeLayers(false, false);
}