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 // find an unused train for additional tabs
158 const QString train = tabIndex == 0 ? "" : findUnusedOpticalTrain();
159 // select an unused train
160 if (train != "")
161 newCamera->opticalTrainCombo->setCurrentText(train);
162
163 moduleState()->addCamera(newCamera);
164 // update the tab text
165 updateCamera(tabIndex, true);
166
167 return newCamera;
168}
169
170const QString Capture::findUnusedOpticalTrain()
171{
172 QList<QString> names = OpticalTrainManager::Instance()->getTrainNames();
173 foreach(auto cam, cameras())
174 names.removeAll(cam->opticalTrain());
175
176 if (names.isEmpty())
177 return "";
178 else
179 return names.first();
180}
181
182void Capture::updateCamera(int tabID, bool isValid)
183{
184 if (isValid)
185 {
186 if (tabID < cameraTabs->count() && tabID < cameras().count())
187 {
188 auto cam = moduleState()->mutableCameras()[tabID];
189
190 if (cam->activeCamera() != nullptr)
191 {
192 auto name = cam->activeCamera()->getDeviceName();
193 cameraTabs->setTabText(tabID, name);
194 }
195
196 // update shared attributes
197 cam->state()->getRefocusState()->setForceInSeqAF(moduleState()->forceInSeqAF(cam->opticalTrain()));
198 }
199 else
200 qCWarning(KSTARS_EKOS_CAPTURE) << "Unknown camera ID:" << tabID;
201 }
202 else
203 cameraTabs->setTabText(cameraTabs->currentIndex(), "no camera");
204}
205
206
208{
209 return process()->setDome(device);
210}
211
213{
214 if (mainCamera()->m_standAlone)
215 return;
216 if (name == "Mount" && mountInterface == nullptr)
217 {
218 qCDebug(KSTARS_EKOS_CAPTURE) << "Registering new Module (" << name << ")";
219 mountInterface = new QDBusInterface("org.kde.kstars", "/KStars/Ekos/Mount",
220 "org.kde.kstars.Ekos.Mount", QDBusConnection::sessionBus(), this);
221 }
222}
223
224QString Capture::camera()
225{
226 if (mainCameraDevices()->getActiveCamera())
227 return mainCameraDevices()->getActiveCamera()->getDeviceName();
228
229 return QString();
230}
231
232void Capture::setGuideChip(ISD::CameraChip * guideChip)
233{
234 // We should suspend guide in two scenarios:
235 // 1. If guide chip is within the primary CCD, then we cannot download any data from guide chip while primary CCD is downloading.
236 // 2. If we have two CCDs running from ONE driver (Multiple-Devices-Per-Driver mpdp is true). Same issue as above, only one download
237 // at a time.
238 // After primary CCD download is complete, we resume guiding.
239 if (!mainCameraDevices()->getActiveCamera())
240 return;
241
242 mainCameraState()->setSuspendGuidingOnDownload((mainCameraDevices()->getActiveCamera()->getChip(
243 ISD::CameraChip::GUIDE_CCD) == guideChip) ||
244 (guideChip->getCCD() == mainCameraDevices()->getActiveCamera() &&
245 mainCameraDevices()->getActiveCamera()->getDriverInfo()->getAuxInfo().value("mdpd", false).toBool()));
246}
247
248void Capture::setFocusStatus(FocusState newstate, const QString &trainname)
249{
250 // publish to all known focusers using the same optical train (should be only one)
251 for (auto &cam : cameras())
252 if (trainname == "" || cam->opticalTrain() == trainname)
253 cam->setFocusStatus(newstate);
254}
255
256void Capture::focusAdaptiveComplete(bool success, const QString &trainname)
257{
258 // publish to all known focusers using the same optical train (should be only one)
259 for (auto &cam : cameras())
260 if (trainname == "" || cam->opticalTrain() == trainname)
261 cam->focusAdaptiveComplete(success);
262}
263
264QString Capture::filterWheel()
265{
266 if (mainCameraDevices()->filterWheel())
267 return mainCameraDevices()->filterWheel()->getDeviceName();
268
269 return QString();
270}
271
272bool Capture::setFilter(const QString &filter)
273{
274 if (mainCameraDevices()->filterWheel())
275 {
276 mainCamera()->FilterPosCombo->setCurrentText(filter);
277 return true;
278 }
279
280 return false;
281}
282
283QString Capture::filter()
284{
285 return mainCamera()->FilterPosCombo->currentText();
286}
287
288bool Capture::loadSequenceQueue(const QString &fileURL, QString train, bool isLead, QString targetName)
289{
291 if (train == "")
292 cam = mainCamera();
293 else if (isLead)
294 {
295 // take the main camera, and select the train if necessary
296 if (mainCamera()->opticalTrain() != train)
297 mainCamera()->selectOpticalTrain(train);
298
299 cam = mainCamera();
300 }
301 else
302 {
303 // find the camera, create a new one if necessary
304 int pos = findCamera(train, true);
305 if (pos < 0)
306 return false;
307 else
308 cam = camera(pos);
309 }
310 // camera found, load the sequence queue
311 return cam->loadSequenceQueue(fileURL, targetName);
312}
313
314
315void Capture::appendLogText(const QString &text)
316{
317 m_LogText.insert(0, i18nc("log entry; %1 is the date, %2 is the text", "%1 %2",
318 KStarsData::Instance()->lt().toString("yyyy-MM-ddThh:mm:ss"), text));
319
320 qCInfo(KSTARS_EKOS_CAPTURE) << text;
321
322 emit newLog(text);
323}
324
325void Capture::clearLog()
326{
327 m_LogText.clear();
328 emit newLog(QString());
329}
330
331void Capture::setFocusTemperatureDelta(double focusTemperatureDelta, double absTemperture, const QString &trainname)
332{
333 Q_UNUSED(absTemperture);
334 // publish to all known focusers using the same optical train (should be only one)
335 for (auto &cam : cameras())
336 if (trainname == "" || cam->opticalTrain() == trainname)
337 cam->state()->getRefocusState()->setFocusTemperatureDelta(focusTemperatureDelta);
338}
339
340void Capture::setGuideDeviation(double delta_ra, double delta_dec)
341{
342 // forward it to the global state machine
343 moduleState()->setGuideDeviation(delta_ra, delta_dec);
344
345}
346
348{
349 // This function is called independently from the Scheduler or the UI, so honor the change
350 mainCameraState()->setIgnoreJobProgress(true);
351}
352
353void Capture::setCapturedFramesMap(const QString &signature, int count, QString train)
354{
356 if (train == "")
357 cam = mainCamera();
358 else
359 {
360 // find the camera, create a new one if necessary
361 int pos = findCamera(train, true);
362 if (pos < 0)
363 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot set the captured frames map for train" << train;
364 else
365 cam = camera(pos);
366 }
367 // camera found, set the captured frames map
368 cam->state()->setCapturedFramesCount(signature, count);
369}
370
371void Capture::setAlignStatus(AlignState newstate)
372{
373 // forward it directly to the state machine
374 mainCameraState()->setAlignState(newstate);
375}
376
377void Capture::setGuideStatus(GuideState newstate)
378{
379 // forward to state machine
380 moduleState()->setGuideStatus(newstate);
381}
382
383bool Capture::setVideoLimits(uint16_t maxBufferSize, uint16_t maxPreviewFPS)
384{
385 if (mainCameraDevices()->getActiveCamera() == nullptr)
386 return false;
387
388 return mainCameraDevices()->getActiveCamera()->setStreamLimits(maxBufferSize, maxPreviewFPS);
389}
390
392{
394 if (train == "")
395 cam = mainCamera();
396 else
397 {
398 // find the camera, create a new one if necessary
399 int pos = findCamera(train, true);
400 if (pos < 0)
401 {
402 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot start capturing for train" << train;
403 return "";
404 }
405 else
406 cam = camera(pos);
407 }
408 // camera found, start capturing
409 cam->start();
410 // return the real train name
411 return cam->opticalTrain();
412}
413
415{
417 if (train == "")
418 for (auto cam : cameras())
419 cam->abort();
420 else
421 {
422 int pos = findCamera(train, false);
423 if (pos < 0)
424 {
425 qCWarning(KSTARS_EKOS_CAPTURE) << "Cannot abort capturing for train" << train;
426 return;
427 }
428 else
429 cam = camera(pos);
430
431 // camera found, abort capturing
432 cam->abort();
433 }
434}
435
436QSharedPointer<Camera> &Capture::camera(int i)
437{
438 if (i < cameras().count())
439 return moduleState()->mutableCameras()[i];
440 else
441 {
442 qCWarning(KSTARS_EKOS_CAPTURE) << "Unknown camera ID:" << i;
443 return moduleState()->mutableCameras()[0];
444 }
445}
446
447void Ekos::Capture::closeCameraTab(int tabIndex)
448{
449 cameraTabs->removeTab(tabIndex);
450 moduleState()->removeCamera(tabIndex);
451 // select the next one on the left
452 cameraTabs->setCurrentIndex(std::max(0, tabIndex - 1));
453}
454
455void Capture::checkCloseCameraTab(int tabIndex)
456{
457 // ignore close event from the "Add" tab
458 if (tabIndex == cameraTabs->count() - 1)
459 return;
460
461 if (moduleState()->mutableCameras()[tabIndex]->state()->isBusy())
462 {
463 // if accept has been clicked, abort and close the tab
464 connect(KSMessageBox::Instance(), &KSMessageBox::accepted, this, [this, &tabIndex]()
465 {
466 KSMessageBox::Instance()->disconnect(this);
467 moduleState()->mutableCameras()[tabIndex]->abort();
468 closeCameraTab(tabIndex);
469 });
470 // if cancel has been clicked, do not close the tab
471 connect(KSMessageBox::Instance(), &KSMessageBox::rejected, this, [this]()
472 {
473 KSMessageBox::Instance()->disconnect(this);
474 });
475
476 KSMessageBox::Instance()->warningContinueCancel(i18n("Camera %1 is busy. Abort to close?",
477 moduleState()->mutableCameras()[tabIndex]->activeCamera()->getDeviceName()), i18n("Stop capturing"), 30, false,
478 i18n("Abort"));
479 }
480 else
481 {
482 closeCameraTab(tabIndex);
483 }
484}
485
486const QSharedPointer<Camera> Capture::mainCamera() const
487{
488 if (cameras().size() > 0)
489 return moduleState()->cameras()[0];
490 else
491 {
493 cms.reset(new CaptureModuleState());
494 // TODO FIXME
495 //return QSharedPointer<Camera>(new Camera(cms));
496 return QSharedPointer<Camera>(new Camera(0));
497 }
498}
499
500int Capture::findCamera(QString train, bool addIfNecessary)
501{
502 for (auto &cam : cameras())
503 {
504 if (cam->opticalTrain() == train)
505 return cam->m_cameraId;
506 }
507
508 // none found
509 if (addIfNecessary)
510 {
511 QSharedPointer<Camera> cam = addCamera();
512 cam->selectOpticalTrain(train);
513 return cam->m_cameraId;
514 }
515 // nothing found
516 return -1;
517}
518
519void Capture::setMountStatus(ISD::Mount::Status newState)
520{
521 switch (newState)
522 {
523 case ISD::Mount::MOUNT_PARKING:
524 case ISD::Mount::MOUNT_SLEWING:
525 case ISD::Mount::MOUNT_MOVING:
526 mainCamera()->previewB->setEnabled(false);
527 mainCamera()->liveVideoB->setEnabled(false);
528 // Only disable when button is "Start", and not "Stopped"
529 // If mount is in motion, Stopped button should always be enabled to terminate
530 // the sequence
531 if (mainCameraState()->isBusy() == false)
532 mainCamera()->startB->setEnabled(false);
533 break;
534
535 default:
536 if (mainCameraState()->isBusy() == false)
537 {
538 mainCamera()->previewB->setEnabled(true);
539 if (mainCameraDevices()->getActiveCamera())
540 mainCamera()->liveVideoB->setEnabled(mainCameraDevices()->getActiveCamera()->hasVideoStream());
541 mainCamera()->startB->setEnabled(true);
542 }
543
544 break;
545 }
546}
547
548void Capture::setAlignResults(double solverPA, double ra, double de, double pixscale)
549{
550 Q_UNUSED(ra)
551 Q_UNUSED(de)
552 Q_UNUSED(pixscale)
553 if (mainCameraDevices()->rotator() && mainCamera()->m_RotatorControlPanel)
554 mainCamera()->m_RotatorControlPanel->refresh(solverPA);
555}
556
557void Capture::setMeridianFlipState(QSharedPointer<MeridianFlipState> newstate)
558{
559 mainCameraState()->setMeridianFlipState(newstate);
560 connect(mainCameraState()->getMeridianFlipState().get(), &MeridianFlipState::newLog, this, &Capture::appendLogText);
561 connect(mainCameraState()->getMeridianFlipState().get(), &MeridianFlipState::newMountMFStatus, moduleState().get(),
562 &CaptureModuleState::updateMFMountState);
563}
564
566{
567 bool result = false;
568 for (auto &cam : cameras())
569 if (cam->process()->hasCoolerControl())
570 result |= cam->process()->hasCoolerControl();
571 return result;
572}
573
575{
576 bool result = true;
577 for (auto &cam : cameras())
578 if (cam->process()->hasCoolerControl())
579 result &= cam->process()->setCoolerControl(enable);
580
581 return result;
582}
583
585{
586 process()->removeDevice(device);
587}
588
589QString Capture::getTargetName()
590{
591 if (activeJob())
592 return activeJob()->getCoreProperty(SequenceJob::SJ_TargetName).toString();
593 else
594 return "";
595}
596
597void Capture::setHFR(double newHFR, int, bool inAutofocus, const QString &trainname)
598{
599 // publish to all known focusers using the same optical train (should be only one)
600 for (auto &cam : cameras())
601 if (trainname == "" || cam->opticalTrain() == trainname)
602 cam->state()->getRefocusState()->setFocusHFR(newHFR, inAutofocus);
603}
604
605void Capture::inSequenceAFRequested(bool requested, const QString &trainname)
606{
607 // publish to all known cameras using the same optical train (should be only one)
608 for (auto &cam : cameras())
609 if (trainname == "" || cam->opticalTrain() == trainname)
610 // set the value directly in the camera's state
611 cam->state()->getRefocusState()->setForceInSeqAF(requested);
612
613 moduleState()->setForceInSeqAF(requested, trainname);
614}
615} // 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:597
bool setVideoLimits(uint16_t maxBufferSize, uint16_t maxPreviewFPS)
setVideoLimits sets the buffer size and max preview fps for live preview
Definition capture.cpp:383
bool setDome(ISD::Dome *device)
setDome Set dome device
Definition capture.cpp:207
void updateCamera(int tabID, bool isValid)
Update the camera.
Definition capture.cpp:182
void inSequenceAFRequested(bool requested, const QString &trainname)
inSequenceAFRequested Focuser informs that the user wishes an AF run as soon as possible.
Definition capture.cpp:605
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:248
void setFocusTemperatureDelta(double focusTemperatureDelta, double absTemperature, const QString &trainname)
setFocusTemperatureDelta update the focuser's temperature delta
Definition capture.cpp:331
void setGuideDeviation(double delta_ra, double delta_dec)
setGuideDeviation Set the guiding deviation as measured by the guiding module.
Definition capture.cpp:340
void registerNewModule(const QString &name)
registerNewModule Register an Ekos module as it arrives via DBus and create the appropriate DBus inte...
Definition capture.cpp:212
void focusAdaptiveComplete(bool success, const QString &trainname)
focusAdaptiveComplete Forward the new focus state to the capture module state machine
Definition capture.cpp:256
int findCamera(QString train, bool addIfNecessary)
find the camera using the given train
Definition capture.cpp:500
void removeDevice(const QSharedPointer< ISD::GenericDevice > &device)
Generic method for removing any connected device.
Definition capture.cpp:584
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:565
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:414
Q_SCRIPTABLE Q_NOREPLY void ignoreSequenceHistory()
DBUS interface function.
Definition capture.cpp:347
Q_SCRIPTABLE QString start(QString train="")
DBUS interface function.
Definition capture.cpp:391
Q_SCRIPTABLE bool loadSequenceQueue(const QString &fileURL, QString train="", bool isLead=true, QString targetName="")
DBUS interface function.
Definition capture.cpp:288
Q_SCRIPTABLE bool setCoolerControl(bool enable)
DBUS interface function.
Definition capture.cpp:574
Q_SCRIPTABLE bool setFilter(const QString &filter)
DBUS interface function.
Definition capture.cpp:272
Q_SCRIPTABLE Q_NOREPLY void setCapturedFramesMap(const QString &signature, int count, QString train="")
DBUS interface function.
Definition capture.cpp:353
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 18 2024 12:16:40 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.