File indexing completed on 2024-04-28 15:11:24

 /*
     SPDX-FileCopyrightText: 2013 Samikshan Bairagya <samikshan@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "wiequipsettings.h"
 #include "oal/equipmentwriter.h"
 #include "kstars.h"
 #include "Options.h"
 
 #include <QListWidgetItem>
 
 WIEquipSettings::WIEquipSettings() : QFrame(KStars::Instance())
 {
     setupUi(this);
 
     ScopeListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
     binoDetailsFrame->setEnabled(kcfg_BinocularsCheck->isChecked());
     scopeFrame->setEnabled(kcfg_TelescopeCheck->isChecked());
 
     connect(kcfg_TelescopeCheck, SIGNAL(toggled(bool)), this, SLOT(slotTelescopeCheck(bool)));
     connect(kcfg_BinocularsCheck, SIGNAL(toggled(bool)), this, SLOT(slotBinocularsCheck(bool)));
     connect(ScopeListWidget, SIGNAL(currentRowChanged(int)), this, SLOT(slotScopeSelected(int)));
     connect(saveNewScopeButton, SIGNAL(clicked()), this, SLOT(slotAddNewScope()));
 
     populateScopeListWidget();
 }
 
 void WIEquipSettings::populateScopeListWidget()
 {
     ScopeListWidget->clear();
     ///Get telescope list from KStars user database.
     KStars::Instance()->data()->userdb()->GetAllScopes(m_ScopeList);
     foreach (OAL::Scope *scope, m_ScopeList)
     {
         QListWidgetItem *scopeItem = new QListWidgetItem;
         scopeItem->setText(scope->vendor());
         scopeItem->setData(Vendor, scope->vendor());
         scopeItem->setData(Model, scope->model());
         scopeItem->setData(Aperture, scope->aperture());
         scopeItem->setData(FocalLength, scope->focalLength());
         scopeItem->setData(Type, scope->type());
 
         ScopeListWidget->addItem(scopeItem);
     }
     if (ScopeListWidget->count() == 0)
         return;
 
     vendorText->setText(ScopeListWidget->item(0)->data(Vendor).toString());
     modelText->setText(ScopeListWidget->item(0)->data(Model).toString());
     apertureText->setText(ScopeListWidget->item(0)->data(Aperture).toString().append(" mm"));
 
     ScopeListWidget->setCurrentRow(Options::scopeListIndex());
 }
 
 void WIEquipSettings::slotTelescopeCheck(bool on)
 {
     scopeFrame->setEnabled(on);
     Options::setTelescopeCheck(on);
 }
 
 void WIEquipSettings::slotBinocularsCheck(bool on)
 {
     binoDetailsFrame->setEnabled(on);
     Options::setBinocularsCheck(on);
 }
 
 void WIEquipSettings::slotScopeSelected(int row)
 {
     if (row == -1)
         return;
 
     QListWidgetItem *item = ScopeListWidget->item(row);
 
     if (item == nullptr)
         return;
 
     vendorText->setText(item->data(Vendor).toString());
     modelText->setText(item->data(Model).toString());
     apertureText->setText(item->data(Aperture).toString().append(" mm"));
 
     if (item->data(Type).toString() == "Reflector")
         m_TelType = ObsConditions::Reflector;
     else if (item->data(Type).toString() == "Refractor")
         m_TelType = ObsConditions::Refractor;
 
     Options::setScopeListIndex(row);
 }
 
 void WIEquipSettings::slotAddNewScope()
 {
     EquipmentWriter equipmentdlg;
     equipmentdlg.loadEquipment();
     equipmentdlg.exec();
 
     populateScopeListWidget(); //Reload scope list widget
 }
 
 void WIEquipSettings::setAperture()
 {
     double telAperture  = INVALID_APERTURE;
     double binoAperture = INVALID_APERTURE;
 
     if (kcfg_TelescopeCheck->isChecked() && ScopeListWidget->selectedItems().isEmpty() == false)
         telAperture = ScopeListWidget->currentItem()->data(Aperture).toDouble();
     if (kcfg_BinocularsCheck->isChecked())
         binoAperture = kcfg_BinocularsAperture->value();
     m_Aperture = telAperture > binoAperture ? telAperture : binoAperture;
 
     // JM 2016-05-11: This is way over-complicated
     /*
     if (ScopeListWidget->count() == 0)
     {
         if (Options::binocularsCheck()z)
         {
             m_Aperture = kcfg_BinocularsAperture->value();
             return;
         }
         else
         {
             m_Aperture = INVALID_APERTURE;
             return;
         }
     }
 
     if (!Options::telescopeCheck() && !Options::binocularsCheck())
     {
         m_Aperture = INVALID_APERTURE;
     }
     else if (!Options::telescopeCheck())    //No telescope available, but binoculars available
     {
         m_Aperture = kcfg_BinocularsAperture->value();
     }
     else if (!Options::binocularsCheck())   //No binoculars available, but telescope available
     {
         if (ScopeListWidget->count() == 0)
         {
                 m_Aperture = INVALID_APERTURE;
                 return;
         }
         else
             m_Aperture = ScopeListWidget->currentItem()->data(Aperture).toDouble();
     }
     else                                    //Both Telescope and Binoculars available
     {
         if (ScopeListWidget->count() == 0)
         {
             m_Aperture = kcfg_BinocularsAperture->value();
             return;
         }
         //If both Binoculars and Telescope available then select bigger aperture
         double telAperture = ScopeListWidget->currentItem()->data(Aperture).toDouble();
         double binoAperture = kcfg_BinocularsAperture->value();
         m_Aperture = telAperture > binoAperture ? telAperture : binoAperture;
     }*/
 }