File indexing completed on 2024-04-14 14:11:35

 /*
     SPDX-FileCopyrightText: 2002-2003 Pablo de Vicente <vicente@oan.es>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "altvstime.h"
 
 #include "avtplotwidget.h"
 #include "dms.h"
 #include "ksalmanac.h"
 #include "kstarsdata.h"
 #include "kstarsdatetime.h"
 #include "ksnumbers.h"
 #include "simclock.h"
 #include "kssun.h"
 #include "dialogs/finddialog.h"
 #include "dialogs/locationdialog.h"
 #include "geolocation.h"
 #include "skyobjects/skypoint.h"
 #include "skyobjects/skyobject.h"
 #include "skyobjects/starobject.h"
 
 #include <KLocalizedString>
 #include <kplotwidget.h>
 
 #include <QVBoxLayout>
 #include <QFrame>
 #include <QDialog>
 #include <QPainter>
 #include <QtPrintSupport/QPrinter>
 #include <QtPrintSupport/QPrintDialog>
 
 #include "kstars_debug.h"
 
 AltVsTimeUI::AltVsTimeUI(QWidget *p) : QFrame(p)
 {
     setupUi(this);
 }
 
 AltVsTime::AltVsTime(QWidget *parent) : QDialog(parent)
 {
 #ifdef Q_OS_OSX
     setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
 #endif
 
     setWindowTitle(i18nc("@title:window", "Altitude vs. Time"));
 
     setModal(false);
 
     QVBoxLayout *topLayout = new QVBoxLayout;
     setLayout(topLayout);
     topLayout->setContentsMargins(0, 0, 0, 0);
     avtUI = new AltVsTimeUI(this);
 
     // Layers for setting up the plot's priority: the current curve should be above the other curves.
     // The Rise/Set/Transit markers should be on top, with highest priority.
     avtUI->View->addLayer("currentCurveLayer", avtUI->View->layer("main"), QCustomPlot::limAbove);
     avtUI->View->addLayer("markersLayer", avtUI->View->layer("currentCurveLayer"), QCustomPlot::limAbove);
 
     // Set up the Graph Window:
     avtUI->View->setBackground(QBrush(QColor(0, 0, 0)));
     avtUI->View->xAxis->grid()->setVisible(false);
     avtUI->View->yAxis->grid()->setVisible(false);
     QColor axisColor(Qt::white);
     QPen axisPen(axisColor, 1);
     avtUI->View->xAxis->setBasePen(axisPen);
     avtUI->View->xAxis->setTickPen(axisPen);
     avtUI->View->xAxis->setSubTickPen(axisPen);
     avtUI->View->xAxis->setTickLabelColor(axisColor);
     avtUI->View->xAxis->setLabelColor(axisColor);
 
     avtUI->View->xAxis2->setBasePen(axisPen);
     avtUI->View->xAxis2->setTickPen(axisPen);
     avtUI->View->xAxis2->setSubTickPen(axisPen);
     avtUI->View->xAxis2->setTickLabelColor(axisColor);
     avtUI->View->xAxis2->setLabelColor(axisColor);
 
     avtUI->View->yAxis->setBasePen(axisPen);
     avtUI->View->yAxis->setTickPen(axisPen);
     avtUI->View->yAxis->setSubTickPen(axisPen);
     avtUI->View->yAxis->setTickLabelColor(axisColor);
     avtUI->View->yAxis->setLabelColor(axisColor);
 
     avtUI->View->yAxis2->setBasePen(axisPen);
     avtUI->View->yAxis2->setTickPen(axisPen);
     avtUI->View->yAxis2->setSubTickPen(axisPen);
     avtUI->View->yAxis2->setTickLabelColor(axisColor);
     avtUI->View->yAxis2->setLabelColor(axisColor);
 
     // give the axis some labels:
     avtUI->View->xAxis2->setLabel(i18n("Local Sidereal Time"));
     avtUI->View->xAxis2->setVisible(true);
     avtUI->View->yAxis2->setVisible(true);
     avtUI->View->yAxis2->setTickLength(0, 0);
     avtUI->View->xAxis->setLabel(i18n("Local Time"));
     avtUI->View->yAxis->setLabel(i18n("Altitude"));
     avtUI->View->xAxis->setRange(43200, 129600);
     avtUI->View->xAxis2->setRange(61200, 147600);
 
     // configure the bottom axis to show time instead of number:
     QSharedPointer<QCPAxisTickerTime> xAxisTimeTicker(new QCPAxisTickerTime);
     xAxisTimeTicker->setTimeFormat("%h:%m");
     xAxisTimeTicker->setTickCount(12);
     xAxisTimeTicker->setTickStepStrategy(QCPAxisTicker::tssReadability);
     xAxisTimeTicker->setTickOrigin(Qt::UTC);
     avtUI->View->xAxis->setTicker(xAxisTimeTicker);
 
     // configure the top axis to show time instead of number:
     QSharedPointer<QCPAxisTickerTime> xAxis2TimeTicker(new QCPAxisTickerTime);
     xAxis2TimeTicker->setTimeFormat("%h:%m");
     xAxis2TimeTicker->setTickCount(12);
     xAxis2TimeTicker->setTickStepStrategy(QCPAxisTicker::tssReadability);
     xAxis2TimeTicker->setTickOrigin(Qt::UTC);
     avtUI->View->xAxis2->setTicker(xAxis2TimeTicker);
 
     // set up the Zoom/Pan features for the Top X Axis
     avtUI->View->axisRect()->setRangeDragAxes(avtUI->View->xAxis2, avtUI->View->yAxis);
     avtUI->View->axisRect()->setRangeZoomAxes(avtUI->View->xAxis2, avtUI->View->yAxis);
 
     // set up the margins, for a nice view
     avtUI->View->axisRect()->setAutoMargins(QCP::msBottom | QCP::msLeft | QCP::msTop);
     avtUI->View->axisRect()->setMargins(QMargins(0, 0, 7, 0));
 
     // set up the interaction set:
     avtUI->View->setInteraction(QCP::iRangeZoom, true);
     avtUI->View->setInteraction(QCP::iRangeDrag, true);
 
     // set up the selection tolerance for checking if a certain graph is or not selected:
     avtUI->View->setSelectionTolerance(5);
 
     // draw the gradient:
     drawGradient();
 
     // set up the background image:
     background = new QCPItemPixmap(avtUI->View);
     background->setPixmap(*gradient);
     background->topLeft->setType(QCPItemPosition::ptPlotCoords);
     background->bottomRight->setType(QCPItemPosition::ptPlotCoords);
     background->setScaled(true, Qt::IgnoreAspectRatio);
     background->setLayer("background");
     background->setVisible(true);
 
     avtUI->raBox->setUnits(dmsBox::HOURS);
     avtUI->decBox->setUnits(dmsBox::DEGREES);
 
     //FIXME:
     //Doesn't make sense to manually adjust long/lat unless we can modify TZ also
     avtUI->longBox->setReadOnly(true);
     avtUI->latBox->setReadOnly(true);
 
     topLayout->addWidget(avtUI);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     topLayout->addWidget(buttonBox);
     connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
     QPushButton *printB = new QPushButton(QIcon::fromTheme("document-print"), i18n("&Print..."));
     printB->setToolTip(i18n("Print the Altitude vs. time plot"));
     buttonBox->addButton(printB, QDialogButtonBox::ActionRole);
     connect(printB, SIGNAL(clicked()), this, SLOT(slotPrint()));
 
     geo = KStarsData::Instance()->geo();
 
     DayOffset = 0;
     // set up the initial minimum and maximum altitude
     minAlt = 0;
     maxAlt = 0;
     showCurrentDate();
     if (getDate().time().hour() > 12)
         DayOffset = 1;
 
     avtUI->longBox->show(geo->lng());
     avtUI->latBox->show(geo->lat());
 
     computeSunRiseSetTimes();
     setLSTLimits();
     setDawnDusk();
 
     connect(avtUI->View->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(onYRangeChanged(QCPRange)));
     connect(avtUI->View->xAxis2, SIGNAL(rangeChanged(QCPRange)), this, SLOT(onXRangeChanged(QCPRange)));
     connect(avtUI->View, SIGNAL(plottableClick(QCPAbstractPlottable*, int, QMouseEvent*)), this,
             SLOT(plotMousePress(QCPAbstractPlottable*, int, QMouseEvent*)));
     connect(avtUI->View, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(mouseOverLine(QMouseEvent*)));
 
     connect(avtUI->browseButton, SIGNAL(clicked()), this, SLOT(slotBrowseObject()));
     connect(avtUI->cityButton, SIGNAL(clicked()), this, SLOT(slotChooseCity()));
     connect(avtUI->updateButton, SIGNAL(clicked()), this, SLOT(slotUpdateDateLoc()));
     connect(avtUI->clearButton, SIGNAL(clicked()), this, SLOT(slotClear()));
     connect(avtUI->addButton, SIGNAL(clicked()), this, SLOT(slotAddSource()));
     connect(avtUI->nameBox, SIGNAL(returnPressed()), this, SLOT(slotAddSource()));
     connect(avtUI->raBox, SIGNAL(returnPressed()), this, SLOT(slotAddSource()));
     connect(avtUI->decBox, SIGNAL(returnPressed()), this, SLOT(slotAddSource()));
     connect(avtUI->clearFieldsButton, SIGNAL(clicked()), this, SLOT(slotClearBoxes()));
     connect(avtUI->longBox, SIGNAL(returnPressed()), this, SLOT(slotAdvanceFocus()));
     connect(avtUI->latBox, SIGNAL(returnPressed()), this, SLOT(slotAdvanceFocus()));
     connect(avtUI->PlotList, SIGNAL(currentRowChanged(int)), this, SLOT(slotHighlight(int)));
     connect(avtUI->computeButton, SIGNAL(clicked()), this, SLOT(slotComputeAltitudeByTime()));
     connect(avtUI->riseButton, SIGNAL(clicked()), this, SLOT(slotMarkRiseTime()));
     connect(avtUI->setButton, SIGNAL(clicked()), this, SLOT(slotMarkSetTime()));
     connect(avtUI->transitButton, SIGNAL(clicked()), this, SLOT(slotMarkTransitTime()));
 
     // Set up the Rise/Set/Transit buttons' icons:
 
     QPixmap redButton(100, 100);
     redButton.fill(Qt::transparent);
     QPainter p;
     p.begin(&redButton);
     p.setRenderHint(QPainter::Antialiasing, true);
     QPen pen(Qt::red, 2);
     p.setPen(pen);
     QBrush brush(Qt::red);
     p.setBrush(brush);
     p.drawEllipse(15, 15, 80, 80);
     p.end();
 
     QPixmap blueButton(100, 100);
     blueButton.fill(Qt::transparent);
     QPainter p1;
     p1.begin(&blueButton);
     p1.setRenderHint(QPainter::Antialiasing, true);
     QPen pen1(Qt::blue, 2);
     p1.setPen(pen1);
     QBrush brush1(Qt::blue);
     p1.setBrush(brush1);
     p1.drawEllipse(15, 15, 80, 80);
     p1.end();
 
     QPixmap greenButton(100, 100);
     greenButton.fill(Qt::transparent);
     QPainter p2;
     p2.begin(&greenButton);
     p2.setRenderHint(QPainter::Antialiasing, true);
     QPen pen2(Qt::green, 2);
     p2.setPen(pen2);
     QBrush brush2(Qt::green);
     p2.setBrush(brush2);
     p2.drawEllipse(15, 15, 80, 80);
     p2.end();
 
     avtUI->riseButton->setIcon(QIcon(redButton));
     avtUI->setButton->setIcon(QIcon(blueButton));
     avtUI->transitButton->setIcon(QIcon(greenButton));
 
     setMouseTracking(true);
 }
 
 AltVsTime::~AltVsTime()
 {
     //WARNING: need to delete deleteList items!
 }
 void AltVsTime::slotAddSource()
 {
 
     SkyObject *obj = KStarsData::Instance()->objectNamed(avtUI->nameBox->text());
     if (!obj)
     {
         QString name = FindDialog::processSearchText(avtUI->nameBox->text());
         obj = KStarsData::Instance()->objectNamed(name);
     }
     if (obj)
     {
         //An object with the current name exists.  If the object is not already
         //in the avt list, add it.
         bool found = false;
         foreach (SkyObject *o, pList)
         {
             //if ( o->name() == obj->name() ) {
             if (getObjectName(o, false) == getObjectName(obj, false))
             {
                 found = true;
                 break;
             }
         }
         if (!found)
             processObject(obj);
     }
     else
     {
         //Object with the current name doesn't exist.  It's possible that the
         //user is trying to add a custom object.  Assume this is the case if
         //the RA and Dec fields are filled in.
 
         if (!avtUI->nameBox->text().isEmpty() && !avtUI->raBox->text().isEmpty() && !avtUI->decBox->text().isEmpty())
         {
             bool okRA, okDec;
             dms newRA  = avtUI->raBox->createDms(&okRA);
             dms newDec = avtUI->decBox->createDms(&okDec);
             if (!okRA || !okDec)
                 return;
 
             //If the epochName is blank (or any non-double), we assume J2000
             //Otherwise, precess to J2000.
             KStarsDateTime dt;
             dt.setFromEpoch(getEpoch(avtUI->epochName->text()));
             long double jd = dt.djd();
             if (jd != J2000)
             {
                 SkyPoint ptest(newRA, newDec);
                 //ptest.precessFromAnyEpoch(jd, J2000);
                 ptest.catalogueCoord(jd);
                 newRA.setH(ptest.ra().Hours());
                 newDec.setD(ptest.dec().Degrees());
             }
 
             //make sure the coords do not already exist from another object
             bool found = false;
             foreach (SkyObject *p, pList)
             {
                 //within an arcsecond?
                 if (fabs(newRA.Degrees() - p->ra().Degrees()) < 0.0003 &&
                         fabs(newDec.Degrees() - p->dec().Degrees()) < 0.0003)
                 {
                     found = true;
                     break;
                 }
             }
             if (!found)
             {
                 SkyObject *obj = new SkyObject(8, newRA, newDec, 1.0, avtUI->nameBox->text());
                 deleteList.append(obj); //this object will be deleted when window is destroyed
                 processObject(obj);
             }
         }
 
         //If the Ra and Dec boxes are filled, but the name field is empty,
         //move input focus to nameBox.  If either coordinate box is empty,
         //move focus there
         if (avtUI->nameBox->text().isEmpty())
         {
             avtUI->nameBox->QWidget::setFocus();
         }
         if (avtUI->raBox->text().isEmpty())
         {
             avtUI->raBox->QWidget::setFocus();
         }
         else
         {
             if (avtUI->decBox->text().isEmpty())
                 avtUI->decBox->QWidget::setFocus();
         }
     }
 
     avtUI->View->update();
 }
 
 //Use find dialog to choose an object
 void AltVsTime::slotBrowseObject()
 {
     if (FindDialog::Instance()->exec() == QDialog::Accepted)
     {
         SkyObject *o = FindDialog::Instance()->targetObject();
         processObject(o);
     }
 
     avtUI->View->update();
     avtUI->View->replot();
 }
 
 void AltVsTime::processObject(SkyObject *o, bool forceAdd)
 {
     if (!o)
         return;
 
     KSNumbers *num    = new KSNumbers(getDate().djd());
     KSNumbers *oldNum = nullptr;
 
     //If the object is in the solar system, recompute its position for the given epochLabel
     KStarsData *data = KStarsData::Instance();
     if (o->isSolarSystem())
     {
         oldNum = new KSNumbers(data->ut().djd());
         o->updateCoords(num, true, geo->lat(), data->lst(), true);
     }
 
     //precess coords to target epoch
     o->updateCoordsNow(num);
 
     // vector used for computing the points needed for drawing the graph
     QVector<double> y(100), t(100);
 
     //If this point is not in list already, add it to list
     bool found(false);
     foreach (SkyObject *p, pList)
     {
         if (o->ra().Degrees() == p->ra().Degrees() && o->dec().Degrees() == p->dec().Degrees())
         {
             found = true;
             break;
         }
     }
     if (found && !forceAdd)
     {
         qCWarning(KSTARS) << "This point is already displayed; It will not be duplicated.";
     }
     else
     {
         pList.append(o);
 
         // make sure existing curves are thin and red:
 
         for (int i = 0; i < avtUI->View->graphCount(); i++)
         {
             if (avtUI->View->graph(i)->pen().color() == Qt::white)
             {
                 avtUI->View->graph(i)->setPen(QPen(Qt::red, 2));
             }
         }
 
         // SET up the curve's name
         avtUI->View->addGraph()->setName(o->name());
 
         // compute the current graph:
         // time range: 24h
 
         int offset = 3;
         for (double h = -12.0, i = 0; h <= 12.0; h += 0.25, i++)
         {
             y[i] = findAltitude(o, h);
             if (y[i] > maxAlt)
                 maxAlt = y[i];
             if (y[i] < minAlt)
                 minAlt = y[i];
             t[i] = i * 900 + 43200;
             avtUI->View->graph(avtUI->View->graphCount() - 1)->addData(t[i], y[i]);
         }
         avtUI->View->graph(avtUI->View->graphCount() - 1)->setPen(QPen(Qt::white, 3));
 
         // Go into initial state: without Zoom/Pan
         avtUI->View->xAxis->setRange(43200, 129600);
         avtUI->View->xAxis2->setRange(61200, 147600);
         if (abs(minAlt) > maxAlt)
             maxAlt = abs(minAlt);
         else
             minAlt = -maxAlt;
 
         avtUI->View->yAxis->setRange(minAlt - offset, maxAlt + offset);
 
         // Update background coordinates:
         background->topLeft->setCoords(avtUI->View->xAxis->range().lower, avtUI->View->yAxis->range().upper);
         background->bottomRight->setCoords(avtUI->View->xAxis->range().upper, avtUI->View->yAxis->range().lower);
 
         avtUI->View->replot();
 
         avtUI->PlotList->addItem(getObjectName(o));
         avtUI->PlotList->setCurrentRow(avtUI->PlotList->count() - 1);
         avtUI->raBox->show(o->ra());
         avtUI->decBox->show(o->dec());
         avtUI->nameBox->setText(getObjectName(o));
 
         //Set epochName to epoch shown in date tab
         avtUI->epochName->setText(QString().setNum(getDate().epoch()));
     }
     //qCDebug() << "Currently, there are " << avtUI->View->graphCount() << " objects displayed.";
 
     //restore original position
     if (o->isSolarSystem())
     {
         o->updateCoords(oldNum, true, data->geo()->lat(), data->lst(), true);
         delete oldNum;
     }
     o->EquatorialToHorizontal(data->lst(), data->geo()->lat());
     delete num;
 }
 
 double AltVsTime::findAltitude(SkyPoint *p, double hour)
 {
     hour += 24.0 * DayOffset;
 
     //getDate converts the user-entered local time to UT
     KStarsDateTime ut = getDate().addSecs(hour * 3600.0);
 
     CachingDms LST = geo->GSTtoLST(ut.gst());
     p->EquatorialToHorizontal(&LST, geo->lat());
     return p->alt().Degrees();
 }
 
 void AltVsTime::slotHighlight(int row)
 {
     if (row < 0)
         return;
 
     int rowIndex = 0;
     //highlight the curve of the selected object
     for (int i = 0; i < avtUI->View->graphCount(); i++)
     {
         if (i == row)
             rowIndex = row;
         else
         {
             avtUI->View->graph(i)->setPen(QPen(Qt::red, 2));
             avtUI->View->graph(i)->setLayer("main");
         }
     }
     avtUI->View->graph(rowIndex)->setPen(QPen(Qt::white, 3));
     avtUI->View->graph(rowIndex)->setLayer("currentCurveLayer");
     avtUI->View->update();
     avtUI->View->replot();
 
     if (row >= 0 && row < pList.size())
     {
         SkyObject *p = pList.at(row);
         avtUI->raBox->show(p->ra());
         avtUI->decBox->show(p->dec());
         avtUI->nameBox->setText(avtUI->PlotList->currentItem()->text());
     }
 
     SkyObject *selectedObject = KStarsData::Instance()->objectNamed(avtUI->nameBox->text());
     const KStarsDateTime &ut  = KStarsData::Instance()->ut();
     if (selectedObject)
     {
         QTime rt = selectedObject->riseSetTime(ut, geo, true); //true = use rise time
         if (rt.isValid() == false)
         {
             avtUI->riseButton->setEnabled(false);
             avtUI->setButton->setEnabled(false);
         }
         else
         {
             avtUI->riseButton->setEnabled(true);
             avtUI->setButton->setEnabled(true);
         }
     }
 }
 
 void AltVsTime::onXRangeChanged(const QCPRange &range)
 {
     QCPRange aux = avtUI->View->xAxis2->range();
     avtUI->View->xAxis->setRange(aux -= 18000);
     avtUI->View->xAxis2->setRange(range.bounded(61200, 147600));
     // if ZOOM is detected then remove the gold lines that indicate current position:
     if (avtUI->View->xAxis->range().size() != 86400)
     {
         // Refresh the background:
         background->setScaled(false);
         background->setScaled(true, Qt::IgnoreAspectRatio);
         background->setPixmap(*gradient);
 
         avtUI->View->update();
         avtUI->View->replot();
     }
 }
 
 void AltVsTime::onYRangeChanged(const QCPRange &range)
 {
     int offset = 3;
     avtUI->View->yAxis->setRange(range.bounded(minAlt - offset, maxAlt + offset));
 }
 
 void AltVsTime::plotMousePress(QCPAbstractPlottable *abstractPlottable, int dataIndex, QMouseEvent *event)
 {
     //Do we need this?
     Q_UNUSED(dataIndex);
 
     if (event->button() == Qt::RightButton)
     {
         QCPAbstractPlottable *plottable = abstractPlottable;
         if (plottable)
         {
             double x = avtUI->View->xAxis->pixelToCoord(event->localPos().x());
             double y = avtUI->View->yAxis->pixelToCoord(event->localPos().y());
 
             QCPGraph *graph = qobject_cast<QCPGraph *>(plottable);
 
             if (graph)
             {
                 double yValue = y;
                 double xValue = x;
 
                 // Compute time value:
                 QTime localTime(0, 0, 0, 0);
                 QTime localSiderealTime(5, 0, 0, 0);
 
                 localTime         = localTime.addSecs(int(xValue));
                 localSiderealTime = localSiderealTime.addSecs(int(xValue));
 
                 QToolTip::hideText();
                 QToolTip::showText(event->globalPos(),
                                    i18n("<table>"
                                         "<tr>"
                                         "<th colspan=\"2\">%1</th>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>LST:   </td>"
                                         "<td>%3</td>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>LT:   </td>"
                                         "<td>%2</td>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>Altitude:   </td>"
                                         "<td>%4</td>"
                                         "</tr>"
                                         "</table>",
                                         graph->name().isEmpty() ? "???" : graph->name(),
                                         localTime.toString(),
                                         localSiderealTime.toString(),
                                         QString::number(yValue, 'f', 2) + ' ' + QChar(176)),
                                    avtUI->View, avtUI->View->rect());
             }
         }
     }
 }
 
 //move input focus to the next logical widget
 void AltVsTime::slotAdvanceFocus()
 {
     if (sender()->objectName() == QString("nameBox"))
         avtUI->addButton->setFocus();
     if (sender()->objectName() == QString("raBox"))
         avtUI->decBox->setFocus();
     if (sender()->objectName() == QString("decbox"))
         avtUI->addButton->setFocus();
     if (sender()->objectName() == QString("longBox"))
         avtUI->latBox->setFocus();
     if (sender()->objectName() == QString("latBox"))
         avtUI->updateButton->setFocus();
 }
 
 void AltVsTime::slotClear()
 {
     pList.clear();
     //Need to delete the pointers in deleteList
     while (!deleteList.isEmpty())
         delete deleteList.takeFirst();
 
     avtUI->PlotList->clear();
     avtUI->nameBox->clear();
     avtUI->raBox->clear();
     avtUI->decBox->clear();
     avtUI->epochName->clear();
     // remove all graphs from the plot:
     avtUI->View->clearGraphs();
     // we remove all the dots (rise/set/transit) from the chart
     // without removing the background image
     int indexItem = 0, noItems = avtUI->View->itemCount();
     QCPAbstractItem *item;
     QCPItemPixmap *background;
     // remove every item at a time:
     while (noItems > 1 && indexItem < noItems)
     {
         // test if the current item is the background:
         item       = avtUI->View->item(indexItem);
         background = qobject_cast<QCPItemPixmap *>(item);
         if (background)
             indexItem++;
         else
         {
             // if not, then remove this item:
             avtUI->View->removeItem(indexItem);
             noItems--;
         }
     }
     // update & replot the chart:
     avtUI->View->update();
     avtUI->View->replot();
 }
 
 void AltVsTime::slotClearBoxes()
 {
     avtUI->nameBox->clear();
     avtUI->raBox->clear();
     avtUI->decBox->clear();
     avtUI->epochName->clear();
 }
 
 void AltVsTime::slotComputeAltitudeByTime()
 {
     if (avtUI->PlotList->currentRow() < 0)
         return;
 
     SkyObject *selectedObject = pList.at(avtUI->PlotList->currentRow());
     if (selectedObject == nullptr)
     {
         if (avtUI->PlotList->currentItem())
             qCWarning(KSTARS) << "slotComputeAltitudeByTime: Unable to find" << avtUI->PlotList->currentItem()->text();
         else
         {
             qCWarning(KSTARS) << "slotComputeAltitudeByTime: Unable to find item";
         }
         return;
     }
 
     // Get Local Date & Time
     KStarsDateTime lt = KStarsDateTime(avtUI->DateWidget->date(), avtUI->timeSpin->time(), Qt::LocalTime);
     // Convert to UT
     KStarsDateTime ut = geo->LTtoUT(lt);
     // Get LST from GST
     CachingDms LST = geo->GSTtoLST(ut.gst());
     SkyObject *tempObject = selectedObject->clone();
     // Update coords
     KSNumbers num(ut.djd());
     tempObject->updateCoords(&num, true, geo->lat(), &LST);
     // Find Horizontal coordinates from LST & Latitude
     selectedObject->EquatorialToHorizontal(&LST, geo->lat());
 
     // Set altitude
     avtUI->altitudeBox->setText(selectedObject->altRefracted().toDMSString(true));
 
     delete (tempObject);
 }
 
 void AltVsTime::slotMarkRiseTime()
 {
     if (avtUI->PlotList->currentRow() < 0)
         return;
 
     const KStarsDateTime &ut  = KStarsData::Instance()->ut();
     SkyObject *selectedObject = pList.at(avtUI->PlotList->currentRow());
     if (selectedObject == nullptr)
     {
         qCWarning(KSTARS) << "Mark Rise Time: Unable to find" << avtUI->PlotList->currentItem()->text();
         return;
     }
 
     QCPItemTracer *riseTimeTracer;
     // check if at least one graph exists in the plot
     if (avtUI->View->graphCount() > 0)
     {
         double time = 0;
         double hours, minutes;
 
         QCPGraph *selectedGraph = avtUI->View->graph(avtUI->PlotList->currentRow());
 
         QTime rt = selectedObject->riseSetTime(ut, geo, true); //true = use rise time
         // mark the Rise time with a solid red circle
         if (rt.isValid() && selectedGraph)
         {
             hours   = rt.hour();
             minutes = rt.minute();
             if (hours < 12)
                 hours += 24;
             time           = hours * 3600 + minutes * 60;
             riseTimeTracer = new QCPItemTracer(avtUI->View);
             riseTimeTracer->setLayer("markersLayer");
             riseTimeTracer->setGraph(selectedGraph);
             riseTimeTracer->setInterpolating(true);
             riseTimeTracer->setStyle(QCPItemTracer::tsCircle);
             riseTimeTracer->setPen(QPen(Qt::red));
             riseTimeTracer->setBrush(Qt::red);
             riseTimeTracer->setSize(10);
             riseTimeTracer->setGraphKey(time);
             riseTimeTracer->setVisible(true);
             avtUI->View->update();
             avtUI->View->replot();
         }
     }
 }
 
 void AltVsTime::slotMarkSetTime()
 {
     if (avtUI->PlotList->currentRow() < 0)
         return;
 
     const KStarsDateTime &ut  = KStarsData::Instance()->ut();
     SkyObject *selectedObject = pList.at(avtUI->PlotList->currentRow());
     if (selectedObject == nullptr)
     {
         qCWarning(KSTARS) << "Mark Set Time: Unable to find" << avtUI->PlotList->currentItem()->text();
         return;
     }
     QCPItemTracer *setTimeTracer;
     // check if at least one graph exists in the plot
     if (avtUI->View->graphCount() > 0)
     {
         double time = 0;
         double hours, minutes;
 
         QCPGraph *selectedGraph = avtUI->View->graph(avtUI->PlotList->currentRow());
 
         QTime rt = selectedObject->riseSetTime(ut, geo, true); //true = use rise time
         //If set time is before rise time, use set time for tomorrow
         QTime st = selectedObject->riseSetTime(ut, geo, false); //false = use set time
         if (st < rt)
             st = selectedObject->riseSetTime(ut.addDays(1), geo, false); //false = use set time
         // mark the Set time with a solid blue circle
         if (rt.isValid())
         {
             hours   = st.hour();
             minutes = st.minute();
             if (hours < 12)
                 hours += 24;
             time          = hours * 3600 + minutes * 60;
             setTimeTracer = new QCPItemTracer(avtUI->View);
             setTimeTracer->setLayer("markersLayer");
             setTimeTracer->setGraph(selectedGraph);
             setTimeTracer->setInterpolating(true);
             setTimeTracer->setStyle(QCPItemTracer::tsCircle);
             setTimeTracer->setPen(QPen(Qt::blue));
             setTimeTracer->setBrush(Qt::blue);
             setTimeTracer->setSize(10);
             setTimeTracer->setGraphKey(time);
             setTimeTracer->setVisible(true);
             avtUI->View->update();
             avtUI->View->replot();
         }
     }
 }
 
 void AltVsTime::slotMarkTransitTime()
 {
     if (avtUI->PlotList->currentRow() < 0)
         return;
 
     const KStarsDateTime &ut  = KStarsData::Instance()->ut();
     SkyObject *selectedObject = pList.at(avtUI->PlotList->currentRow());
     if (selectedObject == nullptr)
     {
         qCWarning(KSTARS) << "Mark Transit Time: Unable to find" << avtUI->PlotList->currentItem()->text();
         return;
     }
     QCPItemTracer *transitTimeTracer;
     // check if at least one graph exists in the plot
     if (avtUI->View->graphCount() > 0)
     {
         double time = 0;
         double hours, minutes;
 
         QCPGraph *selectedGraph = avtUI->View->graph(avtUI->PlotList->currentRow());
 
         QTime rt = selectedObject->riseSetTime(ut, geo, true); //true = use rise time
         //If transit time is before rise time, use transit time for tomorrow
         QTime tt = selectedObject->transitTime(ut, geo);
 
         if (tt < rt)
             tt = selectedObject->transitTime(ut.addDays(1), geo);
         // mark the Transit time with a solid green circle
         hours   = tt.hour();
         minutes = tt.minute();
         if (hours < 12)
             hours += 24;
         time              = hours * 3600 + minutes * 60;
         transitTimeTracer = new QCPItemTracer(avtUI->View);
         transitTimeTracer->setLayer("markersLayer");
         transitTimeTracer->setGraph(selectedGraph);
         transitTimeTracer->setInterpolating(true);
         transitTimeTracer->setStyle(QCPItemTracer::tsCircle);
         transitTimeTracer->setPen(QPen(Qt::green));
         transitTimeTracer->setBrush(Qt::green);
         transitTimeTracer->setSize(10);
         transitTimeTracer->setGraphKey(time);
         transitTimeTracer->setVisible(true);
         avtUI->View->update();
         avtUI->View->replot();
     }
 }
 
 void AltVsTime::computeSunRiseSetTimes()
 {
     //Determine the time of sunset and sunrise for the desired date and location
     //expressed as doubles, the fraction of a full day.
 
     /* KSAlmanac ksal(getDate(), geo); */
 
     /* ... */
 }
 
 //FIXME
 /*
 void AltVsTime::mouseOverLine(QMouseEvent *event){
     // Get the mouse position's coordinates relative to axes:
     double x = avtUI->View->xAxis->pixelToCoord(event->pos().x());
     double y = avtUI->View->yAxis->pixelToCoord(event->pos().y());
     // Save the actual values:
     double yValue = y;
     double xValue = x;
     // The offset used for the Y axis: top/bottom
     int offset = 3;
     // Compute the Y axis maximum value:
     int yAxisMaxValue = maxAlt + offset;
     // Compute the X axis minimum and maximum values:
     int xAxisMinValue = 43200;
     int xAxisMaxValue = 129600;
     // Ignore the upper and left margins:
     y = yAxisMaxValue - y;
     x -= xAxisMinValue;
     // We make a copy to gradient background in order to have one set of lines at a time:
     // Otherwise, the chart would have been covered by lines
     QPixmap copy = gradient->copy(gradient->rect());
     // If ZOOM is not active, then draw the gold lines that indicate current mouse pisition:
     if(avtUI->View->xAxis->range().size() == 86400){
         QPainter p;
 
         p.begin(&copy);
         p.setPen( QPen( QBrush("gold"), 2, Qt::SolidLine ) );
 
         // Get the gradient background's width and height:
         int pW = gradient->rect().width();
         int pH = gradient->rect().height();
 
         // Compute the real coordinates within the chart:
         y = (y*pH/2)/yAxisMaxValue;
         x = (x*pW)/(xAxisMaxValue-xAxisMinValue);
 
         // Draw the horizontal line (altitude):
         p.drawLine( QLineF( 0.5, y, avtUI->View->rect().width()-0.5,y ) );
         // Draw the altitude value:
         p.setPen( QPen( QBrush("gold"), 3, Qt::SolidLine ) );
         p.drawText( 25, y + 15, QString::number(yValue,'f',2) + QChar(176) );
         p.setPen( QPen( QBrush("gold"), 1, Qt::SolidLine ) );
         // Draw the vertical line (time):
         p.drawLine( QLineF( x, 0.5, x, avtUI->View->rect().height()-0.5 ) );
         // Compute and draw the time value:
         QTime localTime(0,0,0,0);
         localTime = localTime.addSecs(int(xValue));
         p.save();
         p.translate( x + 10, pH - 20 );
         p.rotate(-90);
         p.setPen( QPen( QBrush("gold"), 3, Qt::SolidLine ) );
         p.drawText( 5, 5, QLocale().toString( localTime, QLocale::ShortFormat ) ); // short format necessary to avoid false time-zone labeling
         p.restore();
         p.end();
     }
     // Refresh the background:
     background->setScaled(false);
     background->setScaled(true, Qt::IgnoreAspectRatio);
     background->setPixmap(copy);
 
     avtUI->View->update();
     avtUI->View->replot();
 }
 */
 
 void AltVsTime::mouseOverLine(QMouseEvent *event)
 {
     double x                            = avtUI->View->xAxis->pixelToCoord(event->localPos().x());
     double y                            = avtUI->View->yAxis->pixelToCoord(event->localPos().y());
     QCPAbstractPlottable *abstractGraph = avtUI->View->plottableAt(event->pos(), false);
     QCPGraph *graph                     = qobject_cast<QCPGraph *>(abstractGraph);
 
     if (x > avtUI->View->xAxis->range().lower && x < avtUI->View->xAxis->range().upper)
         if (y > avtUI->View->yAxis->range().lower && y < avtUI->View->yAxis->range().upper)
         {
             if (graph)
             {
                 double yValue = y;
                 double xValue = x;
 
                 // Compute time value:
                 QTime localTime(0, 0, 0, 0);
                 QTime localSiderealTime(5, 0, 0, 0);
 
                 localTime         = localTime.addSecs(int(xValue));
                 localSiderealTime = localSiderealTime.addSecs(int(xValue));
 
                 QToolTip::hideText();
                 QToolTip::showText(event->globalPos(),
                                    i18n("<table>"
                                         "<tr>"
                                         "<th colspan=\"2\">%1</th>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>LST:   </td>"
                                         "<td>%3</td>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>LT:   </td>"
                                         "<td>%2</td>"
                                         "</tr>"
                                         "<tr>"
                                         "<td>Altitude:   </td>"
                                         "<td>%4</td>"
                                         "</tr>"
                                         "</table>",
                                         graph->name().isEmpty() ? "???" : graph->name(),
                                         localTime.toString(), localSiderealTime.toString(),
                                         QString::number(yValue, 'f', 2) + ' ' + QChar(176)),
                                    avtUI->View, avtUI->View->rect());
             }
             else
                 QToolTip::hideText();
         }
 
     avtUI->View->update();
     avtUI->View->replot();
 }
 
 void AltVsTime::slotUpdateDateLoc()
 {
     KStarsData *data     = KStarsData::Instance();
     KStarsDateTime today = getDate();
     KSNumbers *num       = new KSNumbers(today.djd());
     KSNumbers *oldNum    = nullptr;
     CachingDms LST       = geo->GSTtoLST(today.gst());
 
     //First determine time of sunset and sunrise
     computeSunRiseSetTimes();
     // Determine dawn/dusk time and min/max sun elevation
     setDawnDusk();
 
     for (int i = 0; i < pList.count(); ++i)
     {
         SkyObject *o = pList.at(i);
         if (o)
         {
             //If the object is in the solar system, recompute its position for the given date
             if (o->isSolarSystem())
             {
                 oldNum = new KSNumbers(data->ut().djd());
                 o->updateCoords(num, true, geo->lat(), &LST, true);
             }
 
             //precess coords to target epoch
             o->updateCoordsNow(num);
 
             //update pList entry
             pList.replace(i, o);
 
             // We are creating a new data set (time, altitude) for the new date:
             QVector<double> time_dataSet, altitude_dataSet;
             double point_altitudeValue, point_timeValue;
             // compute the new graph values:
             // time range: 24h
             int offset = 3;
             for (double h = -12.0, i = 0; h <= 12.0; h += 0.25, i++)
             {
                 point_altitudeValue = findAltitude(o, h);
                 altitude_dataSet.push_back(point_altitudeValue);
                 if (point_altitudeValue > maxAlt)
                     maxAlt = point_altitudeValue;
                 if (point_altitudeValue < minAlt)
                     minAlt = point_altitudeValue;
                 point_timeValue = i * 900 + 43200;
                 time_dataSet.push_back(point_timeValue);
             }
 
             // Replace graph data set:
             avtUI->View->graph(i)->setData(time_dataSet, altitude_dataSet);
 
             // Go into initial state: without Zoom/Pan
             avtUI->View->xAxis->setRange(43200, 129600);
             avtUI->View->xAxis2->setRange(61200, 147600);
 
             // Center the altitude axis in 0 value:
             if (abs(minAlt) > maxAlt)
                 maxAlt = abs(minAlt);
             else
                 minAlt = -maxAlt;
             avtUI->View->yAxis->setRange(minAlt - offset, maxAlt + offset);
 
             // Update background coordinates:
             background->topLeft->setCoords(avtUI->View->xAxis->range().lower, avtUI->View->yAxis->range().upper);
             background->bottomRight->setCoords(avtUI->View->xAxis->range().upper, avtUI->View->yAxis->range().lower);
 
             // Redraw the plot:
             avtUI->View->replot();
 
             //restore original position
             if (o->isSolarSystem())
             {
                 o->updateCoords(oldNum, true, data->geo()->lat(), data->lst());
                 delete oldNum;
                 oldNum = nullptr;
             }
             o->EquatorialToHorizontal(data->lst(), data->geo()->lat());
         }
         else //assume unfound object is a custom object
         {
             pList.at(i)->updateCoordsNow(num); //precess to desired epoch
 
             // We are creating a new data set (time, altitude) for the new date:
             QVector<double> time_dataSet, altitude_dataSet;
             double point_altitudeValue, point_timeValue;
             // compute the new graph values:
             // time range: 24h
             int offset = 3;
             for (double h = -12.0, i = 0; h <= 12.0; h += 0.25, i++)
             {
                 point_altitudeValue = findAltitude(pList.at(i), h);
                 altitude_dataSet.push_back(point_altitudeValue);
                 if (point_altitudeValue > maxAlt)
                     maxAlt = point_altitudeValue;
                 if (point_altitudeValue < minAlt)
                     minAlt = point_altitudeValue;
                 point_timeValue = i * 900 + 43200;
                 time_dataSet.push_back(point_timeValue);
             }
 
             // Replace graph data set:
             avtUI->View->graph(i)->setData(time_dataSet, altitude_dataSet);
 
             // Go into initial state: without Zoom/Pan
             avtUI->View->xAxis->setRange(43200, 129600);
             avtUI->View->xAxis2->setRange(61200, 147600);
 
             // Center the altitude axis in 0 value:
             if (abs(minAlt) > maxAlt)
                 maxAlt = abs(minAlt);
             else
                 minAlt = -maxAlt;
             avtUI->View->yAxis->setRange(minAlt - offset, maxAlt + offset);
 
             // Update background coordinates:
             background->topLeft->setCoords(avtUI->View->xAxis->range().lower, avtUI->View->yAxis->range().upper);
             background->bottomRight->setCoords(avtUI->View->xAxis->range().upper, avtUI->View->yAxis->range().lower);
 
             // Redraw the plot:
             avtUI->View->replot();
         }
     }
 
     if (getDate().time().hour() > 12)
         DayOffset = 1;
     else
         DayOffset = 0;
 
     setLSTLimits();
     slotHighlight(avtUI->PlotList->currentRow());
     avtUI->View->update();
 
     delete num;
 }
 
 void AltVsTime::slotChooseCity()
 {
     QPointer<LocationDialog> ld = new LocationDialog(this);
     if (ld->exec() == QDialog::Accepted)
     {
         GeoLocation *newGeo = ld->selectedCity();
         if (newGeo)
         {
             geo = newGeo;
             avtUI->latBox->show(geo->lat());
             avtUI->longBox->show(geo->lng());
         }
     }
     delete ld;
 }
 
 // FIXME: should we remove this method?
 void AltVsTime::setLSTLimits()
 {
     /*
     //UT at noon on target date
     KStarsDateTime ut = getDate().addSecs(((double)DayOffset + 0.5)*86400.);
 
     dms lst = geo->GSTtoLST(ut.gst());
     double h1 = lst.Hours();
     if(h1 > 12.0)
         h1 -= 24.0;
     double h2 = h1 + 24.0;
     avtUI->View->setSecondaryLimits(h1, h2, -90.0, 90.0);
     */
 }
 
 void AltVsTime::showCurrentDate()
 {
     KStarsDateTime dt = KStarsDateTime::currentDateTime();
     if (dt.time() > QTime(12, 0, 0))
         dt = dt.addDays(1);
     avtUI->DateWidget->setDate(dt.date());
 }
 
 void AltVsTime::drawGradient()
 {
     // Things needed for Gradient:
     KStarsDateTime dtt  = KStarsDateTime::currentDateTime();
     GeoLocation *geoLoc = KStarsData::Instance()->geo();
     QDateTime midnight  = QDateTime(dtt.date(), QTime());
     KStarsDateTime const utt  = geoLoc->LTtoUT(KStarsDateTime(midnight));
 
     // Variables needed for Gradient:
     double SunRise, SunSet, Dawn, Dusk, SunMinAlt, SunMaxAlt;
     double MoonRise, MoonSet, MoonIllum;
 
     KSAlmanac ksal(utt, geoLoc);
 
     // Get the values:
     SunRise   = ksal.getSunRise();
     SunSet    = ksal.getSunSet();
     SunMaxAlt = ksal.getSunMaxAlt();
     SunMinAlt = ksal.getSunMinAlt();
     MoonRise  = ksal.getMoonRise();
     MoonSet   = ksal.getMoonSet();
     MoonIllum = ksal.getMoonIllum();
     Dawn      = ksal.getDawnAstronomicalTwilight();
     Dusk      = ksal.getDuskAstronomicalTwilight();
 
     gradient = new QPixmap(avtUI->View->rect().width(), avtUI->View->rect().height());
 
     QPainter p;
 
     p.begin(gradient);
     KPlotWidget *kPW = new KPlotWidget;
     p.setRenderHint(QPainter::Antialiasing, kPW->antialiasing());
     p.fillRect(gradient->rect(), kPW->backgroundColor());
 
     p.setClipRect(gradient->rect());
     p.setClipping(true);
 
     int pW = gradient->rect().width();
     int pH = gradient->rect().height();
 
     QColor SkyColor(0, 100, 200);
     //    TODO
     //    if( Options::darkAppColors() )
     //        SkyColor = QColor( 200, 0, 0 ); // use something red, visible through a red filter
 
     // Draw gradient representing lunar interference in the sky
     if (MoonIllum > 0.01) // do this only if Moon illumination is reasonable so it's important
     {
         int moonrise = int(pW * (0.5 + MoonRise));
         int moonset  = int(pW * (MoonSet - 0.5));
         if (moonset < 0)
             moonset += pW;
         if (moonrise > pW)
             moonrise -= pW;
         int moonalpha = int(10 + MoonIllum * 130);
         int fadewidth =
             pW *
             0.01; // pW * fraction of day to fade the moon brightness over (0.01 corresponds to roughly 15 minutes, 0.007 to 10 minutes), both before and after actual set.
         QColor MoonColor(255, 255, 255, moonalpha);
 
         if (moonset < moonrise)
         {
             QLinearGradient grad =
                 QLinearGradient(QPointF(moonset - fadewidth, 0.0), QPointF(moonset + fadewidth, 0.0));
             grad.setColorAt(0, MoonColor);
             grad.setColorAt(1, Qt::transparent);
             p.fillRect(QRectF(0.0, 0.0, moonset + fadewidth, pH),
                        grad); // gradient should be padded until moonset - fadewidth (see QLinearGradient docs)
             grad.setStart(QPointF(moonrise + fadewidth, 0.0));
             grad.setFinalStop(QPointF(moonrise - fadewidth, 0.0));
             p.fillRect(QRectF(moonrise - fadewidth, 0.0, pW - moonrise + fadewidth, pH), grad);
         }
         else
         {
             qreal opacity = p.opacity();
             p.setOpacity(opacity / 4);
             p.fillRect(QRectF(moonrise + fadewidth, 0.0, moonset - moonrise - 2 * fadewidth, pH), MoonColor);
             QLinearGradient grad =
                 QLinearGradient(QPointF(moonrise + fadewidth, 0.0), QPointF(moonrise - fadewidth, 0.0));
             grad.setColorAt(0, MoonColor);
             grad.setColorAt(1, Qt::transparent);
             p.fillRect(QRectF(0.0, 0.0, moonrise + fadewidth, pH), grad);
             grad.setStart(QPointF(moonset - fadewidth, 0.0));
             grad.setFinalStop(QPointF(moonset + fadewidth, 0.0));
             p.fillRect(QRectF(moonset - fadewidth, 0.0, pW - moonset, pH), grad);
             p.setOpacity(opacity);
         }
     }
 
     //draw daytime sky if the Sun rises for the current date/location
     if (SunMaxAlt > -18.0)
     {
         //Display centered on midnight, so need to modulate dawn/dusk by 0.5
         int rise = int(pW * (0.5 + SunRise));
         int set  = int(pW * (SunSet - 0.5));
         int da   = int(pW * (0.5 + Dawn));
         int du   = int(pW * (Dusk - 0.5));
 
         if (SunMinAlt > 0.0)
         {
             // The sun never set and the sky is always blue
             p.fillRect(rect(), SkyColor);
         }
         else if (SunMaxAlt < 0.0 && SunMinAlt < -18.0)
         {
             // The sun never rise but the sky is not completely dark
             QLinearGradient grad = QLinearGradient(QPointF(0.0, 0.0), QPointF(du, 0.0));
 
             QColor gradStartColor = SkyColor;
             gradStartColor.setAlpha((1 - (SunMaxAlt / -18.0)) * 255);
 
             grad.setColorAt(0, gradStartColor);
             grad.setColorAt(1, Qt::transparent);
             p.fillRect(QRectF(0.0, 0.0, du, pH), grad);
             grad.setStart(QPointF(pW, 0.0));
             grad.setFinalStop(QPointF(da, 0.0));
             p.fillRect(QRectF(da, 0.0, pW, pH), grad);
         }
         else if (SunMaxAlt < 0.0 && SunMinAlt > -18.0)
         {
             // The sun never rise but the sky is NEVER completely dark
             QLinearGradient grad = QLinearGradient(QPointF(0.0, 0.0), QPointF(pW, 0.0));
 
             QColor gradStartEndColor = SkyColor;
             gradStartEndColor.setAlpha((1 - (SunMaxAlt / -18.0)) * 255);
             QColor gradMidColor = SkyColor;
             gradMidColor.setAlpha((1 - (SunMinAlt / -18.0)) * 255);
 
             grad.setColorAt(0, gradStartEndColor);
             grad.setColorAt(0.5, gradMidColor);
             grad.setColorAt(1, gradStartEndColor);
             p.fillRect(QRectF(0.0, 0.0, pW, pH), grad);
         }
         else if (Dawn < 0.0)
         {
             // The sun sets and rises but the sky is never completely dark
             p.fillRect(0, 0, set, int(0.5 * pH), SkyColor);
             p.fillRect(rise, 0, pW, int(0.5 * pH), SkyColor);
 
             QLinearGradient grad = QLinearGradient(QPointF(set, 0.0), QPointF(rise, 0.0));
 
             QColor gradMidColor = SkyColor;
             gradMidColor.setAlpha((1 - (SunMinAlt / -18.0)) * 255);
 
             grad.setColorAt(0, SkyColor);
             grad.setColorAt(0.5, gradMidColor);
             grad.setColorAt(1, SkyColor);
             p.fillRect(QRectF(set, 0.0, rise - set, pH), grad);
         }
         else
         {
             p.fillRect(0, 0, set, pH, SkyColor);
             p.fillRect(rise, 0, pW, pH, SkyColor);
 
             QLinearGradient grad = QLinearGradient(QPointF(set, 0.0), QPointF(du, 0.0));
             grad.setColorAt(0, SkyColor);
             grad.setColorAt(
                 1,
                 Qt::transparent); // FIXME?: The sky appears black well before the actual end of twilight if the gradient is too slow (eg: latitudes above arctic circle)
             p.fillRect(QRectF(set, 0.0, du - set, pH), grad);
 
             grad.setStart(QPointF(rise, 0.0));
             grad.setFinalStop(QPointF(da, 0.0));
             p.fillRect(QRectF(da, 0.0, rise - da, pH), grad);
         }
     }
 
     p.fillRect(0, int(0.5 * pH), pW, int(0.5 * pH), KStarsData::Instance()->colorScheme()->colorNamed("HorzColor"));
 
     p.setClipping(false);
 
     // Add vertical line indicating "now"
     // Convert the current system clock time to the TZ corresponding to geo
     QTime t = geoLoc->UTtoLT(KStarsDateTime::currentDateTimeUtc()).time();
     double x = 12.0 + t.hour() + t.minute() / 60.0 + t.second() / 3600.0;
 
     while (x > 24.0)
         x -= 24.0;
 
     // Convert to screen pixel coords
     int ix = int(x * pW / 24.0);
 
     p.setPen(QPen(QBrush("white"), 2.0, Qt::DotLine));
     p.drawLine(ix, 0, ix, pH);
 
     QFont largeFont = p.font();
 
     largeFont.setPointSize(largeFont.pointSize() + 1);
     // Label this vertical line with the current time
     p.save();
     p.setFont(largeFont);
     p.translate(ix + 15, pH - 20);
     p.rotate(-90);
     // Short format necessary to avoid false time-zone labeling
     p.drawText(0, 0, QLocale().toString(t, QLocale::ShortFormat));
     p.restore();
     p.end();
 }
 
 KStarsDateTime AltVsTime::getDate()
 {
     //convert midnight local time to UT:
     QDateTime lt(avtUI->DateWidget->date(), QTime());
     return geo->LTtoUT(KStarsDateTime(lt));
 }
 
 double AltVsTime::getEpoch(const QString &eName)
 {
     //If Epoch field not a double, assume J2000
     bool ok;
     double epoch = eName.toDouble(&ok);
     if (!ok)
     {
         qCWarning(KSTARS) << "Invalid Epoch.  Assuming 2000.0.";
         return 2000.0;
     }
     return epoch;
 }
 
 void AltVsTime::setDawnDusk()
 {
     /* TODO */
 
     /*
     KSAlmanac almanac(getDate(), geo);
 
     avtUI->View->setDawnDuskTimes(almanac.getDawnAstronomicalTwilight(), almanac.getDuskAstronomicalTwilight());
     avtUI->View->setMinMaxSunAlt(almanac.getSunMinAlt(), almanac.getSunMaxAlt());
     */
 
     /* ... */
 }
 
 void AltVsTime::slotPrint()
 {
     QPainter p;            // Our painter object
     QPrinter printer;      // Our printer object
     QString str_legend;    // Text legend
     int text_height = 200; // Height of legend text zone in points
     QSize plot_size;       // Initial plot widget size
     QFont plot_font;       // Initial plot widget font
     int plot_font_size;    // Initial plot widget font size
 
     // Set printer resolution to 300 dpi
     printer.setResolution(300);
 
     // Open print dialog
     //QPointer<QPrintDialog> dialog( KdePrint::createPrintDialog( &printer, this ) );
     //QPointer<QPrintDialog> dialog( &printer, this );
     QPrintDialog dialog(&printer, this);
     dialog.setWindowTitle(i18nc("@title:window", "Print elevation vs time plot"));
     if (dialog.exec() == QDialog::Accepted)
     {
         // Change mouse cursor
         QApplication::setOverrideCursor(Qt::WaitCursor);
 
         // Save plot widget font
         plot_font = avtUI->View->font();
         // Save plot widget font size
         plot_font_size = plot_font.pointSize();
         // Save calendar widget size
         plot_size = avtUI->View->size();
 
         // Set text legend
         str_legend = i18n("Elevation vs. Time Plot");
         str_legend += '\n';
         str_legend += geo->fullName();
         str_legend += " - ";
         str_legend += avtUI->DateWidget->date().toString("dd/MM/yyyy");
 
         // Create a rectangle for legend text zone
         QRect text_rect(0, 0, printer.width(), text_height);
 
         // Increase plot widget font size so it looks good in 300 dpi
         plot_font.setPointSize(plot_font_size * 2.5);
         avtUI->View->setFont(plot_font);
         // Increase plot widget size to fit the entire page
         avtUI->View->resize(printer.width(), printer.height() - text_height);
 
         // Create a pixmap and render plot widget into it
         QPixmap pixmap(avtUI->View->size());
         avtUI->View->render(&pixmap);
 
         // Begin painting on printer
         p.begin(&printer);
         // Draw legend
         p.drawText(text_rect, Qt::AlignLeft, str_legend);
         // Draw plot widget
         p.drawPixmap(0, text_height, pixmap);
         // Ending painting
         p.end();
 
         // Restore plot widget font size
         plot_font.setPointSize(plot_font_size);
         avtUI->View->setFont(plot_font);
         // Restore calendar widget size
         avtUI->View->resize(plot_size);
 
         // Restore mouse cursor
         QApplication::restoreOverrideCursor();
     }
     //delete dialog;
 }
 
 QString AltVsTime::getObjectName(const SkyObject *o, bool translated)
 {
     QString finalObjectName;
     if (o->name() == "star")
     {
         StarObject *s = (StarObject *)o;
 
         // JM: Enable HD Index stars to be added to the observing list.
         if (s->getHDIndex() != 0)
             finalObjectName = QString("HD %1").arg(QString::number(s->getHDIndex()));
     }
     else
         finalObjectName = translated ? o->translatedName() : o->name();
 
     return finalObjectName;
 }