Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12]
 NEkosEkos is an advanced Astrophotography tool for Linux. It is based on a modular extensible framework to perform common astrophotography tasks. This includes highly accurate GOTOs using astrometry solver, ability to measure and correct polar alignment errors , auto-focus & auto-guide capabilities, and capture of single or stack of images with filter wheel support.
 CAddCatalogObjectA simple data entry dialog to create and edit objects in CatalogDB catalogs
 CAddCatDialogDialog for adding custom object catalogs to KStars
 CAltVsTimeAltitude vs. Time Tool. Plot the altitude as a function of time for any list of objects, as seen from any location, on any date
 CApproachSolverImplements 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
 CAstroCalcThis is the base class for the KStars astronomical calculator
 CAVTPlotWidgetAn 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
 CBinaryListComponentFunctionality for loading the component data from Binary
 CBinFileHelperImplements an interface to handle binary data files used by KStars
 CCachingDmsDms subclass that caches its sine and cosine values every time the angle is changed
 CCalendarWidgetAn extension of the KPlotWidget for the SkyCalendar tool
 CCatalogColorEditorA form for editing catalog color scheme mappings
 CCatalogDetailsA dialog that shows catalog information and provides facilities to edit catalog meta information and manage its contents (if the catalog is mutable)
 CCatalogEditFormA simple data entry form for creating/editing catalog meta information
 CCatalogObjectA simple container object to hold the minimum information for a Deep Sky Object to be drawn on the skymap
 CCatalogsComponentRepresents objects loaded from an sqlite backed, trixel indexed catalog
 CCatalogsDBUIA simple UI to manage downloaded and custom Catalogs
 CClickLabelThis is a QLabel with a clicked() signal
 CConjunctionsToolPredicts conjunctions using KSConjunct in the background
 CConstellationArtNodeA SkyNode derived class that represents ConstellationsArt object
 CConstellationNameThe ConstellationName struct
 CConstellationsArtInformation about a ConstellationsArt object. This class represents a constellation image
 CCrossHairNodeRepresents crosshair of telescope in SkyMapLite
 CCustomDriversHandles adding new drivers to database. This would enable to add arbitrary aliases of existing drivers
 CdataElementA structure describing a data field in the binary file
 Cdc1394color_codings_tA struct containing a list of color codings
 Cdc1394video_modes_tA struct containing a list of video modes
 CDeepSkyItemClass that handles representation of Deep Sky Objects
 CDeepSkyNodeA SkyNode derived class used for displaying DeepSkyObjects
 CDeepStarDataA 16-byte structure that holds star data for really faint stars
 CDeepStarItemThis class handles representation of unnamed stars in SkyMapLite
 CDetailsTableRepresents 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
 CDetalDialogLiteBackend 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
 CdmsAn angle, stored as degrees, but expressible in many ways
 CDragListBoxExtension of KListWidget that allows Drag-and-Drop with other DragListBoxes
 CDriverManagerDriverManager is the primary class to handle all operations related to starting and stopping INDI drivers
 CDSOIndexNodeThis class represents DSOs from particular catalog
 CDSOSymbolNodeA SkyNode derived class used for Deep Sky symbols in SkyMapLite
 CEarthShadowComponentThe EarthShadowComponent class
 CEclipseEventThe EclipseEvent class
 CEclipseHandlerThe EclipseHandler class
 CEclipseModelThe EclipseModel class
 CEclipseToolThe EclipseTool class
 CEclipticItemRepresents Ecliptic in SkyMapLite
 CEclipticPositionThe ecliptic position of a planet (Longitude, Latitude, and distance from Sun)
 CEllipseNodeQSGTransformNode derived node used to draw ellipses
 CEquatorItemRepresents Equator in SkyMapLite
 CExportEyepieceViewDialog to export the eyepiece view as an image, with some annotations for field-use
 CExportImageDialogExport sky image dialog
 CEyepieceFieldRenders the view through the eyepiece of various telescope types
 CFindDialogFind Object Dialog
 CFindDialogLiteBackend 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
 CFinderChartClass 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
 CFITSTabHolds information on the current view (drawing area) in addition to the undo/redo stacks and status of current document (clean or dirty)
 CFITSViewerPrimary 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
 CFlagComponentRepresents 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
 CFlagManagerFlag manager Dialog box to add and remove flags
 CFocusDialogA small dialog for setting the focus coordinates manually
 CFovEditorDialogClass representing FOV Editor Dialog which enables user to edit FOV snapshots
 CFovEditorDialogUIUser interface for FOV Editor Dialog
 CFovSnapshotClass 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
 CFOVSymbolBaseA QSGTransformNode derived base class of every type of FOV symbol
 CFOVSymbolNodeA SkyNode derived class that is used for displaying FOV symbol
 CGaussianProcessGuiderThis class provides a guiding algorithm for the right ascension axis that learns and predicts the periodic gear error with a Gaussian process
 CGenericCalendarWidgetUses any KDateTable subclass for the date table and provides a calendar with options to choose a month / year
 CGeoLocationRelevant data about an observing location on Earth
 CGreatCircleA class to compute points along a great circle from one az/alt to another
 CGuideViewThe main change relative to fitsview is to add the capability of displaying the 'neighbor guide stars' for the SEP Multi Star guide algorithm
 CHorizonManagerManages adding/removing and editing regions and points associated with user-customized artificial horizons
 CHorizonNodeThis node acts as a parent of nodes that comprise horizon and both filled and non-filled ground
 CImageExporterBackends for exporting a sky image, either raster or vector, with a legend
 CImageViewerImage viewer window for KStars
 CInfoBoxesCollection of InfoBoxWidget objects that display a transparent box for display of text messages
 CInfoBoxWidgetWidget that displays a transparent box for display of text messages
 CJMoonToolDisplay the positions of Jupiter's moons as a function of time
 CKSAlmanacImplement methods to find important times in a day
 CKSAsteroidA subclass of KSPlanetBase that implements asteroids
 CKSCometA subclass of KSPlanetBase that implements comets
 CKSConjunctImplements 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
 CKSDssDownloaderHelps download a DSS image
 CKSDssImageProvides a class to hold a DSS Image along with its metadata
 CKSEarthShadowA 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
 CKSHelpLabelLabel for displaying links to AstroInfo project
 CKSMoonProvides 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
 CKSNumbersStore several time-dependent astronomical quantities
 CKSPathsWrapper 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)
 CKSPlanetProvides necessary information about objects in the solar system
 CKSPlanetBaseProvides necessary information about objects in the solar system
 CKSPlutoProvides necessary information about Pluto
 CKSSunProvides necessary information about the Sun
 CKStarsThis 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
 CKStarsDateTimeExtension 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)
 CKStarsDocumentBase class for KStars documents. KStarsDocument is a base class for all KStars documents: finder charts, logging forms etc
 CKStarsLiteThis 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
 CKStarsSplashKStars Splash Screen
 CKSUserDBSingle class to delegate all User database I/O
 CKSUtilsKStars utility functions
 CLabelNodeA SkyNode derived class used for displaying labels
 CLabelsItemHandles labels in SkyMapLite
 CLineNodeSkyOpacityNode derived class that draws lines from LineList
 CLinesItemClass that handles most of the lines in SkyMapLite
 CLocationDialogGeographic Location dialog
 CLogEditThis is a simple derivative of QTextEdit, that just adds a focusOut() signal, emitted when the edit loses focus
 CLoggingFormClass that represents logging form. Currently, LoggingForm class is used to create logging forms for finder charts
 CLunarEclipseDetailsThe LunarEclipseDetails struct
 CLunarEclipseEventThe LunarEclipseEvent class
 CLunarEclipseHandlerThe LunarEclipseHandler class
 CMagnitudeSpinBoxCustom spinbox for magnitude (float) values
 CManagerPrimary 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
 CMapCanvasWidget used in the LocationDialog for displaying the world map
 CMilkyWayClass that handles drawing of MilkyWay (both filled and non-filled)
 CmodCalcAngDistModule to compute the angular distance between two points in the sky and position angle
 CmodCalcApCoordCompute the equatorial coordinates for a given date and time from a given epoch or equinox
 CmodCalcDayLengthModule to compute the equatorial coordinates for a given date and time from a given epoch or equinox
 CmodCalcEclCoordsClass which implements the KStars calculator module to compute geocentric ecliptic coordinates to/from geocentric equatorial coordinates
 CmodCalcGalCoordClass which implements the KStars calculator module to compute Galactic coordinates to/from Equatorial coordinates
 CmodCalcGeodCoordClass which implements the KStars calculator module to compute Geodetic coordinates to/from Cartesian coordinates
 CmodCalcJDClass for KStars module which computes JD, MJD and Date/Time from the any of the other entries
 CmodCalcSidTimeClass which implements the KStars calculator module to compute Universal time to/from Sidereal time
 CmodCalcVlsrModule 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
 CModelManagerManages models for QML listviews of different types of sky-objects
 CMoonPhaseToolShows a moon phase calendar for an entire month
 CNOMADStarDataWriterWrites NOMAD star data
 CObservingListTool for managing a custom list of objects
 CObsListWizardWizard for constructing observing lists
 COpsCatalogCatalog page of the Options window
 COpsColorsThe Colors page of the Options window
 COpsSolarSystemThe Solar System page of the Options window
 CPlanetMoonsNodeA container for planets and moons that provides z-order
 CPlanetNodeA container for PointNode and QSGSimpleTextureNode used for displaying some solar system objects
 CPlanetViewerDisplay an overhead view of the solar system
 CPointNodeSkyOpacityNode derived class that represents stars and planets using cached QSGTexture
 CPointSourceNodeA SkyNode derived class that represents stars and objects that are drawn as stars
 CPoleAxisPoleAxis class handles determining the mount Ha axis position given three positions taken with the same mount declination
 CPolyNodeA SkyOpacityNode derived class used for drawing of polygons (both filled and non-filled)
 CPrintingWizardClass representing Printing Wizard for KStars printed documents (currently only finder charts)
 CPWizChartConfigUIUser interface for "Configure basic finder chart settings" step of the Printing Wizard
 CPWizChartContentsUIUser interface for "Configure chart contents" step of the Printing Wizard
 CPWizFovBrowseUIUser interface for "Browse captured FOV images" step of Printing Wizard
 CPWizFovConfigUIUser interface for "Configure common FOV export options" step of the Printing Wizard
 CPWizFovManualUIUser interface for "Manual FOV capture" step of the Printing Wizard
 CPWizFovShUIUser interface for "Star hopper FOV snapshot capture" step of the Printing Wizard
 CPWizFovTypeSelectionUIUser interface for "Select FOV capture method" step of the Printing Wizard
 CPWizObjectSelectionUIUser interface for "Select observed object" step of the Printing Wizard
 CPWizPrintUIUser interface for last "Print and export finder chart" step of the Printing Wizard
 CPWizWelcomeUIUser interface for the first step of the Printing Wizard
 CQCPAbstractItemThe abstract base class for all items in a plot
 CQCPAbstractLegendItemThe abstract base class for all entries in a QCPLegend
 CQCPAbstractPaintBufferThe abstract base class for paint buffers, which define the rendering backend
 CQCPAbstractPlottableThe abstract base class for all data representing objects in a plot
 CQCPAbstractPlottable1DA template base class for plottables with one-dimensional data
 CQCPAxisManages a single axis inside a QCustomPlot
 CQCPAxisRectHolds multiple axes and arranges them in a rectangular shape
 CQCPAxisTickerThe base class tick generator used by QCPAxis to create tick positions and tick labels
 CQCPAxisTickerDateTimeSpecialized axis ticker for calendar dates and times as axis ticks
 CQCPAxisTickerFixedSpecialized axis ticker with a fixed tick step
 CQCPAxisTickerLogSpecialized axis ticker suited for logarithmic axes
 CQCPAxisTickerPiSpecialized axis ticker to display ticks in units of an arbitrary constant, for example pi
 CQCPAxisTickerTextSpecialized axis ticker which allows arbitrary labels at specified coordinates
 CQCPAxisTickerTimeSpecialized axis ticker for time spans in units of milliseconds to days
 CQCPBarsA plottable representing a bar chart in a plot
 CQCPBarsDataHolds the data of one single data point (one bar) for QCPBars
 CQCPBarsGroupGroups multiple QCPBars together so they appear side by side
 CQCPColorGradientDefines a color gradient for use with e.g. QCPColorMap
 CQCPColorMapA plottable representing a two-dimensional color map in a plot
 CQCPColorMapDataHolds the two-dimensional data of a QCPColorMap plottable
 CQCPColorScaleA color scale for use with color coding data such as QCPColorMap
 CQCPColorScaleAxisRectPrivateAn axis rect subclass for use in a QCPColorScale
 CQCPCurveA plottable representing a parametric curve in a plot
 CQCPCurveDataHolds the data of one single data point for QCPCurve
 CQCPDataContainerThe generic data container for one-dimensional plottables
 CQCPDataRangeDescribes a data range given by begin and end index
 CQCPDataSelectionDescribes a data set by holding multiple QCPDataRange instances
 CQCPErrorBarsA plottable that adds a set of error bars to other plottables
 CQCPErrorBarsDataHolds the data of one single error bar for QCPErrorBars
 CQCPFinancialA plottable representing a financial stock chart
 CQCPFinancialDataHolds the data of one single data point for QCPFinancial
 CQCPGraphA plottable representing a graph in a plot
 CQCPGraphDataHolds the data of one single data point for QCPGraph
 CQCPGridResponsible for drawing the grid of a QCPAxis
 CQCPItemAnchorAn anchor of an item to which positions can be attached to
 CQCPItemBracketA bracket for referencing/highlighting certain parts in the plot
 CQCPItemCurveA curved line from one point to another
 CQCPItemEllipseAn ellipse
 CQCPItemLineA line from one point to another
 CQCPItemPixmapAn arbitrary pixmap
 CQCPItemPositionManages the position of an item
 CQCPItemRectA rectangle
 CQCPItemStraightLineA straight line that spans infinitely in both directions
 CQCPItemTextA text label
 CQCPItemTracerItem that sticks to QCPGraph data points
 CQCPLayerA layer that may contain objects, to control the rendering order
 CQCPLayerableBase class for all drawable objects
 CQCPLayoutThe abstract base class for layouts
 CQCPLayoutElementThe abstract base class for all objects that form the layout system
 CQCPLayoutGridA layout that arranges child elements in a grid
 CQCPLayoutInsetA layout that places child elements aligned to the border or arbitrarily positioned
 CQCPLegendManages a legend inside a QCustomPlot
 CQCPLineEndingHandles the different ending decorations for line-like items
 CQCPMarginGroupA margin group allows synchronization of margin sides if working with multiple layout elements
 CQCPPaintBufferPixmapA paint buffer based on QPixmap, using software raster rendering
 CQCPPainterQPainter subclass used internally
 CQCPPlottableInterface1DDefines an abstract interface for one-dimensional plottables
 CQCPPlottableLegendItemA legend item representing a plottable with an icon and the plottable name
 CQCPPolarAxisAngularThe main container for polar plots, representing the angular axis as a circle
 CQCPPolarAxisRadialThe radial axis inside a radial plot
 CQCPPolarGraphA radial graph used to display data in polar plots
 CQCPPolarGridThe grid in both angular and radial dimensions for polar plots
 CQCPPolarLegendItemA legend item for polar plots
 CQCPRangeRepresents the range an axis is encompassing
 CQCPScatterStyleRepresents the visual appearance of scatter points
 CQCPSelectionDecoratorControls how a plottable's data selection is drawn
 CQCPSelectionDecoratorBracketA selection decorator which draws brackets around each selected data segment
 CQCPSelectionRectProvides rect/rubber-band data selection and range zoom interaction
 CQCPStatisticalBoxA plottable representing a single statistical box in a plot
 CQCPStatisticalBoxDataHolds the data of one single data point for QCPStatisticalBox
 CQCPTextElementA layout element displaying a text
 CQCPVector2DRepresents two doubles as a mathematical 2D vector
 CQCustomPlotThe central class of the library. This is the QWidget which displays the plot and interacts with the user
 CqMDNSImplements a simple mDNS responder using Qt
 CQProgressIndicatorLets 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
 CQRoundProgressBarCircular progress bar and maintains its API similar to the QProgressBar
 CRangeConvexA spatial convex is composed of spatial constraints
 CRectangleOverlapChecks if two potentially rotated rectangles intersect
 CRectNodeQSGGeometryNode derived class that draws filled and non-filled rectangles
 CRootNodeA container for nodes that holds collection of textures for stars and provides clipping
 CSatelliteNodeA SkyNode derived class that represents satellite
 CSchemeManagerA set of methods used to work with colors
 CScriptFunctionJason Harris
 CScrollBarThis qml code implements a vertical scrollbar which shall be displayed in listview of sky-objects
 CSequenceJobSequence Job is a container for the details required to capture a series of images
 CSessionSortFilterProxyModelSort best observation times by reimplementing lessThan() to work on the transit times of objects
 CShFovExporterHelper class used as a wrapper for StarHopper when capturing FOV snapshots
 CSimClockKstars simulation clock
 CSimpleFovExporterSimpleFovExporter 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
 CSkyItemA base class that is used for displaying SkyComponents on SkyMapLite
 CSkyMapCanvas widget for displaying the sky bitmap; also handles user interaction events
 CSkyMapDrawAbstractThis class defines the methods that both rendering engines (GLPainter and QPainter) must implement
 CSkyMapGLDrawThis class draws the SkyMap using OpenGL
 CSkyMapLiteItem for displaying sky objects; also handles user interaction events
 CSkyMapQDrawThis class draws the SkyMap using native QPainter
 CSkyNodeProvides virtual functions for update of coordinates and nodes hiding
 CSkyObjectInformation about an object in the sky
 CSkyObjectListModelModel that is used in Find Object Dialog
 CSkyOpacityNodeA wrapper for QSGOpacityNode that provides hide() and show() functions. If node is invisible (opacity is 0) it won't be rendered
 CSkyPainterDraws things on the sky, without regard to backend
 CSkyPointStores dms coordinates for a point in the sky. for converting between coordinate systems
 CSkyPolygonNodeA SkyNode derived class that represents polygon (either filled or non-filled) One of the applications of this class is drawing of Milky Way
 CSkyQPainterThe QPainter-based painting backend
 CSpatialBoundsErrorSpatialException thrown on violation of array bounds
 CSpatialConstraintThe Constraint is really a cone on the sky-sphere
 CSpatialExceptionHTM SpatialIndex Exception base class This is the base class for all Science Archive exceptions
 CSpatialFailureSpatialException thrown on operational failure
 CSpatialInterfaceErrorSpatialException thrown on violation of interface protocols
 CSpatialUnimplementedSpatialException thrown by unimplemented functions
 CStarBlockFactoryA factory that creates StarBlocks and recycles them in an LRU Cache
 CStarComponentRepresents the stars on the sky map. For optimization reasons the stars are not separate objects and are stored in a list
 CStarDataA 32-byte Structure that holds star data
 CStarHopperHelps planning star hopping
 CStarItemClass that handles Stars
 CStarObjectSubclass of SkyObject specialized for stars
 CSupernovaeComponentThis class encapsulates Supernovae
 CSupernovaNodeA SkyNode derived class that represents supernova
 CSymbolNodeA base class for all symbol nodes
 CTargetListComponentHighlights objects present in certain lists by drawing "target" symbols around them
 CTextureManagerSingleton class to manage texture loading/retrieval
 CThumbnailPickerDialog for modifying an object's thumbnail image
 CTimeDialogDialog for adjusting the Time and Date
 CTimeStepBoxComposite 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
 CTimeUnitBoxProvides 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"
 CTrailObjectSkyObject with an attachable Trail
 CTrixelCacheA 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)
 CTrixelNodeConvenience class that represents trixel in SkyMapLite
 CUnitSpinBoxWidgetThe UnitSpinBoxWidget class It is a widget that provides a DoubleSpinBox and a ComboBox for conversions from different units
 CViewParamsThis is just a container that holds information needed to do projections
 CWIEquipSettingsUser interface for "Equipment Type and Parameters" page in WI settings dialog
 CWILPSettingsUser 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
 CWIViewManages 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
 CXPlanetImageLabelXPlanet Image viewer QFrame for the KPlanetImageViewer for KStars
 CXPlanetImageViewerXPlanet Image viewer window for KStars
 CYAxisInfoUsed to keep track of the various Y-axes and connect them to the QLineEdits
 CYAxisToolManages adjusting the Y-axis of Analyze stats graphs
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Thu Sep 21 2023 04:05:33 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.