xypor/index.php

/*

    SPDX-FileCopyrightText: 2016 Artem Fedoskin <afedoskin3@gmail.com>

    SPDX-License-Identifier: GPL-2.0-or-later

*/


#include "skymaplite.h"

#include "kstarsdata.h"

#include "kstarslite.h"


#include "indi/inditelescopelite.h"

#include "indi/clientmanagerlite.h"

#include "kstarslite/skyitems/telescopesymbolsitem.h"


#include "projections/projector.h"

#include "projections/lambertprojector.h"

#include "projections/gnomonicprojector.h"

#include "projections/stereographicprojector.h"

#include "projections/orthographicprojector.h"

#include "projections/azimuthalequidistantprojector.h"

#include "projections/equirectangularprojector.h"


#include "kstarslite/skypointlite.h"

#include "kstarslite/skyobjectlite.h"


#include "skylabeler.h"

#include "Options.h"

#include "skymesh.h"


#include "kstarslite/skyitems/rootnode.h"

#include "kstarslite/skyitems/skynodes/skynode.h"


#include "ksplanetbase.h"

#include "ksutils.h"


#include <QSGSimpleRectNode>

//#include <QSGNode>

#include <QBitmap>

#include <QSGTexture>

#include <QQuickWindow>

#include <QLinkedList>

#include <QQmlContext>

#include <QScreen>


#include "kstarslite/deviceorientation.h"


namespace

{

// Draw bitmap for zoom cursor. Width is size of pen to draw with.

QBitmap zoomCursorBitmap(int width)

{

    QBitmap b(32, 32);

    b.fill(Qt::color0);

    int mx = 16, my = 16;

    // Begin drawing

    QPainter p;

    p.begin(&b);

    p.setPen(QPen(Qt::color1, width));

    p.drawEllipse(mx - 7, my - 7, 14, 14);

    p.drawLine(mx + 5, my + 5, mx + 11, my + 11);

    p.end();

    return b;

}


// Draw bitmap for default cursor. Width is size of pen to draw with.

QBitmap defaultCursorBitmap(int width)

{

    QBitmap b(32, 32);

    b.fill(Qt::color0);

    int mx = 16, my = 16;

    // Begin drawing

    QPainter p;

    p.begin(&b);

    p.setPen(QPen(Qt::color1, width));

    // 1. diagonal

    p.drawLine(mx - 2, my - 2, mx - 8, mx - 8);

    p.drawLine(mx + 2, my + 2, mx + 8, mx + 8);

    // 2. diagonal

    p.drawLine(mx - 2, my + 2, mx - 8, mx + 8);

    p.drawLine(mx + 2, my - 2, mx + 8, mx - 8);

    p.end();

    return b;

}

}


SkyMapLite *SkyMapLite::pinstance = nullptr;


RootNode *SkyMapLite::m_rootNode = nullptr;


int SkyMapLite::starColorMode = 0;


SkyMapLite::SkyMapLite()

    : data(KStarsData::Instance())

#if defined(Q_OS_ANDROID)

    ,

      m_deviceOrientation(new DeviceOrientation(this))

#endif

{

    setAcceptHoverEvents(true);

    setAcceptedMouseButtons(Qt::AllButtons);

    setFlag(ItemHasContents, true);


    m_rootNode = nullptr;

    m_magLim   = 2.222 * log10(static_cast<double>(Options::starDensity())) + 0.35;


    setSlewing(false);


    m_ClickedObjectLite = new SkyObjectLite;

    m_ClickedPointLite  = new SkyPointLite;


    qmlRegisterType<SkyObjectLite>("KStarsLite", 1, 0, "SkyObjectLite");

    qmlRegisterType<SkyPointLite>("KStarsLite", 1, 0, "SkyPointLite");


    m_tapBeganTimer.setSingleShot(true);


    setupProjector();


    // Set pinstance to yourself

    pinstance = this;


    connect(this, SIGNAL(destinationChanged()), this, SLOT(slewFocus()));

    connect(KStarsData::Instance(), SIGNAL(skyUpdate(bool)), this, SLOT(slotUpdateSky(bool)));


    ClientManagerLite *clientMng = KStarsLite::Instance()->clientManagerLite();


    connect(clientMng, &ClientManagerLite::telescopeAdded,

            [this](TelescopeLite * newTelescope)

    {

        this->m_newTelescopes.append(newTelescope->getDevice());

    });

    connect(clientMng, &ClientManagerLite::telescopeRemoved,

            [this](TelescopeLite * newTelescope)

    {

        this->m_delTelescopes.append(newTelescope->getDevice());

    });

#if defined(Q_OS_ANDROID)

    //Automatic mode

    automaticModeTimer.setInterval(5);

    connect(&automaticModeTimer, SIGNAL(timeout()), this, SLOT(updateAutomaticMode()));

    setAutomaticMode(false);

#endif

}


QSGNode *SkyMapLite::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)

{

    Q_UNUSED(updatePaintNodeData);

    RootNode *n = static_cast<RootNode *>(oldNode);


    /* This code deletes all nodes that are representing dynamic stars and not needed anymore (under construction) */

    //qDeleteAll(m_deleteNodes);

    //m_deleteNodes.clear();


    if (m_loadingFinished && isInitialized)

    {

        if (!n)

        {

            n          = new RootNode();

            m_rootNode = n;

        }

        /** Add or delete telescope crosshairs **/

        if (m_newTelescopes.count() > 0)

        {

            foreach (INDI::BaseDevice *telescope, m_newTelescopes)

            {

                n->telescopeSymbolsItem()->addTelescope(telescope);

            }

            m_newTelescopes.clear();

        }


        if (m_delTelescopes.count() > 0)

        {

            foreach (INDI::BaseDevice *telescope, m_delTelescopes)

            {

                n->telescopeSymbolsItem()->removeTelescope(telescope);

            }

            m_delTelescopes.clear();

        }

        //Notify RootNode that textures for point node should be recreated

        n->update(clearTextures);

        clearTextures = false;

    }


    //Memory Leaks test

    /*if(m_loadingFinished) {

        if(!n) {

            n = new RootNode();

        }

        n->testLeakAdd();

        n->update();

        m_loadingFinished = false;

    } else {

        if (n) {

            n->testLeakDelete();

        }

        m_loadingFinished = true;

    }*/

    return n;

}


double SkyMapLite::deleteLimit()

{

    double lim = (MAXZOOM / MINZOOM) / sqrt(Options::zoomFactor()) / 3; //(MAXZOOM/MINZOOM - Options::zoomFactor())/130;

    return lim;

}


void SkyMapLite::deleteSkyNode(SkyNode *skyNode)

{

    m_deleteNodes.append(skyNode);

}


QSGTexture *SkyMapLite::getCachedTexture(int size, char spType)

{

    return textureCache[harvardToIndex(spType)][size];

}


SkyMapLite *SkyMapLite::createInstance()

{

    delete pinstance;

    pinstance = new SkyMapLite();

    return pinstance;

}


void SkyMapLite::initialize(QQuickItem *parent)

{

    if (parent)

    {

        setParentItem(parent);

        // Whenever the wrapper's(parent) dimensions changed, change SkyMapLite too

        connect(parent, &QQuickItem::widthChanged, this, &SkyMapLite::resizeItem);

        connect(parent, &QQuickItem::heightChanged, this, &SkyMapLite::resizeItem);


        isInitialized = true;

    }


    resizeItem(); /* Set initial size pf SkyMapLite. Without it on Android SkyMapLite is

    not displayed until screen orientation is not changed*/


    //Initialize images for stars

    initStarImages();

}


SkyMapLite::~SkyMapLite()

{

    // Delete image cache

    for (auto &imgCache : imageCache)

        qDeleteAll(imgCache);


    // Delete textures generated from image cache

    for (auto &tCache : textureCache)

        qDeleteAll(tCache);

}


void SkyMapLite::setFocus(SkyPoint *p)

{

    setFocus(p->ra(), p->dec());

}


void SkyMapLite::setFocus(const dms &ra, const dms &dec)

{

    Options::setFocusRA(ra.Hours());

    Options::setFocusDec(dec.Degrees());


    focus()->set(ra, dec);

    focus()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

}


void SkyMapLite::setFocusAltAz(const dms &alt, const dms &az)

{

    Options::setFocusRA(focus()->ra().Hours());

    Options::setFocusDec(focus()->dec().Degrees());

    focus()->setAlt(alt);

    focus()->setAz(az);

    focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat());


    setSlewing(false);

    forceUpdate(); //need a total update, or slewing with the arrow keys doesn't work.

}


void SkyMapLite::setDestination(const SkyPoint &p)

{

    setDestination(p.ra(), p.dec());

}


void SkyMapLite::setDestination(const dms &ra, const dms &dec)

{

    destination()->set(ra, dec);

    destination()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

    emit destinationChanged();

}


void SkyMapLite::setDestinationAltAz(const dms &alt, const dms &az, bool altIsRefracted)

{

    if (altIsRefracted)

    {

        // The alt in the SkyPoint is always actual, not apparent

        destination()->setAlt(SkyPoint::unrefract(alt));

    }

    else

    {

        destination()->setAlt(alt);

    }

    destination()->setAz(az);

    destination()->HorizontalToEquatorial(data->lst(), data->geo()->lat());

    emit destinationChanged();

}


void SkyMapLite::setClickedPoint(SkyPoint *f)

{

    ClickedPoint = *f;

    m_ClickedPointLite->setPoint(f);

}


void SkyMapLite::setClickedObject(SkyObject *o)

{

    ClickedObject = o;

    m_ClickedObjectLite->setObject(o);

}


void SkyMapLite::setFocusObject(SkyObject *o)

{

    FocusObject = o;

    if (FocusObject)

        Options::setFocusObject(FocusObject->name());

    else

        Options::setFocusObject(i18n("nothing"));

}


void SkyMapLite::slotCenter()

{

    /*KStars* kstars = KStars::Instance();

    TrailObject* trailObj = dynamic_cast<TrailObject*>( focusObject() );*/


    setFocusPoint(clickedPoint());

    if (Options::useAltAz())

    {

        focusPoint()->updateCoords(data->updateNum(), true, data->geo()->lat(), data->lst(), false);

        focusPoint()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

    }

    else

    {

        focusPoint()->updateCoords(data->updateNum(), true, data->geo()->lat(), data->lst(), false);

    }

    qDebug() << "Centering on " << focusPoint()->ra().toHMSString() << " " << focusPoint()->dec().toDMSString();


    //clear the planet trail of old focusObject, if it was temporary

    /*if( trailObj && data->temporaryTrail ) {

        trailObj->clearTrail();

        data->temporaryTrail = false;

    }*/


    //If the requested object is below the opaque horizon, issue a warning message

    //(unless user is already pointed below the horizon)

    if (Options::useAltAz() && Options::showGround() && focus()->alt().Degrees() > SkyPoint::altCrit &&

            focusPoint()->alt().Degrees() <= SkyPoint::altCrit)

    {

        QString caption = i18n("Requested Position Below Horizon");

        QString message = i18n("The requested position is below the horizon.\nWould you like to go there anyway?");

        /*if ( KMessageBox::warningContinueCancel( this, message, caption,

                                        KGuiItem(i18n("Go Anyway")), KGuiItem(i18n("Keep Position")), "dag_focus_below_horiz" )==KMessageBox::Cancel ) {

            setClickedObject( nullptr );

            setFocusObject( nullptr );

            Options::setIsTracking( false );


            return;

        }*/

    }


    //set FocusObject before slewing.  Otherwise, KStarsData::updateTime() can reset

    //destination to previous object...

    setFocusObject(ClickedObject);

    Options::setIsTracking(true);

    /*if ( kstars ) {

        kstars->actionCollection()->action("track_object")->setIcon( QIcon::fromTheme("document-encrypt") );

        kstars->actionCollection()->action("track_object")->setText( i18n( "Stop &Tracking" ) );

    }*/


    //If focusObject is a SS body and doesn't already have a trail, set the temporaryTrail


    /*if( Options::useAutoTrail() && trailObj && trailObj->hasTrail() ) {

        trailObj->addToTrail();

        data->temporaryTrail = true;

    }*/


    //update the destination to the selected coordinates

    if (Options::useAltAz())

    {

        setDestinationAltAz(focusPoint()->alt(), focusPoint()->az(), false);

    }

    else

    {

        setDestination(*focusPoint());

    }


    focusPoint()->EquatorialToHorizontal(data->lst(), data->geo()->lat());


    //display coordinates in statusBar

    emit mousePointChanged(focusPoint());

    //showFocusCoords(); //update FocusBox

    //Lock center so that user could only zoom on touch-enabled devices

}


void SkyMapLite::slewFocus()

{

    //Don't slew if the mouse button is pressed

    //Also, no animated slews if the Manual Clock is active

    //08/2002: added possibility for one-time skipping of slew with snapNextFocus

    if (!mouseButtonDown)

    {

        bool goSlew = (Options::useAnimatedSlewing() && !data->snapNextFocus()) &&

                      !(data->clock()->isManualMode() && data->clock()->isActive());

        if (goSlew)

        {

            double dX, dY;

            double maxstep = 10.0;

            if (Options::useAltAz())

            {

                dX = destination()->az().Degrees() - focus()->az().Degrees();

                dY = destination()->alt().Degrees() - focus()->alt().Degrees();

            }

            else

            {

                dX = destination()->ra().Degrees() - focus()->ra().Degrees();

                dY = destination()->dec().Degrees() - focus()->dec().Degrees();

            }


            //switch directions to go the short way around the celestial sphere, if necessary.

            dX = KSUtils::reduceAngle(dX, -180.0, 180.0);


            double r0 = sqrt(dX * dX + dY * dY);

            if (r0 < 20.0) //smaller slews have smaller maxstep

            {

                maxstep *= (10.0 + 0.5 * r0) / 20.0;

            }

            double step = 0.1;

            double r    = r0;

            while (r > step)

            {

                //DEBUG

                //qDebug() << step << ": " << r << ": " << r0 << endl;

                double fX = dX / r;

                double fY = dY / r;


                if (Options::useAltAz())

                {

                    focus()->setAlt(focus()->alt().Degrees() + fY * step);

                    focus()->setAz(dms(focus()->az().Degrees() + fX * step).reduce());

                    focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat());

                }

                else

                {

                    fX = fX / 15.; //convert RA degrees to hours

                    SkyPoint newFocus(focus()->ra().Hours() + fX * step, focus()->dec().Degrees() + fY * step);

                    setFocus(&newFocus);

                    focus()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

                }


                setSlewing(true);


                forceUpdate();

                qApp->processEvents(); //keep up with other stuff


                if (Options::useAltAz())

                {

                    dX = destination()->az().Degrees() - focus()->az().Degrees();

                    dY = destination()->alt().Degrees() - focus()->alt().Degrees();

                }

                else

                {

                    dX = destination()->ra().Degrees() - focus()->ra().Degrees();

                    dY = destination()->dec().Degrees() - focus()->dec().Degrees();

                }


                //switch directions to go the short way around the celestial sphere, if necessary.

                dX = KSUtils::reduceAngle(dX, -180.0, 180.0);

                r  = sqrt(dX * dX + dY * dY);


                //Modify step according to a cosine-shaped profile

                //centered on the midpoint of the slew

                //NOTE: don't allow the full range from -PI/2 to PI/2

                //because the slew will never reach the destination as

                //the speed approaches zero at the end!

                double t = dms::PI * (r - 0.5 * r0) / (1.05 * r0);

                step     = cos(t) * maxstep;

            }

        }


        //Either useAnimatedSlewing==false, or we have slewed, and are within one step of destination

        //set focus=destination.

        if (Options::useAltAz())

        {

            setFocusAltAz(destination()->alt(), destination()->az());

            focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat());

        }

        else

        {

            setFocus(destination());

            focus()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

        }


        setSlewing(false);


        //Turn off snapNextFocus, we only want it to happen once

        if (data->snapNextFocus())

        {

            data->setSnapNextFocus(false);

        }


        //Start the HoverTimer. if the user leaves the mouse in place after a slew,

        //we want to attach a label to the nearest object.

        if (Options::useHoverLabel())

            m_HoverTimer.start(HOVER_INTERVAL);


        forceUpdate();

    }

}


void SkyMapLite::slotClockSlewing()

{

    //If the current timescale exceeds slewTimeScale, set clockSlewing=true, and stop the clock.

    if ((fabs(data->clock()->scale()) > Options::slewTimeScale()) ^ clockSlewing)

    {

        data->clock()->setManualMode(!clockSlewing);

        clockSlewing = !clockSlewing;

        // don't change automatically the DST status

        KStarsLite *kstars = KStarsLite::Instance();

        if (kstars)

            kstars->updateTime(false);

    }

}


/*void SkyMapLite::updateFocus() {

    if( slewing )

        return;


    //Tracking on an object

    if ( Options::isTracking() && focusObject() != nullptr ) {

        if ( Options::useAltAz() ) {

            //Tracking any object in Alt/Az mode requires focus updates

            focusObject()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

            setFocusAltAz( focusObject()->alt(), focusObject()->az() );

            focus()->HorizontalToEquatorial( data->lst(), data->geo()->lat() );

            setDestination( *focus() );

        } else {

            //Tracking in equatorial coords

            setFocus( focusObject() );

            focus()->EquatorialToHorizontal( data->lst(), data->geo()->lat() );

            setDestination( *focus() );

        }


    //Tracking on empty sky

    } else if ( Options::isTracking() && focusPoint() != nullptr ) {

        if ( Options::useAltAz() ) {

            //Tracking on empty sky in Alt/Az mode

            setFocus( focusPoint() );

            focus()->EquatorialToHorizontal( data->lst(), data->geo()->lat() );

            setDestination( *focus() );

        }


    // Not tracking and not slewing, let sky drift by

    // This means that horizontal coordinates are constant.

    } else {

        focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat() );

    }

}*/


void SkyMapLite::resizeItem()

{

    if (parentItem())

    {

        setWidth(parentItem()->width());

        setHeight(parentItem()->height());

    }

    forceUpdate();

}


void SkyMapLite::slotZoomIn()

{

    setZoomFactor(Options::zoomFactor() * DZOOM);

}


void SkyMapLite::slotZoomOut()

{

    setZoomFactor(Options::zoomFactor() / DZOOM);

}


void SkyMapLite::slotZoomDefault()

{

    setZoomFactor(DEFAULTZOOM);

}


void SkyMapLite::slotSelectObject(SkyObject *skyObj)

{

    ClickedPoint  = *skyObj;

    ClickedObject = skyObj;

    /*if ( Options::useAltAz() ) {

        setDestinationAltAz( skyObj->altRefracted(), skyObj->az() );

    } else {

        setDestination( *skyObj );

    }*/

    //Update selected SkyObject (used in FindDialog, DetailDialog)

    m_ClickedObjectLite->setObject(skyObj);

    emit objectLiteChanged();

    slotCenter();

}


void SkyMapLite::setSkyRotation(double skyRotation)

{

    if (m_skyRotation != skyRotation)

    {

        m_skyRotation = skyRotation;

        emit skyRotationChanged(skyRotation);


        if (skyRotation >= 0 && skyRotation < 90)

        {

            m_skyMapOrientation = SkyMapOrientation::Top0;

        }

        else if (skyRotation >= 90 && skyRotation < 180)

        {

            m_skyMapOrientation = SkyMapOrientation::Right90;

        }

        else if (skyRotation >= 180 && skyRotation < 270)

        {

            m_skyMapOrientation = SkyMapOrientation::Bottom180;

        }

        else if (skyRotation >= 270 && skyRotation < 360)

        {

            m_skyMapOrientation = SkyMapOrientation::Left270;

        }

    }

}


void SkyMapLite::setZoomFactor(double factor)

{

    Options::setZoomFactor(KSUtils::clamp(factor, MINZOOM, MAXZOOM));


    forceUpdate();

    emit zoomChanged();

}


void SkyMapLite::forceUpdate()

{

    setupProjector();


    // We delay one draw cycle before re-indexing

    // we MUST ensure CLines do not get re-indexed while we use DRAW_BUF

    // so we do it here.

    //m_CLines->reindex( &m_reindexNum );

    // This queues re-indexing for the next draw cycle

    //m_reindexNum = KSNumbers( data->updateNum()->julianDay() );


    // This ensures that the JIT updates are synchronized for the entire draw

    // cycle so the sky moves as a single sheet.  May not be needed.

    data->syncUpdateIDs();


    SkyMesh *m_skyMesh = SkyMesh::Instance(3);

    if (m_skyMesh)

    {

        // prepare the aperture

        // FIXME_FOV: We may want to rejigger this to allow

        // wide-angle views --hdevalence

        double radius = m_proj->fov();

        if (radius > 180.0)

            radius = 180.0;


        if (m_skyMesh->inDraw())

        {

            printf("Warning: aborting concurrent SkyMapComposite::draw()\n");

            return;

        }


        //m_skyMesh->inDraw( true );

        m_skyMesh->aperture(&Focus, radius + 1.0, DRAW_BUF); // divide by 2 for testing


        // create the no-precess aperture if needed

        if (Options::showEquatorialGrid() || Options::showHorizontalGrid() || Options::showCBounds() ||

                Options::showEquator())

        {

            m_skyMesh->index(&Focus, radius + 1.0, NO_PRECESS_BUF);

        }

    }

    update();

}


void SkyMapLite::slotUpdateSky(bool now)

{

    Q_UNUSED(now);

    updateFocus();

    forceUpdate();

}


void SkyMapLite::updateFocus()

{

    if (getSlewing())

        return;


    //Tracking on an object

    if (Options::isTracking() && focusObject() != nullptr)

    {

        if (Options::useAltAz())

        {

            //Tracking any object in Alt/Az mode requires focus updates

            focusObject()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

            setFocusAltAz(focusObject()->alt(), focusObject()->az());

            focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat());

            setDestination(*focus());

        }

        else

        {

            //Tracking in equatorial coords

            setFocus(focusObject());

            focus()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

            setDestination(*focus());

        }


        //Tracking on empty sky

    }

    else if (Options::isTracking() && focusPoint() != nullptr)

    {

        if (Options::useAltAz())

        {

            //Tracking on empty sky in Alt/Az mode

            setFocus(focusPoint());

            focus()->EquatorialToHorizontal(data->lst(), data->geo()->lat());

            setDestination(*focus());

        }


        // Not tracking and not slewing, let sky drift by

        // This means that horizontal coordinates are constant.

    }

    else

    {

        focus()->HorizontalToEquatorial(data->lst(), data->geo()->lat());

    }

}


void SkyMapLite::setupProjector()

{

    //Update View Parameters for projection

    ViewParams p;

    p.focus         = focus();

    p.height        = height();

    p.width         = width();

    p.useAltAz      = Options::useAltAz();

    p.useRefraction = Options::useRefraction();

    p.zoomFactor    = Options::zoomFactor();

    p.rotationAngle = Options::skyRotation();

    p.fillGround    = Options::showGround();


    //Check if we need a new projector

    if (m_proj && Options::projection() == m_proj->type())

        m_proj->setViewParams(p);

    else

    {

        delete m_proj;

        switch (Options::projection())

        {

            case Projector::Gnomonic:

                m_proj = new GnomonicProjector(p);

                break;

            case Projector::Stereographic:

                m_proj = new StereographicProjector(p);

                break;

            case Projector::Orthographic:

                m_proj = new OrthographicProjector(p);

                break;

            case Projector::AzimuthalEquidistant:

                m_proj = new AzimuthalEquidistantProjector(p);

                break;

            case Projector::Equirectangular:

                m_proj = new EquirectangularProjector(p);

                break;

            case Projector::Lambert:

            default:

                //TODO: implement other projection classes

                m_proj = new LambertProjector(p);

                break;

        }

    }

}


void SkyMapLite::setZoomMouseCursor()

{

    mouseMoveCursor = false; // no mousemove cursor

    QBitmap cursor  = zoomCursorBitmap(2);

    QBitmap mask    = zoomCursorBitmap(4);

    setCursor(QCursor(cursor, mask));

}


void SkyMapLite::setDefaultMouseCursor()

{

    mouseMoveCursor = false; // no mousemove cursor

    QBitmap cursor  = defaultCursorBitmap(2);

    QBitmap mask    = defaultCursorBitmap(3);

    setCursor(QCursor(cursor, mask));

}


void SkyMapLite::setMouseMoveCursor()

{

    if (mouseButtonDown)

    {

        setCursor(Qt::SizeAllCursor); // cursor shape defined in qt

        mouseMoveCursor = true;

    }

}


bool SkyMapLite::isSlewing() const

{

    return (getSlewing() || (clockSlewing && data->clock()->isActive()));

}


int SkyMapLite::harvardToIndex(char c)

{

    // Convert spectral class to numerical index.

    // If spectral class is invalid return index for white star (A class)


    switch (c)

    {

        case 'o':

        case 'O':

            return 0;

        case 'b':

        case 'B':

            return 1;

        case 'a':

        case 'A':

            return 2;

        case 'f':

        case 'F':

            return 3;

        case 'g':

        case 'G':

            return 4;

        case 'k':

        case 'K':

            return 5;

        case 'm':

        case 'M':

            return 6;

        // For unknown spectral class assume A class (white star)

        default:

            return 2;

    }

}


QVector<QVector<QPixmap *>> SkyMapLite::getImageCache()

{

    return imageCache;

}


QSGTexture *SkyMapLite::textToTexture(QString text, QColor color, bool zoomFont)

{

    if (isInitialized)

    {

        QFont f;


        if (zoomFont)

        {

            f = SkyLabeler::Instance()->drawFont();

        }

        else

        {

            f = SkyLabeler::Instance()->stdFont();

        }


        qreal ratio = window()->effectiveDevicePixelRatio();


        QFontMetrics fm(f);


        int width  = fm.width(text);

        int height = fm.height();

        //        double rotation = 0;


        ////        switch(m_skyMapOrientation) {

        ////        case(SkyMapOrientation::Top0):

        ////            width = fm.width(text);

        ////            height = fm.height();

        ////            rotation = 0;

        ////            break;

        ////        case(SkyMapOrientation::Right90):

        ////            width = fm.height();

        ////            height = fm.width(text);

        ////            rotation = 90;

        ////        case(SkyMapOrientation::Bottom180):

        //////            width = ;

        //////            height = ;

        ////            rotation = 180;

        ////        case(SkyMapOrientation::Left270):

        //////            width = ;

        //////            height;

        ////            rotation = 270;

        ////        }


        f.setPointSizeF(f.pointSizeF() * ratio);


        QImage label((width)*ratio, (height)*ratio, QImage::Format_ARGB32_Premultiplied);


        label.fill(Qt::transparent);


        m_painter.begin(&label);


        m_painter.setFont(f);


        m_painter.setPen(color);


        //        m_painter.drawRect(0,0, label.width(), label.height());

        //        m_painter.rotate(getSkyRotation());

        m_painter.drawText(0, (height - fm.descent()) * ratio, text);


        m_painter.end();


        QSGTexture *texture = window()->createTextureFromImage(label, QQuickWindow::TextureCanUseAtlas);

        return texture;

    }

    else

    {

        return nullptr;

    }

}


void SkyMapLite::addFOVSymbol(const QString &FOVName, bool initialState)

{

    m_FOVSymbols.append(FOVName);

    //Emit signal whenever new value was added

    emit symbolsFOVChanged(m_FOVSymbols);


    m_FOVSymVisible.append(initialState);

}


bool SkyMapLite::isFOVVisible(int index)

{

    return m_FOVSymVisible.value(index);

}


void SkyMapLite::setFOVVisible(int index, bool visible)

{

    if (index >= 0 && index < m_FOVSymVisible.size())

    {

        m_FOVSymVisible[index] = visible;

        forceUpdate();

    }

}


void SkyMapLite::setSlewing(bool newSlewing)

{

    if (m_slewing != newSlewing)

    {

        m_slewing = newSlewing;

        emit slewingChanged(newSlewing);

    }

}


void SkyMapLite::setCenterLocked(bool centerLocked)

{

    m_centerLocked = centerLocked;

    emit centerLockedChanged(centerLocked);

}


void SkyMapLite::setAutomaticMode(bool automaticMode)

{

#if defined(Q_OS_ANDROID)

    if (m_automaticMode != automaticMode)

    {

        m_automaticMode = automaticMode;

        if (automaticMode)

        {

            m_deviceOrientation->startSensors();

            automaticModeTimer.start();

        }

        else

        {

            automaticModeTimer.stop();

            m_deviceOrientation->stopSensors();

        }

    }

#else

    Q_UNUSED(automaticMode);

#endif

}


void SkyMapLite::updateAutomaticMode()

{

#if defined(Q_OS_ANDROID)

    m_deviceOrientation->getOrientation();

    if (Options::useRefraction() && Options::useAltAz())

    {

        setFocusAltAz(SkyPoint::unrefract(dms(m_deviceOrientation->getAltitude())), dms(m_deviceOrientation->getAzimuth()));

    }

    else

    {

        setFocusAltAz(dms(m_deviceOrientation->getAltitude()), dms(m_deviceOrientation->getAzimuth()));

    }


    setSkyRotation(-1 * m_deviceOrientation->getRoll());

#endif

}


void SkyMapLite::initStarImages()

{

    if (isInitialized)

    {

        //Delete all existing pixmaps

        if (imageCache.length() != 0)

        {

            foreach (QVector<QPixmap *> vec, imageCache)

            {

                qDeleteAll(vec.begin(), vec.end());

            }

            clearTextures = true;

        }


        imageCache = QVector<QVector<QPixmap *>>(nSPclasses);


        QMap<char, QColor> ColorMap;

        const int starColorIntensity = Options::starColorIntensity();


        //On high-dpi screens star will look pixelized if don't multiply scaling factor by this ratio

        //Check PointNode::setNode() to see how it works

        qreal ratio = window()->effectiveDevicePixelRatio();


        switch (Options::starColorMode())

        {

            case 1: // Red stars.

                ColorMap.insert('O', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('B', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('A', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('F', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('G', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('K', QColor::fromRgb(255, 0, 0));

                ColorMap.insert('M', QColor::fromRgb(255, 0, 0));

                break;

            case 2: // Black stars.

                ColorMap.insert('O', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('B', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('A', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('F', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('G', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('K', QColor::fromRgb(0, 0, 0));

                ColorMap.insert('M', QColor::fromRgb(0, 0, 0));

                break;

            case 3: // White stars

                ColorMap.insert('O', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('B', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('A', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('F', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('G', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('K', QColor::fromRgb(255, 255, 255));

                ColorMap.insert('M', QColor::fromRgb(255, 255, 255));

            case 0:  // Real color

            default: // And use real color for everything else

                ColorMap.insert('O', QColor::fromRgb(0, 0, 255));

                ColorMap.insert('B', QColor::fromRgb(0, 200, 255));

                ColorMap.insert('A', QColor::fromRgb(0, 255, 255));

                ColorMap.insert('F', QColor::fromRgb(200, 255, 100));

                ColorMap.insert('G', QColor::fromRgb(255, 255, 0));

                ColorMap.insert('K', QColor::fromRgb(255, 100, 0));

                ColorMap.insert('M', QColor::fromRgb(255, 0, 0));

        }


        for (char color : ColorMap.keys())

        {

            //Add new spectral class


            QPixmap BigImage(15, 15);

            BigImage.fill(Qt::transparent);


            QPainter p;

            p.begin(&BigImage);


            if (Options::starColorMode() == 0)

            {

                qreal h, s, v, a;

                p.setRenderHint(QPainter::Antialiasing, false);

                QColor starColor = ColorMap[color];

                starColor.getHsvF(&h, &s, &v, &a);

                for (int i = 0; i < 8; i++)

                {

                    for (int j = 0; j < 8; j++)

                    {

                        qreal x    = i - 7;

                        qreal y    = j - 7;

                        qreal dist = sqrt(x * x + y * y) / 7.0;

                        starColor.setHsvF(h, qMin(qreal(1), dist < (10 - starColorIntensity) / 10.0 ? 0 : dist), v,

                                          qMax(qreal(0), dist < (10 - starColorIntensity) / 20.0 ? 1 : 1 - dist));

                        p.setPen(starColor);

                        p.drawPoint(i, j);

                        p.drawPoint((14 - i), j);

                        p.drawPoint(i, (14 - j));

                        p.drawPoint((14 - i), (14 - j));

                    }

                }

            }

            else

            {

                p.setRenderHint(QPainter::Antialiasing, true);

                p.setPen(QPen(ColorMap[color], 2.0));

                p.setBrush(p.pen().color());

                p.drawEllipse(QRectF(2, 2, 10, 10));

            }

            p.end();

            //[nSPclasses][nStarSizes];

            // Cache array slice


            QVector<QPixmap *> *pmap = &imageCache[harvardToIndex(color)];

            pmap->append(new QPixmap(BigImage));

            for (int size = 1; size < nStarSizes; size++)

            {

                pmap->append(new QPixmap(

                                 BigImage.scaled(size * ratio, size * ratio, Qt::KeepAspectRatio, Qt::SmoothTransformation)));

            }

        }

        //}

        starColorMode = Options::starColorMode();

    }

}


AzimuthalEquidistantProjector
Implememntation of Azimuthal equidistant projection
Definition azimuthalequidistantprojector.h:19

ClientManagerLite
Definition clientmanagerlite.h:41

EquirectangularProjector
Implememntation of Equirectangular projection
Definition equirectangularprojector.h:19

GeoLocation::lat
const CachingDms * lat() const
Definition geolocation.h:70

GnomonicProjector
Implememntation of Gnomonic projection
Definition gnomonicprojector.h:19

KStarsData
KStarsData is the backbone of KStars.
Definition kstarsdata.h:74

KStarsData::lst
CachingDms * lst()
Definition kstarsdata.h:226

KStarsData::snapNextFocus
bool snapNextFocus() const
Definition kstarsdata.h:270

KStarsData::clock
Q_INVOKABLE SimClock * clock()
Definition kstarsdata.h:220

KStarsData::geo
GeoLocation * geo()
Definition kstarsdata.h:232

KStarsData::setSnapNextFocus
void setSnapNextFocus(bool b=true)
Disable or re-enable the slewing animation for the next Focus change.
Definition kstarsdata.h:285

KStarsLite
This class loads QML files and connects SkyMapLite and KStarsData Unlike KStars class it is not a mai...
Definition kstarslite.h:47

KStarsLite::clientManagerLite
ClientManagerLite * clientManagerLite() const
Definition kstarslite.h:107

KStarsLite::updateTime
void updateTime(const bool automaticDSTchange=true)
Update time-dependent data and (possibly) repaint the sky map.
Definition kstarslite.cpp:234

KStarsLite::Instance
static KStarsLite * Instance()
Definition kstarslite.h:77

LambertProjector
Implememntation of Lambert azimuthal equal-area projection
Definition lambertprojector.h:19

OrthographicProjector
Implememntation of Orthographic projection
Definition orthographicprojector.h:19

Projector::setViewParams
void setViewParams(const ViewParams &p)
Update cached values for projector.
Definition projector.cpp:46

Projector::fov
double fov() const
Return the FOV of this projection.
Definition projector.cpp:88

Projector::type
virtual Q_INVOKABLE Projection type() const =0
Return the type of this projection.

RootNode
A QSGClipNode derived class used as a container for holding pointers to nodes and for clipping.
Definition rootnode.h:60

RootNode::update
void update(bool clearTextures=false)
update positions of all child SkyItems
Definition rootnode.cpp:216

SimClock::scale
double scale() const
Definition simclock.h:51

SimClock::isActive
Q_INVOKABLE bool isActive()
Whether the clock is active or not is a bit complicated by the introduction of "manual mode".
Definition simclock.cpp:128

SimClock::setManualMode
void setManualMode(bool on=true)
Sets Manual Mode on/off according to the bool argument.
Definition simclock.cpp:66

SimClock::isManualMode
bool isManualMode() const
Manual Mode is a new (04/2002) addition to the SimClock.
Definition simclock.h:69

SkyMapLite
This is the main item that displays all SkyItems.
Definition skymaplite.h:59

SkyMapLite::setZoomFactor
void setZoomFactor(double factor)
@ Set zoom factor.
Definition skymaplite.cpp:631

SkyMapLite::setAutomaticMode
Q_INVOKABLE void setAutomaticMode(bool automaticMode)
switch automatic mode on/off according to isOn parameter
Definition skymaplite.cpp:957

SkyMapLite::setCenterLocked
void setCenterLocked(bool centerLocked)
sets whether SkyMapLite is centered on an object and locked(olny pinch-to-zoom is available)
Definition skymaplite.cpp:951

SkyMapLite::createInstance
static SkyMapLite * createInstance()
Creates instance of SkyMapLite (delete the old one if any)
Definition skymaplite.cpp:215

SkyMapLite::slotCenter
void slotCenter()
Center the display at the point ClickedPoint.
Definition skymaplite.cpp:327

SkyMapLite::updateFocus
void updateFocus()
Update the focus position according to current options.
Definition skymaplite.cpp:690

SkyMapLite::slewFocus
void slewFocus()
Step the Focus point toward the Destination point.
Definition skymaplite.cpp:401

SkyMapLite::textToTexture
QSGTexture * textToTexture(QString text, QColor color=QColor(255, 255, 255), bool zoomFont=false)
creates QImage from text and converts it to QSGTexture
Definition skymaplite.cpp:849

SkyMapLite::symbolsFOVChanged
void symbolsFOVChanged(QStringList)
Emitted when FOVSymbols list was changed (new value appended)

SkyMapLite::harvardToIndex
int harvardToIndex(char c)
Returns index for a Harvard spectral classification.
Definition skymaplite.cpp:810

SkyMapLite::focus
SkyPoint * focus()
Retrieve the Focus point; the position on the sky at the center of the skymap.
Definition skymaplite.h:125

SkyMapLite::~SkyMapLite
~SkyMapLite()
Destructor.
Definition skymaplite.cpp:241

SkyMapLite::centerLocked
bool centerLocked
true if SkyMapLite is centered on an object and only pinch-to-zoom needs to be available
Definition skymaplite.h:74

SkyMapLite::slotSelectObject
void slotSelectObject(SkyObject *skyObj)
centres skyObj in SkyMap and opens context drawer with skyObj Used in FindDialogLite
Definition skymaplite.cpp:590

SkyMapLite::setDestination
void setDestination(const SkyPoint &f)
sets the destination point of the sky map.
Definition skymaplite.cpp:278

SkyMapLite::forceUpdate
void forceUpdate()
Recalculates the positions of objects in the sky, and then repaints the sky map.
Definition skymaplite.cpp:639

SkyMapLite::destinationChanged
void destinationChanged()
Emitted by setDestination(), and connected to slewFocus().

SkyMapLite::getImageCache
QVector< QVector< QPixmap * > > getImageCache()
returns cache of star images
Definition skymaplite.cpp:844

SkyMapLite::setClickedObject
void setClickedObject(SkyObject *o)
Set the ClickedObject pointer to the argument.
Definition skymaplite.cpp:312

SkyMapLite::slotZoomIn
void slotZoomIn()
Zoom in one step.
Definition skymaplite.cpp:575

SkyMapLite::focusPoint
SkyPoint * focusPoint()
retrieve the FocusPoint position.
Definition skymaplite.h:149

SkyMapLite::getCachedTexture
QSGTexture * getCachedTexture(int size, char spType)
returns cached texture from textureCache.
Definition skymaplite.cpp:210

SkyMapLite::zoomChanged
void zoomChanged()
Emitted when zoom level is changed.

SkyMapLite::initStarImages
void initStarImages()
Initializes images of Stars and puts them in cache (copied from SkyQPainter)
Definition skymaplite.cpp:996

SkyMapLite::slewingChanged
void slewingChanged(bool)
Emitted when SkyMapLite is being slewed or slewing is finished.

SkyMapLite::slotClockSlewing
void slotClockSlewing()
Checks whether the timestep exceeds a threshold value.
Definition skymaplite.cpp:516

SkyMapLite::getSlewing
bool getSlewing() const
Proxy method for SkyMapDrawAbstract::drawObjectLabels()
Definition skymaplite.h:422

SkyMapLite::setFocusPoint
void setFocusPoint(SkyPoint *f)
set the FocusPoint; the position that is to be the next Destination.
Definition skymaplite.h:204

SkyMapLite::objectLiteChanged
void objectLiteChanged()
Wrapper of ClickedObject for QML.

SkyMapLite::mousePointChanged
void mousePointChanged(SkyPoint *)
Emitted when position under mouse changed.

SkyMapLite::slotUpdateSky
void slotUpdateSky(bool now)
Update the focus point and call forceUpdate()
Definition skymaplite.cpp:683

SkyMapLite::addFOVSymbol
Q_INVOKABLE void addFOVSymbol(const QString &FOVName, bool initialState=false)
adds FOV symbol to m_FOVSymbols
Definition skymaplite.cpp:919

SkyMapLite::setDestinationAltAz
void setDestinationAltAz(const dms &alt, const dms &az, bool altIsRefracted)
sets the destination point of the sky map, using its alt/az coordinates.
Definition skymaplite.cpp:290

SkyMapLite::destination
SkyPoint * destination()
retrieve the Destination position.
Definition skymaplite.h:135

SkyMapLite::updatePaintNode
virtual QSGNode * updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData) override
Updates SkyMapLite by calling RootNode::update(), which in turn initiates update of all child nodes.
Definition skymaplite.cpp:143

SkyMapLite::clickedPoint
SkyPoint * clickedPoint()
Retrieve the ClickedPoint position.
Definition skymaplite.h:217

SkyMapLite::slotZoomDefault
void slotZoomDefault()
Set default zoom.
Definition skymaplite.cpp:585

SkyMapLite::skyRotationChanged
void skyRotationChanged(double skyRotation)
Emitted when skyRotation used to rotate coordinates of SkyPoints is changed.

SkyMapLite::setClickedPoint
void setClickedPoint(SkyPoint *f)
Set the ClickedPoint to the skypoint given as an argument.
Definition skymaplite.cpp:306

SkyMapLite::isSlewing
bool isSlewing() const
Definition skymaplite.cpp:805

SkyMapLite::initialize
void initialize(QQuickItem *parent)
Bind size to parent's size and initialize star images.
Definition skymaplite.cpp:222

SkyMapLite::setFocusAltAz
void setFocusAltAz(const dms &alt, const dms &az)
sets the focus point of the sky map, using its alt/az coordinates
Definition skymaplite.cpp:266

SkyMapLite::deleteSkyNode
void deleteSkyNode(SkyNode *skyNode)
skyNode will be deleted on the next call to updatePaintNode (currently used only in StarNode(struct i...
Definition skymaplite.cpp:205

SkyMapLite::setFocusObject
void setFocusObject(SkyObject *o)
Set the FocusObject pointer to the argument.
Definition skymaplite.cpp:318

SkyMapLite::setupProjector
void setupProjector()
Call to set up the projector before update of SkyItems positions begins.
Definition skymaplite.cpp:735

SkyMapLite::isFOVVisible
bool isFOVVisible(int index)
Definition skymaplite.cpp:928

SkyMapLite::setSlewing
void setSlewing(bool newSlewing)
sets whether SkyMapLite is being slewed
Definition skymaplite.cpp:942

SkyMapLite::setFOVVisible
Q_INVOKABLE void setFOVVisible(int index, bool visible)
updates visibility of FOV symbol according to visible
Definition skymaplite.cpp:933

SkyMapLite::focusObject
SkyObject * focusObject() const
Retrieve the object which is centered in the sky map.
Definition skymaplite.h:252

SkyMapLite::resizeItem
void resizeItem()
Called whenever wrappers' width or height are changed.
Definition skymaplite.cpp:565

SkyMapLite::slotZoomOut
void slotZoomOut()
Zoom out one step.
Definition skymaplite.cpp:580

SkyMapLite::setFocus
void setFocus(SkyPoint *f)
sets the central focus point of the sky map.
Definition skymaplite.cpp:252

SkyMapLite::deleteLimit
static double deleteLimit()
return limit of hides for the node to delete it
Definition skymaplite.cpp:199

SkyMapLite::updateAutomaticMode
void updateAutomaticMode()
updates focus of SkyMapLite according to data from DeviceOrientation (Smartphone's sensors)
Definition skymaplite.cpp:979

SkyMesh
Provides an interface to the Hierarchical Triangular Mesh (HTM) library written by A.
Definition skymesh.h:74

SkyMesh::Instance
static SkyMesh * Instance()
returns the default instance of SkyMesh or null if it has not yet been created.
Definition skymesh.cpp:39

SkyMesh::aperture
void aperture(SkyPoint *center, double radius, MeshBufNum_t bufNum=DRAW_BUF)
finds the set of trixels that cover the circular aperture specified after first performing a reverse ...
Definition skymesh.cpp:56

SkyMesh::index
Trixel index(const SkyPoint *p)
returns the index of the trixel containing p.
Definition skymesh.cpp:74

SkyNode
Provides virtual functions for update of coordinates and nodes hiding.
Definition skynode.h:28

SkyObjectLite
Wrapper for SkyObject to allow access of some of its properties from QML.
Definition skyobjectlite.h:21

SkyObjectLite::setObject
void setObject(SkyObject *object)
sets SkyObject that is needed to be wrapped
Definition skyobjectlite.cpp:11

SkyObject
Provides all necessary information about an object in the sky: its coordinates, name(s),...
Definition skyobject.h:42

SkyObject::name
virtual QString name(void) const
Definition skyobject.h:146

SkyPointLite
Wrapper for SkyPoint to allow access of some of its properties from QML.
Definition skypointlite.h:22

SkyPointLite::setPoint
void setPoint(SkyPoint *point)
sets SkyPoint that is needed to be wrapped
Definition skypointlite.cpp:12

SkyPoint::altCrit
static const double altCrit
Critical height for atmospheric refraction corrections.
Definition skypoint.h:727

SkyPoint::EquatorialToHorizontal
void EquatorialToHorizontal(const CachingDms *LST, const CachingDms *lat)
Determine the (Altitude, Azimuth) coordinates of the SkyPoint from its (RA, Dec) coordinates,...
Definition skypoint.cpp:77

SkyPoint::unrefract
static double unrefract(const double alt, bool conditional=true)
Remove refraction correction, depending on conditional.
Definition skypoint.cpp:1091

StereographicProjector
Implememntation of Stereographic projection
Definition stereographicprojector.h:19

TelescopeLite
device handle controlling telescope.
Definition inditelescopelite.h:27

TelescopeSymbolsItem::addTelescope
void addTelescope(INDI::BaseDevice *bd)
Add telescope symbol for device bd.
Definition telescopesymbolsitem.cpp:25

TelescopeSymbolsItem::removeTelescope
void removeTelescope(INDI::BaseDevice *bd)
Remove telescope symbol of device bd.
Definition telescopesymbolsitem.cpp:36

ViewParams
This is just a container that holds information needed to do projections.
Definition projector.h:37

ViewParams::fillGround
bool fillGround
If the ground is filled, then points below horizon are invisible.
Definition projector.h:44

dms::PI
static constexpr double PI
PI is a const static member; it's public so that it can be used anywhere, as long as dms....
Definition dms.h:385

i18n
QString i18n(const char *text, const TYPE &arg...)

QBitmap

QColor

QColor::fromRgb
QColor fromRgb(QRgb rgb)

QColor::getHsvF
void getHsvF(float *h, float *s, float *v, float *a) const const

QColor::setHsvF
void setHsvF(float h, float s, float v, float a)

QCursor

QFont

QFontMetrics

QFontMetrics::descent
int descent() const const

QFontMetrics::height
int height() const const

QImage

QImage::Format_ARGB32_Premultiplied
Format_ARGB32_Premultiplied

QList::append
void append(QList< T > &&value)

QList::begin
iterator begin()

QList::clear
void clear()

QList::count
qsizetype count() const const

QList::end
iterator end()

QList::size
qsizetype size() const const

QList::value
T value(qsizetype i) const const

QMap

QObject::connect
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

QPainter

QPainter::Antialiasing
Antialiasing

QPainter::begin
bool begin(QPaintDevice *device)

QPainter::drawEllipse
void drawEllipse(const QPoint &center, int rx, int ry)

QPainter::drawLine
void drawLine(const QLine &line)

QPainter::drawPoint
void drawPoint(const QPoint &position)

QPainter::drawText
void drawText(const QPoint &position, const QString &text)

QPainter::end
bool end()

QPainter::pen
const QPen & pen() const const

QPainter::setBrush
void setBrush(Qt::BrushStyle style)

QPainter::setFont
void setFont(const QFont &font)

QPainter::setPen
void setPen(Qt::PenStyle style)

QPainter::setRenderHint
void setRenderHint(RenderHint hint, bool on)

QPen

QPen::color
QColor color() const const

QPixmap

QPixmap::fill
void fill(const QColor &color)

QPixmap::scaled
QPixmap scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode, Qt::TransformationMode transformMode) const const

QQuickItem

QQuickItem::cursor
QCursor cursor() const const

QQuickItem::heightChanged
void heightChanged()

QQuickItem::parent
parent

QQuickItem::setCursor
void setCursor(const QCursor &cursor)

QQuickItem::size
QSizeF size() const const

QQuickItem::update
void update()

QQuickItem::visible
visible

QQuickItem::widthChanged
void widthChanged()

QQuickItem::window
QQuickWindow * window() const const

QQuickItem::x
x

QQuickItem::y
y

QQuickWindow::TextureCanUseAtlas
TextureCanUseAtlas

QQuickWindow::createTextureFromImage
QSGTexture * createTextureFromImage(const QImage &image) const const

QQuickWindow::effectiveDevicePixelRatio
qreal effectiveDevicePixelRatio() const const

QRectF

QSGNode

QSGTexture

QString

QString::fill
QString & fill(QChar ch, qsizetype size)

Qt::KeepAspectRatio
KeepAspectRatio

Qt::SizeAllCursor
SizeAllCursor

Qt::color0
color0

Qt::AllButtons
AllButtons

Qt::SmoothTransformation
SmoothTransformation

QtFuture::connect
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)

QTimer::start
void start()

QVector