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

 /*
     SPDX-FileCopyrightText: 2018 Valentin Boettcher <valentin@boettcher.cf>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "eclipsetool.h"
 #include "ui_eclipsetool.h"
 #include "ksplanetbase.h"
 #include "kstarsdata.h"
 #include "geolocation.h"
 #include "dialogs/locationdialog.h"
 #include "kstars.h"
 #include "skymap.h"
 
 #include <QtConcurrent>
 #include <QFileDialog>
 #include <QErrorMessage>
 #include <QMenu>
 
 EclipseTool::EclipseTool(QWidget *parent) :
     QFrame(parent),
     ui(new Ui::EclipseTool)
 {
     ui->setupUi(this);
 
     // set up the eclipse-partner selection
     ui->Obj1ComboBox->addItem(i18n("Earth Shadow"), KSPlanetBase::EARTH_SHADOW);
     ui->Obj2ComboBox->addItem(i18n("Moon"), KSPlanetBase::MOON);
 
     KStarsData *kd = KStarsData::Instance();
     KStarsDateTime dtStart(KStarsDateTime::currentDateTime());
     KStarsDateTime dtStop(dtStart.djd() + 365.24l); // one year
 
     m_geoLocation = kd->geo();
     ui->LocationButton->setText(m_geoLocation->fullName());
 
     ui->startDate->setDateTime(dtStart);
     ui->stopDate->setDateTime(dtStop);
 
     ui->ClearButton->setIcon(QIcon::fromTheme("edit-clear"));
 
     // set up slots
     connect(ui->LocationButton, &QPushButton::clicked, this, &EclipseTool::slotLocation);
     connect(ui->ComputeButton, &QPushButton::clicked, this, [&, this]() {
         // switch to progress bar
         ui->computeStack->setCurrentIndex(1);
 
         // reset progress
         ui->progressBar->setValue(0);
 
         QtConcurrent::run(this, &EclipseTool::slotCompute);
     });
 
     connect(ui->ClearButton, &QPushButton::clicked, &m_model, &EclipseModel::reset);
     connect(ui->ExportButton, &QPushButton::clicked, &m_model, &EclipseModel::exportAsCsv);
 
     // eclipse table
     ui->tableView->setModel(&m_model);
     ui->tableView->horizontalHeader()->setStretchLastSection(true);
     ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
 
     // double click to view
     connect(ui->tableView, &QTableView::doubleClicked, this, [this](const QModelIndex &index){
         slotView(m_model.getEvent(index.row()));
     });
 
     connect(ui->tableView, &QTableView::customContextMenuRequested, this,  &EclipseTool::slotContextMenu);
 
     ui->progressBar->setMinimum(0);
     ui->progressBar->setMaximum(100);
 }
 
 EclipseTool::~EclipseTool()
 {
     delete ui;
 }
 
 void EclipseTool::slotLocation()
 {
     QPointer<LocationDialog> ld(new LocationDialog(this));
     if (ld->exec() == QDialog::Accepted && ld)
     {
         m_geoLocation = ld->selectedCity();
         ui->LocationButton->setText(m_geoLocation->fullName());
     }
     delete ld;
 }
 
 // NOTE: This will need redesign some day.
 void EclipseTool::slotCompute()
 {
     EclipseHandler * handler;
     KStarsDateTime dtStart(ui->startDate->dateTime()); // start date
     KStarsDateTime dtStop(ui->stopDate->dateTime());  // stop date
     long double startJD    = dtStart.djd();         // start julian day
     long double stopJD     = dtStop.djd();
 
     if(ui->Obj1ComboBox->currentData().toInt() == KSPlanetBase::EARTH_SHADOW && ui->Obj2ComboBox->currentData().toInt() == KSPlanetBase::MOON){
         handler = new LunarEclipseHandler();
     } else
         return;
 
     connect(handler, &EclipseHandler::signalEventFound, &m_model, &EclipseModel::slotAddEclipse);
     connect(handler, &EclipseHandler::signalProgress, ui->progressBar, &QProgressBar::setValue);
     connect(handler, &EclipseHandler::signalComputationFinished, this, &EclipseTool::slotFinished);
 
     handler->setGeoLocation(m_geoLocation);
 
     // let's go
     EclipseHandler::EclipseVector eclipses = handler->computeEclipses(startJD, stopJD);
     delete handler;
 }
 
 void EclipseTool::slotFinished()
 {
     ui->computeStack->setCurrentIndex(0);
 }
 
 void EclipseTool::slotContextMenu(QPoint pos)
 {
     int row = ui->tableView->indexAt(pos).row();
     EclipseEvent_s event = m_model.getEvent(row);
 
     QMenu * menu = new QMenu(this);
     QAction * view = new QAction(i18n("View in SkyMap"), menu);
     connect(view, &QAction::triggered, this, [=]{
         slotView(event);
     });
     menu->addAction(view);
 
     if(event->hasDetails()){
         QAction * details = new QAction(i18n("Show Details"), menu);
         connect(details, &QAction::triggered, this, [=] {
             event->slotShowDetails(); // call virtual
         });
         menu->addAction(details);
     }
 
     menu->popup(ui->tableView->viewport()->mapToGlobal(pos));
 }
 
 void EclipseTool::slotView(EclipseEvent_s event)
 {
     SkyMap * map = KStars::Instance()->map();
     KStarsData * data = KStarsData::Instance();
     KStarsDateTime dt;
 
     dt.setDJD(event->getJD());
     data->changeDateTime(dt);
     data->setLocation(event->getGeolocation());
 
     map->setClickedObject(event->getEclipsingObjectFromSkyComposite());
     map->setClickedPoint(map->clickedObject());
     map->slotCenter();
 }
 
 EclipseModel::EclipseModel(QObject *parent) : QAbstractTableModel (parent)
 {
 
 }
 
 int EclipseModel::rowCount(const QModelIndex &) const
 {
     return m_eclipses.length();
 }
 
 QVariant EclipseModel::data(const QModelIndex &index, int role) const
 {
     int row = index.row();
     int col = index.column();
 
     if(role != Qt::DisplayRole)
         return QVariant();
 
     EclipseEvent * event = m_eclipses[row].get();
 
     switch(col) {
     case 0: /* Date */ {
         KStarsDateTime dt(event->getJD());
         return dt.toString(Qt::ISODate);
     }
     case 1: // Eclipsing Obj
         return event->getEclipsingObjectName();
     case 2: // Eclipsed Obj
         return event->getEclipsedObjectName();
     case 3: /* Eclipse Type */ {
         switch(event->getType()) {
         case EclipseEvent::FULL:
             return QString(i18n("Full"));
         case EclipseEvent::PARTIAL:
             return QString(i18n("Partial"));
         }
         break;
     }
     case 4: // Extra Info
         return event->getExtraInfo();
     }
 
     return QVariant();
 }
 
 void EclipseModel::slotAddEclipse(EclipseEvent_s eclipse)
 {
     m_eclipses.append(eclipse);
     emit layoutChanged(); // there must be a better way
 }
 
 void EclipseModel::exportAsCsv()
 {
     int i, j;
     QByteArray line;
 
     QFileDialog dialog;
     dialog.setNameFilter(i18n("CSV Files (*.csv)"));
     dialog.setDefaultSuffix("csv");
     dialog.setWindowTitle(i18nc("@title:window", "Export Eclipses"));
 
     QString fname;
     if(dialog.exec())
         fname = dialog.selectedFiles()[0];
     else {
         QErrorMessage msg;
         msg.showMessage(i18n("Could not export."));
         return;
     }
 
     QFile file(fname);
 
     file.open(QIODevice::WriteOnly | QIODevice::Text);
 
     for (i = 0; i < rowCount(); ++i)
     {
         for (j = 0; j < columnCount(); ++j)
         {
             line.append(data(index(i, j), Qt::DisplayRole).toByteArray());
             if (j < columnCount() - 1)
                 line.append(";");
             else
                 line.append("\n");
         }
         file.write(line);
         line.clear();
     }
 
     file.close();
 }
 
 QVariant EclipseModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (role == Qt::DisplayRole)
     {
         if (orientation == Qt::Horizontal) {
             switch (section)
             {
             case 0:
                 return QString("Date");
             case 1:
                 return QString("Eclipsing Object");
             case 2:
                 return QString("Eclipsed Object");
             case 3:
                 return QString("Eclipse Type");
             case 4:
                 return QString("Extra Information");
             }
         }
     }
     return QVariant();
 }
 
 void EclipseModel::reset()
 {
     emit beginResetModel();
     emit endResetModel();
 }