| CArtificialHorizon | |
| CBinaryListComponent< T, Component > | Functionality for loading the component data from Binary |
| ►CBinaryListComponent< KSAsteroid, AsteroidsComponent > | |
| CAsteroidsComponent | |
| CBinFileHelper | Implements an interface to handle binary data files used by KStars |
| CISD::CameraChip | |
| CCaptureProcessOverlay::CaptureHistory | Navigator through the capture history |
| CCatalogsDB::Catalog | A simple struct to hold information about catalogs |
| CCatalogsDB::CatalogStatistics | Holds statistical information about the objects in a catalog |
| CClientManagerLite | |
| CColorScheme | |
| CConstants | |
| CConstellationBoundary | |
| CConstellationName | The ConstellationName struct |
| Crapidcsv::Converter< T > | Class providing conversion to/from numerical datatypes and strings |
| Crapidcsv::ConverterParams | Datastructure holding parameters controlling how invalid numbers (including empty strings) should be handled |
| ►Ccovariance_functions::CovFunc | Base class definition for covariance functions |
| Ccovariance_functions::PeriodicSquareExponential | |
| Ccovariance_functions::PeriodicSquareExponential2 | |
| CCrossHairNode | Represents crosshair of telescope in SkyMapLite |
| CCultureList | |
| CSkyObjectUserdata::Data | Stores Users' Logs, Pictures and Websites regarding an object in the sky |
| CCatalogsDB::DatabaseError | Database related error, thrown when database access fails or an action does not succeed |
| CdataElement | A structure describing a data field in the binary file |
| CCatalogsDB::DBManager | Manages the catalog database and provides an interface to provide an interface to query and modify the database |
| Cdc1394color_codings_t | A struct containing a list of color codings |
| Cdc1394video_modes_t | A struct containing a list of video modes |
| CDeepStarData | A 16-byte structure that holds star data for really faint stars |
| CDetailsTable | Represents details tables that can be inserted to finder charts and logging forms. DetailsTable class is used for creating QTextTables filled with details about objects of all types. Created tables are stored inside QTextDocument, which can be obtained by DetailsTable::getDocument() and inserted into other QTextDocument as fragment. Four types of details tables are supported: general details, position details, Rise/Set/Transit details and Asteroid/Comet details |
| CDetalDialogLite | Backend for Object details dialog in QML A backend of details dialog declared in QML. Members of this class are the properties that are used in QML. Whenever user clicks on some object the properties are updated with the info about this object and Details dialog in QML is updated automatically as we use property binding there |
| CDeviceInfo | |
| ►Cdms | An angle, stored as degrees, but expressible in many ways |
| CCachingDms | Dms subclass that caches its sine and cosine values every time the angle is changed |
| Crapidcsv::Document | Class representing a CSV document |
| COAL::DSLRLens | |
| CEclipticPosition | The ecliptic position of a planet (Longitude, Latitude, and distance from Sun) |
| CTrixelCache< content >::element | A container to hold cache elements |
| CEyepiece | |
| CFilter | |
| CFilter | |
| COAL::Filter | |
| CEkos::FocusAlgorithmInterface | Interface intender for autofocus algorithms |
| CFOVManager | |
| CFovSnapshot | Class that represents single field of view snapshot. FovSnapshot class stores data of single FOV snapshot: image, description, FOV symbol at which it was captured and its central point |
| CGaussianProcessGuider | This class provides a guiding algorithm for the right ascension axis that learns and predicts the periodic gear error with a Gaussian process |
| CGeoLocation | Relevant data about an observing location on Earth |
| CGreatCircle | A class to compute points along a great circle from one az/alt to another |
| CGuide | |
| CGaussianProcessGuider::guide_parameters | Holds all data that is needed for the GP guiding |
| CGuideView | The main change relative to fitsview is to add the capability of displaying the 'neighbor guide stars' for the SEP Multi Star guide algorithm |
| CHighPMStarList | |
| ►CHTMesh | |
| CSkyMesh | |
| CKSAlmanac | Implement methods to find important times in a day |
| CKSDssImage | Provides a class to hold a DSS Image along with its metadata |
| CKSNumbers | Store several time-dependent astronomical quantities |
| CKSPaths | Wrapper for QStandardPaths with Android assets support The purpose of this class is to search for resources on some platforms with paths that are not provided by QStandardPaths (e.g. assets:/ on Android) |
| ►CKStarsDocument | Base class for KStars documents. KStarsDocument is a base class for all KStars documents: finder charts, logging forms etc |
| CFinderChart | Class that represents finder chart document. FinderChart class is a subclass of KStarsDocument class, representing finder chart. Finder chart can contain following elements: title, subtitle, description, logging forms, images and details tables |
| CLoggingForm | Class that represents logging form. Currently, LoggingForm class is used to create logging forms for finder charts |
| CKSUserDB | Single class to delegate all User database I/O |
| CKSUtils | KStars utility functions |
| ►CKXMLGUIBuilder [external] | |
| ►CKXmlGuiWindow [external] | |
| CFITSViewer | Primary window to view monochrome and color FITS images. The FITSviewer can open multiple images each in a separate. It supports simple filters, histogram transforms, flip and rotation operations, and star detection |
| CKStars | This is the main window for KStars. In addition to the GUI elements, the class contains the program clock, KStarsData, and SkyMap objects. It also contains functions for the DBus Interface D-Bus interface. KStars is now a singleton class. Use KStars::createInstance() to create an instance and KStars::Instance() to get a pointer to the instance |
| ►CKXMLGUIClient [external] | |
| CKXmlGuiWindow [external] | |
| CLabelListIndex | |
| Crapidcsv::LabelParams | Datastructure holding parameters controlling which row and column should be treated as labels |
| COAL::Lens | |
| CLineList | |
| Crapidcsv::LineReaderParams | Datastructure holding parameters controlling how special line formats should be treated |
| CSkyObjectUserdata::LinkData | Stores the tite and URL of a webpage |
| CLog | |
| CKSUtils::Logging | Interface into Qt's logging system |
| CLunarEclipseDetails | The LunarEclipseDetails struct |
| CManager | Primary class to handle all Ekos modules. The Ekos Manager class manages startup and shutdown of INDI devices and registeration of devices within Ekos Modules. Ekos module consist of Ekos::Mount, Ekos::Capture, Ekos::Focus, Ekos::Guide, and Ekos::Align modules |
| CMeshBuffer | |
| CMeshIterator | |
| CKSDssImage::Metadata | Structure to hold some DSS image metadata |
| CMlkyWay | |
| Crapidcsv::no_converter | Exception thrown when attempting to access Document data in a datatype which is not supported by the Converter class |
| CNOMADStarDataWriter | Writes NOMAD star data |
| CObsConditions | |
| COAL::Observation | |
| COAL::Observer | FIXME: why not just use a QHash? |
| CKSPlanet::OrbitData | |
| CKSPlanet::OrbitDataColl | OrbitDataColl contains three groups of six QVectors |
| CKSPlanet::OrbitDataManager | OrbitDataManager places the OrbitDataColl objects for all planets in a QDict indexed by the planets' names |
| ►CPlanetMoons | |
| CJupiterMoons | |
| CPoleAxis | PoleAxis class handles determining the mount Ha axis position given three positions taken with the same mount declination |
| ►CProjector | |
| CAzimuthalEquidistantProjector | |
| CEquirectangularProjector | |
| CGnomonicProjector | |
| CLambertProjector | |
| COrthographicProjector | |
| CStereographicProjector | |
| ►CQCPAbstractPaintBuffer | The abstract base class for paint buffers, which define the rendering backend |
| CQCPPaintBufferPixmap | A paint buffer based on QPixmap, using software raster rendering |
| CQCPAxisPainterPrivate | (Private) |
| ►CQCPAxisTicker | The base class tick generator used by QCPAxis to create tick positions and tick labels |
| CQCPAxisTickerDateTime | Specialized axis ticker for calendar dates and times as axis ticks |
| CQCPAxisTickerFixed | Specialized axis ticker with a fixed tick step |
| CQCPAxisTickerLog | Specialized axis ticker suited for logarithmic axes |
| CQCPAxisTickerPi | Specialized axis ticker to display ticks in units of an arbitrary constant, for example pi |
| CQCPAxisTickerText | Specialized axis ticker which allows arbitrary labels at specified coordinates |
| CQCPAxisTickerTime | Specialized axis ticker for time spans in units of milliseconds to days |
| CQCPBarsData | Holds the data of one single data point (one bar) for QCPBars |
| CQCPColorGradient | Defines a color gradient for use with e.g. QCPColorMap |
| CQCPColorMapData | Holds the two-dimensional data of a QCPColorMap plottable |
| CQCPCurveData | Holds the data of one single data point for QCPCurve |
| CQCPDataContainer< DataType > | The generic data container for one-dimensional plottables |
| CQCPDataRange | Describes a data range given by begin and end index |
| CQCPDataSelection | Describes a data set by holding multiple QCPDataRange instances |
| CQCPErrorBarsData | Holds the data of one single error bar for QCPErrorBars |
| CQCPFinancialData | Holds the data of one single data point for QCPFinancial |
| CQCPGraphData | Holds the data of one single data point for QCPGraph |
| ►CQCPItemAnchor | An anchor of an item to which positions can be attached to |
| CQCPItemPosition | Manages the position of an item |
| CQCPLabelPainterPrivate | (Private) |
| CQCPLineEnding | Handles the different ending decorations for line-like items |
| ►CQCPPlottableInterface1D | Defines an abstract interface for one-dimensional plottables |
| CQCPAbstractPlottable1D< DataType > | A template base class for plottables with one-dimensional data |
| ►CQCPAbstractPlottable1D< QCPBarsData > | |
| CQCPBars | A plottable representing a bar chart in a plot |
| ►CQCPAbstractPlottable1D< QCPCurveData > | |
| CQCPCurve | A plottable representing a parametric curve in a plot |
| ►CQCPAbstractPlottable1D< QCPFinancialData > | |
| CQCPFinancial | A plottable representing a financial stock chart |
| ►CQCPAbstractPlottable1D< QCPGraphData > | |
| CQCPGraph | A plottable representing a graph in a plot |
| ►CQCPAbstractPlottable1D< QCPStatisticalBoxData > | |
| CQCPStatisticalBox | A plottable representing a single statistical box in a plot |
| CQCPErrorBars | A plottable that adds a set of error bars to other plottables |
| CQCPRange | Represents the range an axis is encompassing |
| CQCPScatterStyle | Represents the visual appearance of scatter points |
| ►CQCPSelectionDecorator | Controls how a plottable's data selection is drawn |
| CQCPSelectionDecoratorBracket | A selection decorator which draws brackets around each selected data segment |
| CQCPStatisticalBoxData | Holds the data of one single data point for QCPStatisticalBox |
| CQCPVector2D | Represents two doubles as a mathematical 2D vector |
| ►CQDateTime [external] | |
| CKStarsDateTime | Extension of QDateTime for KStars KStarsDateTime can represent the date/time as a Julian Day, using a long double, in which the fractional portion encodes the time of day to a precision of a less than a second. Also adds Greenwich Sidereal Time and "epoch", which is just the date expressed as a floating point number representing the year, with the fractional part representing the date and time (with poor time resolution; typically the Epoch is only taken to the hundredths place, which is a few days) |
| ►CQLineF [external] | |
| CHoughLine | |
| ►CQList< Satellite * > [external] | |
| CSatelliteGroup | |
| ►CQObject [external] | |
| ►CApproachSolver | Implements algorithms to find close approaches of two objects on the sky. A class that implements a method to compute close approaches between any two solar system objects excluding planetary moons. Given two such objects, this class has implementations of algorithms required to find the time of closest approach in a given range of time. It is meant to be subclassed and provides the boilerplate (+ common interface) for classes like KSKonjunct and EclipseHandler |
| ►CEclipseHandler | The EclipseHandler class |
| CLunarEclipseHandler | The LunarEclipseHandler class |
| CKSConjunct | Implements algorithms to find close conjunctions of planets in a given time range. A class that implements a method to compute close conjunctions between any two solar system objects excluding planetary moons. Given two such objects, this class has implementations of algorithms required to find the time of closest approach in a given range of time |
| CAsteroidsComponent | |
| CBlobManager | |
| CCatalogsDB::AsyncDBManager | A concurrent wrapper around |
| CClientManager | |
| CCometsComponent | |
| CDriverInfo | |
| ►CEclipseEvent | The EclipseEvent class |
| CLunarEclipseEvent | The LunarEclipseEvent class |
| ►CEkos::AstrometryParser | |
| CEkos::ASTAPAstrometryParser | |
| CEkos::RemoteAstrometryParser | |
| CEkos::DarkProcessor | The DarkProcessor class |
| ►CEkos::GuideInterface | Interface skeleton for implementation of different guiding applications and/or routines |
| CEkos::LinGuider | |
| CEkos::PHD2 | |
| CEkos::MosaicTilesModel | Holds the data representation of the mosaic tiles |
| CEkos::OpticalTrainSettings | The OpticalTrainSettings class |
| CEkos::ProfileSettings | The ProfileSettings class |
| CFindDialogLite | Backend for "Find Object" dialog in QML The way we are searching for the object is as follows: Each SkyComponent in addition to QStringList of names holds QVector<QPair<QString, const SkyObject *>>. SkyObjectListModel is a class that holds SkyObjects together with their names (name and longname). Whenever user searches for an object we sort list of SkyObjects through QSortFilterProxyModel. The reason for this way of searching is that we don't need to search for an object again, as it was done previously. Instead of this, user directly selects the object in search results |
| CFlagComponent | Represents a flag on the sky map. Each flag is composed by a SkyPoint where coordinates are stored, an epoch and a label. This class also stores flag images and associates each flag with an image. When FlagComponent is created, it seeks all file names beginning with "_flag" in the user directory and consider them as flag images |
| CFOV | |
| CImageExporter | Backends for exporting a sky image, either raster or vector, with a legend |
| CINDIDBus | |
| CINDIListener | |
| ►CISD::GDInterface | |
| ►CISD::ConcreteDevice | The ConcreteDevice class |
| CISD::AdaptiveOptics | |
| CISD::Auxiliary | |
| CISD::Camera | |
| CISD::Correlator | |
| CISD::Detector | |
| CISD::Dome | |
| CISD::DustCap | |
| CISD::Focuser | |
| CISD::LightBox | |
| CISD::Mount | |
| CISD::Rotator | |
| CISD::Spectrograph | |
| CISD::Weather | |
| CISD::GenericDevice | |
| CKSDssDownloader | Helps download a DSS image |
| CKSFileReader | |
| CKStarsData | |
| CKStarsLite | This class loads QML files and connects SkyMapLite and KStarsData Unlike KStars class it is not a main window (see KStarsLite::m_Engine) but a root object that contains the program clock and holds pointers to SkyMapLite and KStarsData objects. KStarsLite is a singleton, use KStarsLite::createInstance() to create an instance and KStarsLite::Instance() to get a pointer to the instance |
| CLocationDialogLite | |
| CModelManager | Manages models for QML listviews of different types of sky-objects |
| ►CQAbstractItemModel [external] | |
| ►CQAbstractListModel [external] | |
| CSkyObjectListModel | Model that is used in Find Object Dialog |
| CSkyObjListModel | |
| ►CQAbstractProxyModel [external] | |
| ►CQSortFilterProxyModel [external] | |
| CSessionSortFilterProxyModel | Sort best observation times by reimplementing lessThan() to work on the transit times of objects |
| ►CQAbstractTableModel [external] | |
| CEclipseModel | The EclipseModel class |
| CQCPBarsGroup | Groups multiple QCPBars together so they appear side by side |
| CQCPLayer | A layer that may contain objects, to control the rendering order |
| ►CQCPLayerable | Base class for all drawable objects |
| ►CQCPAbstractItem | The abstract base class for all items in a plot |
| CQCPItemBracket | A bracket for referencing/highlighting certain parts in the plot |
| CQCPItemCurve | A curved line from one point to another |
| CQCPItemEllipse | An ellipse |
| CQCPItemLine | A line from one point to another |
| CQCPItemPixmap | An arbitrary pixmap |
| CQCPItemRect | A rectangle |
| CQCPItemStraightLine | A straight line that spans infinitely in both directions |
| CQCPItemText | A text label |
| CQCPItemTracer | Item that sticks to QCPGraph data points |
| ►CQCPAbstractPlottable | The abstract base class for all data representing objects in a plot |
| CQCPAbstractPlottable1D< DataType > | A template base class for plottables with one-dimensional data |
| CQCPAbstractPlottable1D< QCPBarsData > | |
| CQCPAbstractPlottable1D< QCPCurveData > | |
| CQCPAbstractPlottable1D< QCPFinancialData > | |
| CQCPAbstractPlottable1D< QCPGraphData > | |
| CQCPAbstractPlottable1D< QCPStatisticalBoxData > | |
| CQCPColorMap | A plottable representing a two-dimensional color map in a plot |
| CQCPErrorBars | A plottable that adds a set of error bars to other plottables |
| CQCPAxis | Manages a single axis inside a QCustomPlot |
| CQCPGrid | Responsible for drawing the grid of a QCPAxis |
| ►CQCPLayoutElement | The abstract base class for all objects that form the layout system |
| ►CQCPAbstractLegendItem | The abstract base class for all entries in a QCPLegend |
| CQCPPlottableLegendItem | A legend item representing a plottable with an icon and the plottable name |
| CQCPPolarLegendItem | A legend item for polar plots |
| ►CQCPAxisRect | Holds multiple axes and arranges them in a rectangular shape |
| CQCPColorScaleAxisRectPrivate | An axis rect subclass for use in a QCPColorScale |
| CQCPColorScale | A color scale for use with color coding data such as QCPColorMap |
| ►CQCPLayout | The abstract base class for layouts |
| ►CQCPLayoutGrid | A layout that arranges child elements in a grid |
| CQCPLegend | Manages a legend inside a QCustomPlot |
| CQCPLayoutInset | A layout that places child elements aligned to the border or arbitrarily positioned |
| CQCPPolarAxisAngular | The main container for polar plots, representing the angular axis as a circle |
| CQCPTextElement | A layout element displaying a text |
| CQCPPolarAxisRadial | The radial axis inside a radial plot |
| CQCPPolarGraph | A radial graph used to display data in polar plots |
| CQCPPolarGrid | The grid in both angular and radial dimensions for polar plots |
| CQCPSelectionRect | Provides rect/rubber-band data selection and range zoom interaction |
| CQCPMarginGroup | A margin group allows synchronization of margin sides if working with multiple layout elements |
| CqMDNS | Implements a simple mDNS responder using Qt |
| ►CQQuickItem [external] | |
| CItem | [7] |
| CSkyMapLite | Item for displaying sky objects; also handles user interaction events |
| ►CQWidget [external] | |
| CEkos::Align | Align class handles plate-solving and polar alignment measurement and correction using astrometry.net The align class employs StellarSolver library for local solvers and supports remote INDI-based solver. StellarSolver supports internal and external solvers (Astrometry.net, ASTAP, Online Astrometry). If an image is solved successfully, the image central J2000 RA & DE coordinates along with pixel scale, rotation, and partiy are reported back. Index files management is supported with ability to download astrometry.net files. The user may select and edit different solver profiles that provide settings to control both extraction and solving profiles in detail. Manual and automatic field rotation is supported in order to align the solved images to a particular orientation in the sky. The manual rotation assistant is an interactive tool that helps the user to arrive at the desired framing. Align module provide Polar Align Helper tool which enables easy-to-follow polar alignment procedure given wide FOVs (> 1.5 degrees) Legacy polar aligment is deprecated |
| CEkos::Analyze | Analysis tab for Ekos sessions |
| CEkos::Capture | Captures single or sequence of images from a CCD. The capture class support capturing single or multiple images from a CCD, it provides a powerful sequence queue with filter wheel selection. Any sequence queue can be saved as Ekos Sequence Queue (.esq). All image capture operations are saved as Sequence Jobs that encapsulate all the different options in a capture process. The user may select in sequence autofocusing by setting a maximum HFR limit. When the limit is exceeded, it automatically trigger autofocus operation. The capture process can also be linked with guide module. If guiding deviations exceed a certain threshold, the capture operation aborts until the guiding deviation resume to acceptable levels and the capture operation is resumed |
| CEkos::Focus | Supports manual focusing and auto focusing using relative and absolute INDI focusers |
| CEkos::Guide | Performs calibration and autoguiding using an ST4 port or directly via the INDI driver. Can be used with the following external guiding applications: PHD2 LinGuider |
| CEkos::Mount | Supports controlling INDI telescope devices including setting/retrieving mount properties, slewing, motion and speed controls, in addition to enforcing altitude limits and parking/unparking |
| CEkos::PolarAlignmentAssistant | The PolarAlignmentAssistant class |
| CEkos::Scheduler | The Ekos scheduler is a simple scheduler class to orchestrate automated multi object observation jobs |
| CFITSTab | Holds information on the current view (drawing area) in addition to the undo/redo stacks and status of current document (clean or dirty) |
| CGenericCalendarWidget | Uses any KDateTable subclass for the date table and provides a calendar with options to choose a month / year |
| CGUIManager | |
| CINDI_D | |
| CINDI_E | |
| CINDI_P | |
| CInfoBoxes | Collection of InfoBoxWidget objects that display a transparent box for display of text messages |
| CInfoBoxWidget | Widget that displays a transparent box for display of text messages |
| ►CQAbstractSlider [external] | |
| ►CQSlider [external] | |
| CctkRangeSlider | |
| ►CQAbstractSpinBox [external] | |
| ►CQDoubleSpinBox [external] | |
| CMagnitudeSpinBox | Custom spinbox for magnitude (float) values |
| CQCustomPlot | The central class of the library. This is the QWidget which displays the plot and interacts with the user |
| ►CQDialog [external] | |
| CAddCatalogObject | A simple data entry dialog to create and edit objects in CatalogDB catalogs |
| CAddCatDialog | Dialog for adding custom object catalogs to KStars |
| CAddLinkDialog | |
| CAltVsTime | Altitude vs. Time Tool. Plot the altitude as a function of time for any list of objects, as seen from any location, on any date |
| CAstroCalc | This is the base class for the KStars astronomical calculator |
| CCatalogColorEditor | A form for editing catalog color scheme mappings |
| CCatalogDetails | A dialog that shows catalog information and provides facilities to edit catalog meta information and manage its contents (if the catalog is mutable) |
| CCatalogEditForm | A simple data entry form for creating/editing catalog meta information |
| CCatalogsDBUI | A simple UI to manage downloaded and custom Catalogs |
| CCustomDrivers | Handles adding new drivers to database. This would enable to add arbitrary aliases of existing drivers |
| CDriverManager | DriverManager is the primary class to handle all operations related to starting and stopping INDI drivers |
| CEkos::DarkLibrary | Handles acquisition & loading of dark frames and defect map for cameras. If a suitable dark frame exists, it is loaded from disk, otherwise it gets captured and saved for later use |
| CExecute | |
| CExportEyepieceView | Dialog to export the eyepiece view as an image, with some annotations for field-use |
| CExportImageDialog | Export sky image dialog |
| CEyepieceField | Renders the view through the eyepiece of various telescope types |
| CFindDialog | Find Object Dialog |
| CFlagManager | Flag manager Dialog box to add and remove flags |
| CFocusDialog | A small dialog for setting the focus coordinates manually |
| CFOVDialog | |
| CFovEditorDialog | Class representing FOV Editor Dialog which enables user to edit FOV snapshots |
| CHorizonManager | Manages adding/removing and editing regions and points associated with user-customized artificial horizons |
| CImageViewer | Image viewer window for KStars |
| CJMoonTool | Display the positions of Jupiter's moons as a function of time |
| ►CKPageDialog [external] | |
| CDetailDialog | |
| CKSWizard | |
| CLocationDialog | Geographic Location dialog |
| CMoonPhaseTool | Shows a moon phase calendar for an entire month |
| CNewFOV | |
| CObserverAdd | |
| CObservingList | Tool for managing a custom list of objects |
| CObsListWizard | Wizard for constructing observing lists |
| CPlanetViewer | Display an overhead view of the solar system |
| CPrintingWizard | Class representing Printing Wizard for KStars printed documents (currently only finder charts) |
| ►CQMessageBox [external] | |
| CKSMessageBox | |
| CScriptBuilder | |
| CSkyCalendar | |
| CTelescopeFL | |
| CThumbnailPicker | Dialog for modifying an object's thumbnail image |
| CTimeDialog | Dialog for adjusting the Time and Date |
| CWUTDialog | |
| CXPlanetImageViewer | XPlanet Image viewer window for KStars |
| CYAxisTool | Manages adjusting the Y-axis of Analyze stats graphs |
| ►CQFrame [external] | |
| CConjunctionsTool | Predicts conjunctions using KSConjunct in the background |
| CEclipseTool | The EclipseTool class |
| CEkos::OpsCalibration | |
| CEkos::OpsDither | |
| CEkos::OpsGPG | |
| CEkos::OpsGuide | |
| CEkos::OpsLogs | |
| CFovEditorDialogUI | User interface for FOV Editor Dialog |
| ►CKPlotWidget [external] | |
| CAVTPlotWidget | An extension of the KPlotWidget for the AltVsTime tool. The biggest difference is that in addition to the plot objects, it draws the "ground" below Alt=0 and draws the sky light blue for day times, and black for night times. The transition between day and night is drawn with a gradient, and the position follows the actual sunrise/sunset times of the given date/location. Also, this plot widget provides two time axes (local time along the bottom, and local sideral time along the top). Finally, it provides user interaction: on mouse click, it draws crosshairs at the mouse position with labels for the time and altitude |
| CCalendarWidget | An extension of the KPlotWidget for the SkyCalendar tool |
| CMapCanvas | Widget used in the LocationDialog for displaying the world map |
| CmodCalcAltAz | |
| CmodCalcAngDist | Module to compute the angular distance between two points in the sky and position angle |
| CmodCalcApCoord | Compute the equatorial coordinates for a given date and time from a given epoch or equinox |
| CmodCalcDayLength | Module to compute the equatorial coordinates for a given date and time from a given epoch or equinox |
| CmodCalcEclCoords | Class which implements the KStars calculator module to compute geocentric ecliptic coordinates to/from geocentric equatorial coordinates |
| CmodCalcEquinox | |
| CmodCalcGalCoord | Class which implements the KStars calculator module to compute Galactic coordinates to/from Equatorial coordinates |
| CmodCalcGeodCoord | Class which implements the KStars calculator module to compute Geodetic coordinates to/from Cartesian coordinates |
| CmodCalcJD | Class for KStars module which computes JD, MJD and Date/Time from the any of the other entries |
| CmodCalcPlanets | |
| CmodCalcSidTime | Class which implements the KStars calculator module to compute Universal time to/from Sidereal time |
| CmodCalcVlsr | Module to compute the heliocentric radial velocity, geocentric radial velocity and topocentric radial velocity for a source, given its coordinates, its Vlsr and the date and location on the Earth |
| COpsAdvanced | |
| COpsCatalog | Catalog page of the Options window |
| COpsColors | The Colors page of the Options window |
| COpsDeveloper | |
| COpsFITS | |
| COpsGuides | |
| COpsHIPS | |
| COpsINDI | |
| COpsSatellites | |
| COpsSolarSystem | The Solar System page of the Options window |
| COpsSupernovae | |
| COpsTerrain | |
| CPWizChartConfigUI | User interface for "Configure basic finder chart settings" step of the Printing Wizard |
| CPWizChartContentsUI | User interface for "Configure chart contents" step of the Printing Wizard |
| CPWizFovBrowseUI | User interface for "Browse captured FOV images" step of Printing Wizard |
| CPWizFovConfigUI | User interface for "Configure common FOV export options" step of the Printing Wizard |
| CPWizFovManualUI | User interface for "Manual FOV capture" step of the Printing Wizard |
| CPWizFovShUI | User interface for "Star hopper FOV snapshot capture" step of the Printing Wizard |
| CPWizFovTypeSelectionUI | User interface for "Select FOV capture method" step of the Printing Wizard |
| CPWizObjectSelectionUI | User interface for "Select observed object" step of the Printing Wizard |
| CPWizPrintUI | User interface for last "Print and export finder chart" step of the Printing Wizard |
| CPWizWelcomeUI | User interface for the first step of the Printing Wizard |
| ►CQAbstractScrollArea [external] | |
| ►CQAbstractItemView [external] | |
| ►CQListView [external] | |
| ►CQListWidget [external] | |
| CDragListBox | Extension of KListWidget that allows Drag-and-Drop with other DragListBoxes |
| ►CQGraphicsView [external] | |
| CSkyMap | Canvas widget for displaying the sky bitmap; also handles user interaction events |
| ►CQScrollArea [external] | |
| CINDI_G | |
| ►CQTextEdit [external] | |
| CLogEdit | This is a simple derivative of QTextEdit, that just adds a focusOut() signal, emitted when the edit loses focus |
| ►CQLabel [external] | |
| CClickLabel | This is a QLabel with a clicked() signal |
| CKSHelpLabel | Label for displaying links to AstroInfo project |
| CWIEquipSettings | User interface for "Equipment Type and Parameters" page in WI settings dialog |
| CWILPSettings | User interface for "Light Pollution Settings" page in WI settings dialog This class deals with light pollution settings for WI. The user sets the bortle dark-sky rating for the night sky, and this value is used to calculate one of the parameters that decides the limiting mangnitude |
| CXPlanetImageLabel | XPlanet Image viewer QFrame for the KPlanetImageViewer for KStars |
| ►CQGLWidget [external] | |
| CSkyMapGLDraw | This class draws the SkyMap using OpenGL |
| ►CQLineEdit [external] | |
| CdmsBox | |
| ►CQMainWindow [external] | |
| ►CKMainWindow [external] | |
| CKXmlGuiWindow [external] | |
| ►CQMenu [external] | |
| CKSPopupMenu | |
| CObsListPopupMenu | |
| CQProgressIndicator | Lets an application display a progress indicator to show that a long task is under way. Progress indicators are indeterminate and do nothing more than spin to show that the application is busy |
| CQRoundProgressBar | Circular progress bar and maintains its API similar to the QProgressBar |
| ►CQSplashScreen [external] | |
| CKStarsSplash | KStars Splash Screen |
| ►CQTabWidget [external] | |
| COpsEkos | |
| CSkyMapQDraw | This class draws the SkyMap using native QPainter |
| CTimeStepBox | Composite spinbox for specifying a time step. This composite widget consists of a TimeSpinBox (a QSpinBox), coupled with a TimeUnitBox (a second pair of up/down buttons). The second set of buttons makes larger steps through the 82 possible time-step values, skipping to the next even unit of time |
| CTimeUnitBox | Provides a second set of up/down buttons for TimeStepBox. A pair of buttons, arranged one above the other, labeled "+"/"-". These buttons are to be paired with the TimeSpinBox widget. Their function is to provide a way to cycle through the possible time steps using larger intervals than the up/down buttons of the TimeSpinBox. For example, say the Spinbox currently shows a timestep of "1 sec". Increasing the timestep with the spinbox up-button will change it to "2 sec", while using the "+" button of this widget will change it to "1 min" |
| CUnitSpinBoxWidget | The UnitSpinBoxWidget class It is a widget that provides a DoubleSpinBox and a ComboBox for conversions from different units |
| CWIView | Manages the QML user interface for What's Interesting. WIView is used to display the QML UI using a QQuickView. It acts on all signals emitted by the UI and manages the data sent to the UI for display |
| CServerManager | |
| CSimClock | Kstars simulation clock |
| CSkyMapComposite | |
| CSkyObjDescription | |
| ►CSkyPointLite | |
| CSkyObjectLite | |
| CSupernovaeComponent | This class encapsulates Supernovae |
| CTelescopeLite | |
| CTextureManager | Singleton class to manage texture loading/retrieval |
| ►CQPaintDevice [external] | |
| CQWidget [external] | |
| ►CQPainter [external] | |
| CQCPPainter | QPainter subclass used internally |
| CSkyQPainter | The QPainter-based painting backend |
| ►CQQmlImageProviderBase [external] | |
| ►CQQuickImageProvider [external] | |
| CImageProvider | |
| ►CQQmlParserStatus [external] | |
| CQQuickItem [external] | |
| CQSGMaterialShader [external] | |
| ►CQSGNode [external] | |
| ►CQSGBasicGeometryNode [external] | |
| ►CQSGClipNode [external] | |
| CRootNode | A container for nodes that holds collection of textures for stars and provides clipping |
| ►CQSGGeometryNode [external] | |
| CColorNode | [7] |
| CRectNode | QSGGeometryNode derived class that draws filled and non-filled rectangles |
| ►CQSGOpacityNode [external] | |
| ►CSkyOpacityNode | A wrapper for QSGOpacityNode that provides hide() and show() functions. If node is invisible (opacity is 0) it won't be rendered |
| CDSOIndexNode | This class represents DSOs from particular catalog |
| CLabelsItem | Handles labels in SkyMapLite |
| CLineNode | SkyOpacityNode derived class that draws lines from LineList |
| CPointNode | SkyOpacityNode derived class that represents stars and planets using cached QSGTexture |
| CPolyNode | A SkyOpacityNode derived class used for drawing of polygons (both filled and non-filled) |
| ►CSkyItem | A base class that is used for displaying SkyComponents on SkyMapLite |
| CAsteroidsItem | |
| CCometsItem | |
| CConstellationArtItem | |
| CConstellationNamesItem | |
| CDeepSkyItem | Class that handles representation of Deep Sky Objects |
| CDeepStarItem | This class handles representation of unnamed stars in SkyMapLite |
| CEclipticItem | Represents Ecliptic in SkyMapLite |
| CEquatorItem | Represents Equator in SkyMapLite |
| CFOVItem | |
| CHorizonItem | |
| CLinesItem | Class that handles most of the lines in SkyMapLite |
| CPlanetsItem | |
| CSatellitesItem | |
| CStarItem | Class that handles Stars |
| CSupernovaeItem | |
| CTelescopeSymbolsItem | |
| ►CTrixelNode | Convenience class that represents trixel in SkyMapLite |
| CDSOTrixelNode | Trixel |
| ►CQSGTransformNode [external] | |
| CEllipseNode | QSGTransformNode derived node used to draw ellipses |
| CFOVSymbolBase | A QSGTransformNode derived base class of every type of FOV symbol |
| ►CSkyNode | Provides virtual functions for update of coordinates and nodes hiding |
| CConstellationArtNode | A SkyNode derived class that represents ConstellationsArt object |
| CDeepSkyNode | A SkyNode derived class used for displaying DeepSkyObjects |
| CDSOSymbolNode | A SkyNode derived class used for Deep Sky symbols in SkyMapLite |
| CFOVSymbolNode | A SkyNode derived class that is used for displaying FOV symbol |
| CGuideLabelNode | |
| CHorizonNode | This node acts as a parent of nodes that comprise horizon and both filled and non-filled ground |
| CLabelNode | A SkyNode derived class used for displaying labels |
| CPlanetMoonsNode | A container for planets and moons that provides z-order |
| CPlanetNode | A container for PointNode and QSGSimpleTextureNode used for displaying some solar system objects |
| CPointSourceNode | A SkyNode derived class that represents stars and objects that are drawn as stars |
| CSatelliteNode | A SkyNode derived class that represents satellite |
| CSkyPolygonNode | A SkyNode derived class that represents polygon (either filled or non-filled) One of the applications of this class is drawing of Milky Way |
| CSupernovaNode | A SkyNode derived class that represents supernova |
| CSymbolNode | A base class for all symbol nodes |
| ►CQSGSimpleMaterialShader< State > [external] | |
| CShader | [1] |
| ►CQTextStream [external] | |
| CKSFileReader | |
| CRangeConvex | A spatial convex is composed of spatial constraints |
| CFITSData::Record | Object to hold FITS Header records |
| CSchemeManager | A set of methods used to work with colors |
| COAL::Scope | |
| CScriptFunction | Jason Harris |
| CScrollBar | This qml code implements a vertical scrollbar which shall be displayed in listview of sky-objects |
| Crapidcsv::SeparatorParams | Datastructure holding parameters controlling how the CSV data fields are separated |
| CSequenceJob | Sequence Job is a container for the details required to capture a series of images |
| COAL::Session | |
| CShFovExporter | Helper class used as a wrapper for StarHopper when capturing FOV snapshots |
| CSimpleFovExporter | SimpleFovExporter class is used for FOV representation exporting. Central point is defined by passed pointer to SkyPoint instance and field-of-view parameters are defined by FOV class instance. Fragment of sky is painted on passed QPaintDevice subclass. SimpleFovExporter class can be used for export of FOV representations in user-interactive mode as well as for export of multiple FOVs at once, without user interaction |
| COAL::Site | |
| CSkipList | |
| ►CSkyComponent | |
| CCatalogsComponent | Represents objects loaded from an sqlite backed, trixel indexed catalog |
| CConstellationArtComponent | |
| CEarthShadowComponent | The EarthShadowComponent class |
| CHIPSComponent | |
| ►CLineListIndex | |
| CConstellationLines | |
| CEcliptic | |
| CMilkyWay | Class that handles drawing of MilkyWay (both filled and non-filled) |
| ►CNoPrecessIndex | |
| ►CCoordinateGrid | |
| CEquatorialCoordinateGrid | |
| CHorizontalCoordinateGrid | |
| CLocalMeridianComponent | |
| CEquator | |
| ►CListComponent | |
| CConstellationNamesComponent | |
| CDeepStarComponent | |
| ►CSolarSystemListComponent | |
| CAsteroidsComponent | |
| CCometsComponent | |
| CStarComponent | Represents the stars on the sky map. For optimization reasons the stars are not separate objects and are stored in a list |
| CSupernovaeComponent | This class encapsulates Supernovae |
| CMosaicComponent | |
| CPlanetMoonsComponent | |
| ►CPointListComponent | |
| CFlagComponent | Represents a flag on the sky map. Each flag is composed by a SkyPoint where coordinates are stored, an epoch and a label. This class also stores flag images and associates each flag with an image. When FlagComponent is created, it seeks all file names beginning with "_flag" in the user directory and consider them as flag images |
| CHorizonComponent | |
| CSatellitesComponent | |
| ►CSkyComposite | |
| CSkyMapComposite | |
| CSolarSystemComposite | |
| CSolarSystemSingleComponent | |
| CTargetListComponent | Highlights objects present in certain lists by drawing "target" symbols around them |
| CTerrainComponent | |
| CSkyLabeler | |
| CSkyLine | |
| ►CSkyMapDrawAbstract | This class defines the methods that both rendering engines (GLPainter and QPainter) must implement |
| CSkyMapGLDraw | This class draws the SkyMap using OpenGL |
| CSkyMapQDraw | This class draws the SkyMap using native QPainter |
| CSkyObjItem | |
| ►CSkyPainter | Draws things on the sky, without regard to backend |
| CSkyQPainter | The QPainter-based painting backend |
| ►CSkyPoint | Stores dms coordinates for a point in the sky. for converting between coordinate systems |
| ►CSkyObject | Information about an object in the sky |
| CCatalogObject | A simple container object to hold the minimum information for a Deep Sky Object to be drawn on the skymap |
| CConstellationsArt | Information about a ConstellationsArt object. This class represents a constellation image |
| CSatellite | |
| CStarObject | Subclass of SkyObject specialized for stars |
| CSupernova | |
| ►CTrailObject | SkyObject with an attachable Trail |
| ►CKSPlanetBase | Provides necessary information about objects in the solar system |
| ►CKSAsteroid | A subclass of KSPlanetBase that implements asteroids |
| CKSPluto | Provides necessary information about Pluto |
| CKSComet | A subclass of KSPlanetBase that implements comets |
| CKSEarthShadow | A class that manages the calculation of the earths shadow (in moon distance) as a 'virtual' skyobject. KSMoon is responsible for coordinating this object. While a rather unusual measure, this method ensures that unnecessary calculations are avoided |
| CKSMoon | Provides necessary information about the Moon. A subclass of SkyObject that provides information needed for the Moon. Specifically, KSMoon provides a moon-specific findPosition() function. Also, there is a method findPhase(), which returns the lunar phase as a floating-point number between 0.0 and 1.0 |
| ►CKSPlanet | Provides necessary information about objects in the solar system |
| CKSSun | Provides necessary information about the Sun |
| CSpatialConstraint | The Constraint is really a cone on the sky-sphere |
| ►CSpatialException | HTM SpatialIndex Exception base class This is the base class for all Science Archive exceptions |
| CSpatialBoundsError | SpatialException thrown on violation of array bounds |
| CSpatialFailure | SpatialException thrown on operational failure |
| CSpatialInterfaceError | SpatialException thrown on violation of interface protocols |
| CSpatialUnimplemented | SpatialException thrown by unimplemented functions |
| CSpatialIndex | |
| CSpatialVector | |
| CStarBlock | |
| CStarBlockFactory | A factory that creates StarBlocks and recycles them in an LRU Cache |
| CStarBlockList | |
| CStarData | A 32-byte Structure that holds star data |
| CStarHopper | Helps planning star hopping |
| CState | [1] |
| CTimeSpinBox | |
| CTimeZoneRule | |
| CTrixelCache< content > | A simple integer indexed elastically cached wrapper around std::vector to hold container types content which are cheap to construct empty and provide a default constructor, as well as [], size and swap members (think std::vector and std::list) |
| CTrixelCache< ObjectList > | |
| CViewParams | This is just a container that holds information needed to do projections |
| CYAxisInfo | Used to keep track of the various Y-axes and connect them to the QLineEdits |