Kstars

capture.cpp
1/*
2 SPDX-FileCopyrightText: 2012 Jasem Mutlaq <mutlaqja@ikarustech.com>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include "capture.h"
8#include "opsmiscsettings.h"
9#include "opsdslrsettings.h"
10#include <KConfigDialog>
11
12#include "cameraprocess.h"
13#include "camerastate.h"
14#include "capturedeviceadaptor.h"
15#include "captureadaptor.h"
16#include "refocusstate.h"
17#include "kstars.h"
18#include "kstarsdata.h"
19#include "Options.h"
20#include "sequencejob.h"
21#include "placeholderpath.h"
22#include "ekos/manager.h"
23#include "ekos/auxiliary/darklibrary.h"
24#include "ekos/auxiliary/opticaltrainmanager.h"
25#include "ekos/auxiliary/profilesettings.h"
26#include "auxiliary/ksmessagebox.h"
27
28#include "scriptsmanager.h"
29#include "fitsviewer/fitsdata.h"
30#include "indi/driverinfo.h"
31#include "indi/indifilterwheel.h"
32#include "indi/indicamera.h"
33#include "indi/indirotator.h"
34#include "ekos/guide/guide.h"
35#include <basedevice.h>
36
37#include <ekos_capture_debug.h>
38#include <qlineedit.h>
39
40#define MF_TIMER_TIMEOUT 90000
41#define MF_RA_DIFF_LIMIT 4
42
43// Qt version calming
44#include <qtendl.h>
45
46#define KEY_FILTERS "filtersList"
47#define TAB_BUTTON_SIZE 20
48
49namespace Ekos
50{
51
52Capture::Capture()
53{
54 setupUi(this);
55 prepareGUI();
56
57 qRegisterMetaType<CaptureState>("CaptureState");
58 qDBusRegisterMetaType<CaptureState>();
59 new CaptureAdaptor(this);
60 // initialize the global capture state
61 m_moduleState.reset(new CaptureModuleState());
62
63 // Adding the "New Tab" tab
64 QWidget *newTab = new QWidget;
65 QPushButton *addButton = new QPushButton;
66 addButton->setIcon(QIcon::fromTheme("list-add"));
67 addButton->setFixedSize(TAB_BUTTON_SIZE, TAB_BUTTON_SIZE);
68 addButton->setToolTip(i18n("<p>Add additional camera</p><p><b>WARNING</b>: This feature is experimental!</p>"));
69 connect(addButton, &QPushButton::clicked, this, &Capture::addCamera);
70
71 cameraTabs->addTab(newTab, "");
72 cameraTabs->tabBar()->setTabButton(0, QTabBar::RightSide, addButton);
73 // Connect the close request signal to the slot
74 connect(cameraTabs, &QTabWidget::tabCloseRequested, this, &Capture::checkCloseCameraTab);
75 // Create main camera
76 addCamera();
77
78 QDBusConnection::sessionBus().registerObject("/KStars/Ekos/Capture", this);
79 QPointer<QDBusInterface> ekosInterface = new QDBusInterface("org.kde.kstars", "/KStars/Ekos", "org.kde.kstars.Ekos",
81
82 // Connecting DBus signals
83 QDBusConnection::sessionBus().connect("org.kde.kstars", "/KStars/Ekos", "org.kde.kstars.Ekos", "newModule", this,
85
86 // ensure that the mount interface is present
87 registerNewModule("Mount");
88
89 DarkLibrary::Instance()->setCaptureModule(this);
90
91 // connection to the global module state
92 connect(m_moduleState.get(), &CaptureModuleState::dither, this, &Capture::dither);
93 connect(m_moduleState.get(), &CaptureModuleState::newLog, this, &Capture::appendLogText);
94}
95
96
98{
99 KConfigDialog *dialog = new KConfigDialog(this, "capturesettings", Options::self());
100
101#ifdef Q_OS_MACOS
103#endif
104
105 m_OpsMiscSettings = new OpsMiscSettings();
106 KPageWidgetItem *page = dialog->addPage(m_OpsMiscSettings, i18n("Misc"), nullptr, i18n("Capture Misc"), false);
107 page->setIcon(QIcon::fromTheme("configure"));
108
109 m_OpsDslrSettings = new OpsDslrSettings();
110 page = dialog->addPage(m_OpsDslrSettings, i18n("DSLR"), nullptr, i18n("Capture DSLR"), false);
111 page->setIcon(QIcon::fromTheme("camera-photo"));
112
113
114}
115QSharedPointer<Camera> Capture::addCamera()
116{
117 QSharedPointer<Camera> newCamera;
118 newCamera.reset(new Camera(cameras().count(), false, nullptr));
119
120 // create the new tab and bring it to front
121 const int tabIndex = cameraTabs->insertTab(std::max(0, cameraTabs->count() - 1), newCamera.get(), "new Camera");
122 cameraTabs->setCurrentIndex(tabIndex);
123 // make the tab first tab non closeable
124 if (tabIndex == 0)
125 cameraTabs->tabBar()->setTabButton(0, QTabBar::RightSide, nullptr);
126
127 // forward signals from the camera
128 connect(newCamera.get(), &Camera::newLog, this, &Capture::appendLogText);
129 connect(newCamera.get(), &Camera::refreshCamera, this, &Capture::updateCamera);
130 connect(newCamera.get(), &Camera::sequenceChanged, this, &Capture::sequenceChanged);
131 connect(newCamera.get(), &Camera::newLocalPreview, this, &Capture::newLocalPreview);
132 connect(newCamera.get(), &Camera::dslrInfoRequested, this, &Capture::dslrInfoRequested);
133 connect(newCamera.get(), &Camera::trainChanged, this, &Capture::trainChanged);
134 connect(newCamera.get(), &Camera::settingsUpdated, this, &Capture::settingsUpdated);
135 connect(newCamera.get(), &Camera::filterManagerUpdated, this, &Capture::filterManagerUpdated);
136 connect(newCamera.get(), &Camera::newFilterStatus, this, &Capture::newFilterStatus);
137 connect(newCamera.get(), &Camera::ready, this, &Capture::ready);
138 connect(newCamera.get(), &Camera::newExposureProgress, this, &Capture::newExposureProgress);
139 connect(newCamera.get(), &Camera::captureComplete, this, &Capture::captureComplete);
140 connect(newCamera.get(), &Camera::captureStarting, this, &Capture::captureStarting);
141 connect(newCamera.get(), &Camera::captureAborted, this, &Capture::captureAborted);
142 connect(newCamera.get(), &Camera::checkFocus, this, &Capture::checkFocus);
143 connect(newCamera.get(), &Camera::newImage, this, &Capture::newImage);
144 connect(newCamera.get(), &Camera::runAutoFocus, this, &Capture::runAutoFocus);
145 connect(newCamera.get(), &Camera::resetFocusFrame, this, &Capture::resetFocusFrame);
146 connect(newCamera.get(), &Camera::abortFocus, this, &Capture::abortFocus);
147 connect(newCamera.get(), &Camera::adaptiveFocus, this, &Capture::adaptiveFocus);
148 connect(newCamera.get(), &Camera::meridianFlipStarted, this, &Capture::meridianFlipStarted);
149 connect(newCamera.get(), &Camera::captureTarget, this, &Capture::captureTarget);
150 connect(newCamera.get(), &Camera::guideAfterMeridianFlip, this, &Capture::guideAfterMeridianFlip);
151 connect(newCamera.get(), &Camera::newStatus, this, &Capture::newStatus);
152 connect(newCamera.get(), &Camera::suspendGuiding, this, &Capture::suspendGuiding);
153 connect(newCamera.get(), &Camera::resumeGuiding, this, &Capture::resumeGuiding);
154 connect(newCamera.get(), &Camera::resetNonGuidedDither, this, &Capture::resetNonGuidedDither);
155 connect(newCamera.get(), &Camera::driverTimedout, this, &Capture::driverTimedout);
156
157 const QString train = findUnusedOpticalTrain();
158 // select an unused train
159 if (train != "")
160 newCamera->opticalTrainCombo->setCurrentText(train);
161 moduleState()->addCamera(newCamera);
162 // update the tab text
163 updateCamera(tabIndex, true);
164
165 return newCamera;
166}
167
168const QString Capture::findUnusedOpticalTrain()
169{
170 QList<QString> names = OpticalTrainManager::Instance()->getTrainNames();
171 foreach(auto cam, cameras())
172 names.removeAll(cam->opticalTrain());
173
174 if (names.isEmpty())
175 return "";
176 else
177 return names.first();
178}
179
180void Capture::updateCamera(int tabID, bool isValid)
181{
182 if (isValid)
183 {
184 if (tabID < cameraTabs->count() && tabID < cameras().count())
185 {
186 auto cam = moduleState()->mutableCameras()[tabID];
187
188 if (cam->activeCamera() != nullptr)
189 {
190 auto name = cam->activeCamera()->getDeviceName();
191 cameraTabs->setTabText(tabID, name);
192 }
193
194 // update shared attributes
195 cam->state()->getRefocusState()->setForceInSeqAF(moduleState()->forceInSeqAF(cam->opticalTrain()));
196 }
197 else
198 qCWarning(KSTARS_EKOS_CAPTURE) << "Unknown camera ID:" << tabID;
199 }
200 else
201 cameraTabs->setTabText(cameraTabs->currentIndex(), "no camera");
202}
203
204
206{
207 return process()->setDome(device);
208}
209
211{
212 if (mainCamera()->m_standAlone)
213 return;
214 if (name == "Mount" && mountInterface == nullptr)
215 {
216 qCDebug(KSTARS_EKOS_CAPTURE) << "Registering new Module (" << name << ")";
217 mountInterface = new QDBusInterface("org.kde.kstars", "/KStars/Ekos/Mount",
218 "org.kde.kstars.Ekos.Mount", QDBusConnection::sessionBus(), this);
219 }
220}
221
222QString Capture::camera()
223{
224 if (mainCameraDevices()->getActiveCamera())
225 return mainCameraDevices()->getActiveCamera()->getDeviceName();
226
227 return QString();
228}
229
230void Capture::setGuideChip(ISD::CameraChip * guideChip)
231{
232 // We should suspend guide in two scenarios:
233 // 1. If guide chip is within the primary CCD, then we cannot download any data from guide chip while primary CCD is downloading.
234 // 2. If we have two CCDs running from ONE driver (Multiple-Devices-Per-Driver mpdp is true). Same issue as above, only one download
235 // at a time.
236 // After primary CCD download is complete, we resume guiding.
237 if (!mainCameraDevices()->getActiveCamera())
238 return;
239
240 mainCameraState()->setSuspendGuidingOnDownload((mainCameraDevices()->getActiveCamera()->getChip(
241 ISD::CameraChip::GUIDE_CCD) == guideChip) ||
242 (guideChip->getCCD() == mainCameraDevices()->getActiveCamera() &&
243 mainCameraDevices()->getActiveCamera()->getDriverInfo()->getAuxInfo().value("mdpd", false).toBool()));
244}
245
246void Capture::setFocusStatus(FocusState newstate, const QString &trainname)
247{
248 // publish to all known focusers using the same optical train (should be only one)
249 for (auto &cam : cameras())
250 if (trainname == "" || cam->opticalTrain() == trainname)
251 cam->setFocusStatus(newstate);
252}
253
254void Capture::focusAdaptiveComplete(bool success, const QString &trainname)
255{
256 // publish to all known focusers using the same optical train (should be only one)
257 for (auto &cam : cameras())
258 if (trainname == "" || cam->opticalTrain() == trainname)
259 cam->focusAdaptiveComplete(success);
260}
261
262QString Capture::filterWheel()
263{
264 if (mainCameraDevices()->filterWheel())
265 return mainCameraDevices()->filterWheel()->getDeviceName();
266
267 return QString();
268}
269
270bool Capture::setFilter(const QString &filter)
271{
272 if (mainCameraDevices()->filterWheel())
273 {
274 mainCamera()->FilterPosCombo->setCurrentText(filter);
275 return true;
276 }
277
278 return false;
279}
280
281QString Capture::filter()
282{
283 return mainCamera()->FilterPosCombo->currentText();
284}
285
286bool Capture::loadSequenceQueue(const QString &fileURL, QString train, bool isLead, QString targetName)
287{
289 if (train == "")
290 cam = mainCamera();
291 else if (isLead)
292 {
293 // take the main camera, and select the train if necessary
294 if (mainCamera()->opticalTrain() != train)
295 mainCamera()->selectOpticalTrain(train);
296
297 cam = mainCamera();
298 }
299 else
300 {
301 // find the camera, create a new one if necessary
302 int pos = findCamera(train, true);
303 if (pos < 0)
304 return false;
305 else
306 cam = camera(pos);
307 }
308 // camera found, load the sequence queue
309 return cam->loadSequenceQueue(fileURL, targetName);
310}
311
312
313void Capture::appendLogText(const QString &text)
314{
315 m_LogText.insert(0, i18nc("log entry; %1 is the date, %2 is the text", "%1 %2",
316 KStarsData::Instance()->lt().toString("yyyy-MM-ddThh:mm:ss"), text));
317
318 qCInfo(KSTARS_EKOS_CAPTURE) << text;
319
320 emit newLog(text);
321}
322
323void Capture::clearLog()
324{
325 m_LogText.clear();
326 emit newLog(QString());
327}
328
329void Capture::setFocusTemperatureDelta(double focusTemperatureDelta, double absTemperture, const QString &trainname)
330{
331 Q_UNUSED(absTemperture);
332 // publish to all known focusers using the same optical train (should be only one)
333 for (auto &cam : cameras())
334 if (trainname == "" || cam->opticalTrain() == trainname)
335 cam->state()->getRefocusState()->setFocusTemperatureDelta(focusTemperatureDelta);
336}
337
338void Capture::setGuideDeviation(double delta_ra, double delta_dec)
339{
340 // forward it to the global state machine
341 moduleState()->setGuideDeviation(delta_ra, delta_dec);
342
343}
344
346{
347 // This function is called independently from the Scheduler or the UI, so honor the change
348 mainCameraState()->setIgnoreJobProgress(true);
349}
350
351void Capture::setCapturedFramesMap(const QString &signature, int count, QString train)
352{
354 if (train == "")
355 cam = mainCamera();
356 else
357 {
358 // find the camera, create a new one if necessary
359 int pos = findCamera(train, true);
360 if (pos < 0)
361 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot set the captured frames map for train" << train;
362 else
363 cam = camera(pos);
364 }
365 // camera found, set the captured frames map
366 cam->state()->setCapturedFramesCount(signature, count);
367}
368
369void Capture::setAlignStatus(AlignState newstate)
370{
371 // forward it directly to the state machine
372 mainCameraState()->setAlignState(newstate);
373}
374
375void Capture::setGuideStatus(GuideState newstate)
376{
377 // forward to state machine
378 moduleState()->setGuideStatus(newstate);
379}
380
381bool Capture::setVideoLimits(uint16_t maxBufferSize, uint16_t maxPreviewFPS)
382{
383 if (mainCameraDevices()->getActiveCamera() == nullptr)
384 return false;
385
386 return mainCameraDevices()->getActiveCamera()->setStreamLimits(maxBufferSize, maxPreviewFPS);
387}
388
390{
392 if (train == "")
393 cam = mainCamera();
394 else
395 {
396 // find the camera, create a new one if necessary
397 int pos = findCamera(train, true);
398 if (pos < 0)
399 {
400 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot start capturing for train" << train;
401 return "";
402 }
403 else
404 cam = camera(pos);
405 }
406 // camera found, start capturing
407 cam->start();
408 // return the real train name
409 return cam->opticalTrain();
410}
411
413{
415 if (train == "")
416 for (auto cam : cameras())
417 cam->abort();
418 else
419 {
420 int pos = findCamera(train, false);
421 if (pos < 0)
422 {
423 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot abort capturing for train" << train;
424 return;
425 }
426 else
427 cam = camera(pos);
428
429 // camera found, abort capturing
430 cam->abort();
431 }
432}
433
434QSharedPointer<Camera> &Capture::camera(int i)
435{
436 if (i < cameras().count())
437 return moduleState()->mutableCameras()[i];
438 else
439 {
440 qCWarning(KSTARS_EKOS_CAPTURE) << "Unknown camera ID:" << i;
441 return moduleState()->mutableCameras()[0];
442 }
443}
444
445void Ekos::Capture::closeCameraTab(int tabIndex)
446{
447 cameraTabs->removeTab(tabIndex);
448 moduleState()->removeCamera(tabIndex);
449 // select the next one on the left
450 cameraTabs->setCurrentIndex(std::max(0, tabIndex - 1));
451}
452
453void Capture::checkCloseCameraTab(int tabIndex)
454{
455 // ignore close event from the "Add" tab
456 if (tabIndex == cameraTabs->count() - 1)
457 return;
458
459 if (moduleState()->mutableCameras()[tabIndex]->state()->isBusy())
460 {
461 // if accept has been clicked, abort and close the tab
462 connect(KSMessageBox::Instance(), &KSMessageBox::accepted, this, [this, &tabIndex]()
463 {
464 KSMessageBox::Instance()->disconnect(this);
465 moduleState()->mutableCameras()[tabIndex]->abort();
466 closeCameraTab(tabIndex);
467 });
468 // if cancel has been clicked, do not close the tab
469 connect(KSMessageBox::Instance(), &KSMessageBox::rejected, this, [this]()
470 {
471 KSMessageBox::Instance()->disconnect(this);
472 });
473
474 KSMessageBox::Instance()->warningContinueCancel(i18n("Camera %1 is busy. Abort to close?",
475 moduleState()->mutableCameras()[tabIndex]->activeCamera()->getDeviceName()), i18n("Stop capturing"), 30, false,
476 i18n("Abort"));
477 }
478 else
479 {
480 closeCameraTab(tabIndex);
481 }
482}
483
484const QSharedPointer<Camera> Capture::mainCamera() const
485{
486 if (cameras().size() > 0)
487 return moduleState()->cameras()[0];
488 else
489 {
491 cms.reset(new CaptureModuleState());
492 // TODO FIXME
493 //return QSharedPointer<Camera>(new Camera(cms));
494 return QSharedPointer<Camera>(new Camera(0));
495 }
496}
497
498int Capture::findCamera(QString train, bool addIfNecessary)
499{
500 for (auto &cam : cameras())
501 {
502 if (cam->opticalTrain() == train)
503 return cam->m_cameraId;
504 }
505
506 // none found
507 if (addIfNecessary)
508 {
509 QSharedPointer<Camera> cam = addCamera();
510 cam->selectOpticalTrain(train);
511 return cam->m_cameraId;
512 }
513 // nothing found
514 return -1;
515}
516
517void Capture::setMountStatus(ISD::Mount::Status newState)
518{
519 switch (newState)
520 {
521 case ISD::Mount::MOUNT_PARKING:
522 case ISD::Mount::MOUNT_SLEWING:
523 case ISD::Mount::MOUNT_MOVING:
524 mainCamera()->previewB->setEnabled(false);
525 mainCamera()->liveVideoB->setEnabled(false);
526 // Only disable when button is "Start", and not "Stopped"
527 // If mount is in motion, Stopped button should always be enabled to terminate
528 // the sequence
529 if (mainCameraState()->isBusy() == false)
530 mainCamera()->startB->setEnabled(false);
531 break;
532
533 default:
534 if (mainCameraState()->isBusy() == false)
535 {
536 mainCamera()->previewB->setEnabled(true);
537 if (mainCameraDevices()->getActiveCamera())
538 mainCamera()->liveVideoB->setEnabled(mainCameraDevices()->getActiveCamera()->hasVideoStream());
539 mainCamera()->startB->setEnabled(true);
540 }
541
542 break;
543 }
544}
545
546void Capture::setAlignResults(double solverPA, double ra, double de, double pixscale)
547{
548 Q_UNUSED(ra)
549 Q_UNUSED(de)
550 Q_UNUSED(pixscale)
551 if (mainCameraDevices()->rotator() && mainCamera()->m_RotatorControlPanel)
552 mainCamera()->m_RotatorControlPanel->refresh(solverPA);
553}
554
555void Capture::setMeridianFlipState(QSharedPointer<MeridianFlipState> newstate)
556{
557 mainCameraState()->setMeridianFlipState(newstate);
558 connect(mainCameraState()->getMeridianFlipState().get(), &MeridianFlipState::newLog, this, &Capture::appendLogText);
559 connect(mainCameraState()->getMeridianFlipState().get(), &MeridianFlipState::newMountMFStatus, moduleState().get(),
560 &CaptureModuleState::updateMFMountState);
561}
562
564{
565 bool result = false;
566 for (auto &cam : cameras())
567 if (cam->process()->hasCoolerControl())
568 result |= cam->process()->hasCoolerControl();
569 return result;
570}
571
573{
574 bool result = true;
575 for (auto &cam : cameras())
576 if (cam->process()->hasCoolerControl())
577 result &= cam->process()->setCoolerControl(enable);
578
579 return result;
580}
581
583{
584 process()->removeDevice(device);
585}
586
587QString Capture::getTargetName()
588{
589 if (activeJob())
590 return activeJob()->getCoreProperty(SequenceJob::SJ_TargetName).toString();
591 else
592 return "";
593}
594
595void Capture::setHFR(double newHFR, int, bool inAutofocus, const QString &trainname)
596{
597 // publish to all known focusers using the same optical train (should be only one)
598 for (auto &cam : cameras())
599 if (trainname == "" || cam->opticalTrain() == trainname)
600 cam->state()->getRefocusState()->setFocusHFR(newHFR, inAutofocus);
601}
602
603void Capture::inSequenceAFRequested(bool requested, const QString &trainname)
604{
605 // publish to all known cameras using the same optical train (should be only one)
606 for (auto &cam : cameras())
607 if (trainname == "" || cam->opticalTrain() == trainname)
608 // set the value directly in the camera's state
609 cam->state()->getRefocusState()->setForceInSeqAF(requested);
610
611 moduleState()->setForceInSeqAF(requested, trainname);
612}
613} // namespace
void setHFR(double newHFR, int position, bool inAutofocus, const QString &trainname)
setHFR Receive the measured HFR value of the latest frame
Definition capture.cpp:595
bool setVideoLimits(uint16_t maxBufferSize, uint16_t maxPreviewFPS)
setVideoLimits sets the buffer size and max preview fps for live preview
Definition capture.cpp:381
bool setDome(ISD::Dome *device)
setDome Set dome device
Definition capture.cpp:205
void updateCamera(int tabID, bool isValid)
Update the camera.
Definition capture.cpp:180
void inSequenceAFRequested(bool requested, const QString &trainname)
inSequenceAFRequested Focuser informs that the user wishes an AF run as soon as possible.
Definition capture.cpp:603
QSharedPointer< CameraProcess > process() const
process shortcut for the process engine
Definition capture.h:615
void setFocusStatus(FocusState newstate, const QString &trainname)
setFocusStatus Forward the new focus state to the capture module state machine
Definition capture.cpp:246
void setFocusTemperatureDelta(double focusTemperatureDelta, double absTemperature, const QString &trainname)
setFocusTemperatureDelta update the focuser's temperature delta
Definition capture.cpp:329
void setGuideDeviation(double delta_ra, double delta_dec)
setGuideDeviation Set the guiding deviation as measured by the guiding module.
Definition capture.cpp:338
void registerNewModule(const QString &name)
registerNewModule Register an Ekos module as it arrives via DBus and create the appropriate DBus inte...
Definition capture.cpp:210
void focusAdaptiveComplete(bool success, const QString &trainname)
focusAdaptiveComplete Forward the new focus state to the capture module state machine
Definition capture.cpp:254
int findCamera(QString train, bool addIfNecessary)
find the camera using the given train
Definition capture.cpp:498
void removeDevice(const QSharedPointer< ISD::GenericDevice > &device)
Generic method for removing any connected device.
Definition capture.cpp:582
CameraChip class controls a particular chip in camera.
Class handles control of INDI dome devices.
Definition indidome.h:25
KPageWidgetItem * addPage(QWidget *page, const QString &itemName, const QString &pixmapName=QString(), const QString &header=QString(), bool manage=true)
void setIcon(const QIcon &icon)
Q_SCRIPTABLE bool hasCoolerControl()
DBUS interface function.
Definition capture.cpp:563
void prepareGUI()
prepareGUI Perform once only GUI prep processing
Definition capture.cpp:97
Q_SCRIPTABLE Q_NOREPLY void abort(QString train="")
DBUS interface function.
Definition capture.cpp:412
Q_SCRIPTABLE Q_NOREPLY void ignoreSequenceHistory()
DBUS interface function.
Definition capture.cpp:345
Q_SCRIPTABLE QString start(QString train="")
DBUS interface function.
Definition capture.cpp:389
Q_SCRIPTABLE bool loadSequenceQueue(const QString &fileURL, QString train="", bool isLead=true, QString targetName="")
DBUS interface function.
Definition capture.cpp:286
Q_SCRIPTABLE bool setCoolerControl(bool enable)
DBUS interface function.
Definition capture.cpp:572
Q_SCRIPTABLE bool setFilter(const QString &filter)
DBUS interface function.
Definition capture.cpp:270
Q_SCRIPTABLE Q_NOREPLY void setCapturedFramesMap(const QString &signature, int count, QString train="")
DBUS interface function.
Definition capture.cpp:351
QString i18nc(const char *context, const char *text, const TYPE &arg...)
QString i18n(const char *text, const TYPE &arg...)
Ekos is an advanced Astrophotography tool for Linux.
Definition align.cpp:83
AlignState
Definition ekos.h:145
KIOCORE_EXPORT TransferJob * get(const QUrl &url, LoadType reload=NoReload, JobFlags flags=DefaultFlags)
void clicked(bool checked)
void setIcon(const QIcon &icon)
bool connect(const QString &service, const QString &path, const QString &interface, const QString &name, QObject *receiver, const char *slot)
bool registerObject(const QString &path, QObject *object, RegisterOptions options)
QDBusConnection sessionBus()
void accepted()
void rejected()
QIcon fromTheme(const QString &name)
void clear()
T & first()
iterator insert(const_iterator before, parameter_type value)
bool isEmpty() const const
qsizetype removeAll(const AT &t)
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
bool disconnect(const QMetaObject::Connection &connection)
T * get() const const
void tabCloseRequested(int index)
QString toString() const const
QWidget(QWidget *parent, Qt::WindowFlags f)
void setFixedSize(const QSize &s)
void setupUi(QWidget *widget)
void setToolTip(const QString &)
void setWindowFlags(Qt::WindowFlags type)
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Mon Nov 4 2024 16:38:42 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.