xypor/index.php

/*

    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 <QToolTip>


#include "kstars_debug.h"


AltVsTimeUI::AltVsTimeUI(QWidget *p) : QFrame(p)

{

    setupUi(this);

}


AltVsTime::AltVsTime(QWidget *parent) : QDialog(parent)

{

#ifdef Q_OS_MACOS

    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;

}


AltVsTime::AltVsTime
AltVsTime(QWidget *parent=nullptr)
Constructor.
Definition altvstime.cpp:42

AltVsTime::slotAddSource
void slotAddSource()
Add an object to the list of displayed objects, according to the data entered in the edit boxes.
Definition altvstime.cpp:253

AltVsTime::slotHighlight
void slotHighlight(int)
Update the plot to highlight the altitude curve of the objects which is highlighted in the listbox.
Definition altvstime.cpp:479

AltVsTime::findAltitude
double findAltitude(SkyPoint *p, double hour)
Determine the altitude coordinate of a SkyPoint, given an hour of the day.
Definition altvstime.cpp:467

AltVsTime::slotPrint
void slotPrint()
Print plot widget.
Definition altvstime.cpp:1389

AltVsTime::slotMarkSetTime
void slotMarkSetTime()
Mark the set time on the curve.
Definition altvstime.cpp:752

AltVsTime::showCurrentDate
void showCurrentDate()
Set the AltVsTime Date according to the current Date in the KStars main window.
Definition altvstime.cpp:1148

AltVsTime::setLSTLimits
void setLSTLimits()
Determine the limits for the sideral time axis, using the sidereal time at midnight for the current d...
Definition altvstime.cpp:1133

AltVsTime::plotMousePress
void plotMousePress(QCPAbstractPlottable *abstractPlottable, int dataIndex, QMouseEvent *event)
Show information from the curve as a tooltip.
Definition altvstime.cpp:551

AltVsTime::slotBrowseObject
void slotBrowseObject()
Launch the Find Object window to select a new object for the list of displayed objects.
Definition altvstime.cpp:349

AltVsTime::slotClearBoxes
void slotClearBoxes()
Clear the edit boxes for specifying a new object.
Definition altvstime.cpp:661

AltVsTime::slotChooseCity
void slotChooseCity()
Launch the Location dialog to choose a new location.
Definition altvstime.cpp:1116

AltVsTime::slotMarkTransitTime
void slotMarkTransitTime()
Mark the transit time on the curve.
Definition altvstime.cpp:802

AltVsTime::getDate
KStarsDateTime getDate()
Definition altvstime.cpp:1355

AltVsTime::getEpoch
double getEpoch(const QString &eName)
Parse a string as an epoch number.
Definition altvstime.cpp:1362

AltVsTime::mouseOverLine
void mouseOverLine(QMouseEvent *event)
Draw the white vertical line on click.
Definition altvstime.cpp:926

AltVsTime::onXRangeChanged
void onXRangeChanged(const QCPRange &range)
Update the X axis on Zoom and Drag.
Definition altvstime.cpp:527

AltVsTime::computeSunRiseSetTimes
void computeSunRiseSetTimes()
Determine the time of sunset and sunrise for the current date and location settings.
Definition altvstime.cpp:850

AltVsTime::slotUpdateDateLoc
void slotUpdateDateLoc()
Update the plot to reflec new Date and Location settings.
Definition altvstime.cpp:980

AltVsTime::slotClear
void slotClear()
Clear the list of displayed objects.
Definition altvstime.cpp:622

AltVsTime::processObject
void processObject(SkyObject *o, bool forceAdd=false)
Add a SkyObject to the display.
Definition altvstime.cpp:361

AltVsTime::slotMarkRiseTime
void slotMarkRiseTime()
Mark the rise time on the curve.
Definition altvstime.cpp:705

AltVsTime::~AltVsTime
~AltVsTime() override
Destructor.
Definition altvstime.cpp:249

AltVsTime::onYRangeChanged
void onYRangeChanged(const QCPRange &range)
Update the Y axis on Zoom and Drag.
Definition altvstime.cpp:545

AltVsTime::slotAdvanceFocus
void slotAdvanceFocus()
Move input keyboard focus to the next logical widget.
Definition altvstime.cpp:608

AltVsTime::slotComputeAltitudeByTime
void slotComputeAltitudeByTime()
Compute the altitude for a certain time.
Definition altvstime.cpp:669

AltVsTime::getObjectName
QString getObjectName(const SkyObject *o, bool translated=true)
get object name.
Definition altvstime.cpp:1460

FindDialog::targetObject
SkyObject * targetObject()
Definition finddialog.h:53

GeoLocation
Contains all relevant information for specifying a location on Earth: City Name, State/Province name,...
Definition geolocation.h:28

GeoLocation::fullName
QString fullName() const
Definition geolocation.cpp:46

GeoLocation::lat
const CachingDms * lat() const
Definition geolocation.h:70

GeoLocation::lng
const CachingDms * lng() const
Definition geolocation.h:64

KPlotWidget

KPlotWidget::backgroundColor
QColor backgroundColor() const

KPlotWidget::antialiasing
bool antialiasing() const

KSAlmanac
A class that implements methods to find sun rise, sun set, twilight begin / end times,...
Definition ksalmanac.h:27

KSNumbers
There are several time-dependent values used in position calculations, that are not specific to an ob...
Definition ksnumbers.h:43

KStarsData
KStarsData is the backbone of KStars.
Definition kstarsdata.h:74

KStarsData::lst
CachingDms * lst()
Definition kstarsdata.h:226

KStarsData::objectNamed
SkyObject * objectNamed(const QString &name)
Find object by name.
Definition kstarsdata.cpp:445

KStarsData::ut
const KStarsDateTime & ut() const
Definition kstarsdata.h:159

KStarsData::geo
GeoLocation * geo()
Definition kstarsdata.h:232

KStarsDateTime
Extension of QDateTime for KStars KStarsDateTime can represent the date/time as a Julian Day,...
Definition kstarsdatetime.h:36

KStarsDateTime::currentDateTimeUtc
static KStarsDateTime currentDateTimeUtc()
Definition kstarsdatetime.cpp:82

KStarsDateTime::currentDateTime
static KStarsDateTime currentDateTime()
Definition kstarsdatetime.cpp:73

LocationDialog
Dialog for changing the geographic location of the observer.
Definition locationdialog.h:61

QCPAbstractItem
The abstract base class for all items in a plot.
Definition qcustomplot.h:3714

QCPAbstractPlottable
The abstract base class for all data representing objects in a plot.
Definition qcustomplot.h:3496

QCPAxisTickerTime
Specialized axis ticker for time spans in units of milliseconds to days.
Definition qcustomplot.h:1847

QCPAxisTicker::tssReadability
@ tssReadability
A nicely readable tick step is prioritized over matching the requested number of ticks (see setTickCo...
Definition qcustomplot.h:1743

QCPGraph
A plottable representing a graph in a plot.
Definition qcustomplot.h:5495

QCPItemPixmap
An arbitrary pixmap.
Definition qcustomplot.h:6785

QCPItemPixmap::setPixmap
void setPixmap(const QPixmap &pixmap)
Definition qcustomplot.cpp:30185

QCPItemPixmap::setScaled
void setScaled(bool scaled, Qt::AspectRatioMode aspectRatioMode=Qt::KeepAspectRatio, Qt::TransformationMode transformationMode=Qt::SmoothTransformation)
Definition qcustomplot.cpp:30197

QCPItemPosition::setType
void setType(PositionType type)
Definition qcustomplot.cpp:12282

QCPItemPosition::setCoords
void setCoords(double key, double value)
Definition qcustomplot.cpp:12520

QCPItemPosition::ptPlotCoords
@ ptPlotCoords
Dynamic positioning at a plot coordinate defined by two axes (see setAxes).
Definition qcustomplot.h:3660

QCPItemTracer
Item that sticks to QCPGraph data points.
Definition qcustomplot.h:6854

QCPItemTracer::setBrush
void setBrush(const QBrush &brush)
Definition qcustomplot.cpp:30488

QCPItemTracer::tsCircle
@ tsCircle
A circle.
Definition qcustomplot.h:6876

QCPItemTracer::setStyle
void setStyle(TracerStyle style)
Definition qcustomplot.cpp:30518

QCPItemTracer::setGraphKey
void setGraphKey(double key)
Definition qcustomplot.cpp:30560

QCPItemTracer::setInterpolating
void setInterpolating(bool enabled)
Definition qcustomplot.cpp:30576

QCPItemTracer::setSize
void setSize(double size)
Definition qcustomplot.cpp:30507

QCPItemTracer::setGraph
void setGraph(QCPGraph *graph)
Definition qcustomplot.cpp:30533

QCPItemTracer::setPen
void setPen(const QPen &pen)
Definition qcustomplot.cpp:30468

QCPLayerable::setVisible
void setVisible(bool on)
Definition qcustomplot.cpp:1397

QCPLayerable::setLayer
Q_SLOT bool setLayer(QCPLayer *layer)
Definition qcustomplot.cpp:1411

QCPRange
Represents the range an axis is encompassing.
Definition qcustomplot.h:832

QCPRange::bounded
QCPRange bounded(double lowerBound, double upperBound) const
Definition qcustomplot.cpp:2030

QCustomPlot::limAbove
@ limAbove
Layer is inserted above other layer.
Definition qcustomplot.h:3812

SkyObject
Provides all necessary information about an object in the sky: its coordinates, name(s),...
Definition skyobject.h:42

SkyObject::clone
virtual SkyObject * clone() const
Create copy of object.
Definition skyobject.cpp:50

SkyObject::translatedName
QString translatedName() const
Definition skyobject.h:149

SkyObject::name
virtual QString name(void) const
Definition skyobject.h:146

SkyObject::isSolarSystem
bool isSolarSystem() const
Definition skyobject.h:218

SkyObject::transitTime
QTime transitTime(const KStarsDateTime &dt, const GeoLocation *geo) const
The same iteration technique described in riseSetTime() is used here.
Definition skyobject.cpp:239

SkyObject::riseSetTime
QTime riseSetTime(const KStarsDateTime &dt, const GeoLocation *geo, bool rst, bool exact=true) const
Determine the time at which the point will rise or set.
Definition skyobject.cpp:93

SkyPoint::dec
const CachingDms & dec() const
Definition skypoint.h:269

SkyPoint::updateCoordsNow
virtual void updateCoordsNow(const KSNumbers *num)
updateCoordsNow Shortcut for updateCoords( const KSNumbers *num, false, nullptr, nullptr,...
Definition skypoint.h:391

SkyPoint::ra
const CachingDms & ra() const
Definition skypoint.h:263

SkyPoint::altRefracted
dms altRefracted() const
Definition skypoint.cpp:1050

SkyPoint::EquatorialToHorizontal
void EquatorialToHorizontal(const CachingDms *LST, const CachingDms *lat)
Determine the (Altitude, Azimuth) coordinates of the SkyPoint from its (RA, Dec) coordinates,...
Definition skypoint.cpp:77

SkyPoint::updateCoords
virtual void updateCoords(const KSNumbers *num, bool includePlanets=true, const CachingDms *lat=nullptr, const CachingDms *LST=nullptr, bool forceRecompute=false)
Determine the current coordinates (RA, Dec) from the catalog coordinates (RA0, Dec0),...
Definition skypoint.cpp:582

StarObject
This is a subclass of SkyObject.
Definition starobject.h:33

StarObject::getHDIndex
int getHDIndex() const
Definition starobject.h:254

View

i18nc
QString i18nc(const char *context, const char *text, const TYPE &arg...)

i18n
QString i18n(const char *text, const TYPE &arg...)

Baloo::toString
char * toString(const EngineQuery &query)

QCP::iRangeDrag
@ iRangeDrag
0x001 Axis ranges are draggable (see QCPAxisRect::setRangeDrag, QCPAxisRect::setRangeDragAxes)
Definition qcustomplot.h:282

QCP::iRangeZoom
@ iRangeZoom
0x002 Axis ranges are zoomable with the mouse wheel (see QCPAxisRect::setRangeZoom,...
Definition qcustomplot.h:283

QCP::msBottom
@ msBottom
0x08 bottom margin
Definition qcustomplot.h:229

QCP::msTop
@ msTop
0x04 top margin
Definition qcustomplot.h:228

QCP::msLeft
@ msLeft
0x01 left margin
Definition qcustomplot.h:226

QBoxLayout::addWidget
void addWidget(QWidget *widget, int stretch, Qt::Alignment alignment)

QBrush

QChar

QColor

QColor::setAlpha
void setAlpha(int alpha)

QDateTime

QDateTime::date
QDate date() const const

QDialog

QDialog::Accepted
Accepted

QDialog::exec
virtual int exec()

QDialog::setModal
void setModal(bool modal)

QDialog::reject
virtual void reject()

QDialog::rejected
void rejected()

QDialogButtonBox

QDialogButtonBox::ActionRole
ActionRole

QDialogButtonBox::Close
Close

QDialogButtonBox::addButton
QPushButton * addButton(StandardButton button)

QFont

QFont::pointSize
int pointSize() const const

QFont::setPointSize
void setPointSize(int pointSize)

QFrame

QGradient::setColorAt
void setColorAt(qreal position, const QColor &color)

QGuiApplication::restoreOverrideCursor
void restoreOverrideCursor()

QGuiApplication::setOverrideCursor
void setOverrideCursor(const QCursor &cursor)

QIcon

QIcon::fromTheme
QIcon fromTheme(const QString &name)

QLayout::setContentsMargins
void setContentsMargins(const QMargins &margins)

QLinearGradient

QLinearGradient::setFinalStop
void setFinalStop(const QPointF &stop)

QLinearGradient::setStart
void setStart(const QPointF &start)

QList::append
void append(QList< T > &&value)

QList::at
const_reference at(qsizetype i) const const

QList::clear
void clear()

QList::count
qsizetype count() const const

QList::isEmpty
bool isEmpty() const const

QList::push_back
void push_back(parameter_type value)

QList::replace
void replace(qsizetype i, parameter_type value)

QList::size
qsizetype size() const const

QList::takeFirst
value_type takeFirst()

QLocale

QLocale::ShortFormat
ShortFormat

QMargins

QMouseEvent

QObject::connect
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

QObject::objectName
objectName

QObject::qobject_cast
T qobject_cast(QObject *object)

QObject::sender
QObject * sender() const const

QPaintDevice::height
int height() const const

QPaintDevice::width
int width() const const

QPainter

QPainter::Antialiasing
Antialiasing

QPainter::begin
bool begin(QPaintDevice *device)

QPainter::drawEllipse
void drawEllipse(const QPoint &center, int rx, int ry)

QPainter::drawLine
void drawLine(const QLine &line)

QPainter::drawPixmap
void drawPixmap(const QPoint &point, const QPixmap &pixmap)

QPainter::drawText
void drawText(const QPoint &position, const QString &text)

QPainter::end
bool end()

QPainter::fillRect
void fillRect(const QRect &rectangle, QGradient::Preset preset)

QPainter::font
const QFont & font() const const

QPainter::opacity
qreal opacity() const const

QPainter::restore
void restore()

QPainter::rotate
void rotate(qreal angle)

QPainter::save
void save()

QPainter::setBrush
void setBrush(Qt::BrushStyle style)

QPainter::setClipRect
void setClipRect(const QRect &rectangle, Qt::ClipOperation operation)

QPainter::setClipping
void setClipping(bool enable)

QPainter::setFont
void setFont(const QFont &font)

QPainter::setOpacity
void setOpacity(qreal opacity)

QPainter::setPen
void setPen(Qt::PenStyle style)

QPainter::setRenderHint
void setRenderHint(RenderHint hint, bool on)

QPainter::translate
void translate(const QPoint &offset)

QPen

QPixmap

QPixmap::fill
void fill(const QColor &color)

QPixmap::rect
QRect rect() const const

QPointer

QPointF

QPrintDialog

QPrintDialog::exec
virtual int exec() override

QPrinter

QPrinter::setResolution
void setResolution(int dpi)

QPushButton

QRect

QRect::height
int height() const const

QRect::width
int width() const const

QRectF

QSharedPointer

QSize

QString

QString::arg
QString arg(Args &&... args) const const

QString::isEmpty
bool isEmpty() const const

QString::number
QString number(double n, char format, int precision)

QString::toDouble
double toDouble(bool *ok) const const

Qt::AlignLeft
AlignLeft

Qt::IgnoreAspectRatio
IgnoreAspectRatio

Qt::WaitCursor
WaitCursor

Qt::white
white

Qt::RightButton
RightButton

Qt::DotLine
DotLine

Qt::UTC
UTC

Qt::Tool
Tool

QTime

QTime::addSecs
QTime addSecs(int s) const const

QTime::hour
int hour() const const

QTime::isValid
bool isValid(int h, int m, int s, int ms)

QTime::minute
int minute() const const

QTime::second
int second() const const

QTime::toString
QString toString(QStringView format) const const

QToolTip::hideText
void hideText()

QToolTip::showText
void showText(const QPoint &pos, const QString &text, QWidget *w, const QRect &rect, int msecDisplayTime)

QVBoxLayout

QVector

QWidget

QWidget::setEnabled
void setEnabled(bool)

QWidget::event
virtual bool event(QEvent *event) override

QWidget::font
font

QWidget::lower
void lower()

QWidget::setMouseTracking
void setMouseTracking(bool enable)

QWidget::rect
rect

QWidget::render
void render(QPaintDevice *target, const QPoint &targetOffset, const QRegion &sourceRegion, RenderFlags renderFlags)

QWidget::setFocus
void setFocus()

QWidget::setLayout
void setLayout(QLayout *layout)

QWidget::show
void show()

QWidget::size
size

QWidget::setToolTip
void setToolTip(const QString &)

QWidget::update
void update()

QWidget::setVisible
virtual void setVisible(bool visible)

QWidget::setWindowFlags
void setWindowFlags(Qt::WindowFlags type)

QWidget::setWindowTitle
void setWindowTitle(const QString &)

QWidget::x
x

QWidget::y
y