15670918640

Committed 16 Jun 2025 02:08AM UTC coverage: 11.775% (-0.2%) from 11.931%

Build # 15670918640

Build Type

push

github

Committed by

alex-w

Commit Message

Updated data

Run Details

14700 of 124846 relevant lines covered (11.77%)

18324.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/core/StelSkyLayerMgr.cpp

/*
 * Stellarium
 * Copyright (C) 2008 Fabien Chereau
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#include "StelSkyLayerMgr.hpp"
#include "StelApp.hpp"
#include "StelCore.hpp"
#include "StelFileMgr.hpp"
#include "StelSkyImageTile.hpp"
#include "StelModuleMgr.hpp"
#include "StelPainter.hpp"
#include "MilkyWay.hpp"
#include "StelTranslator.hpp"
#include "StelProgressController.hpp"

#include <QNetworkAccessManager>
#include <stdexcept>
#include <QDebug>
#include <QString>
#include <QVariantMap>
#include <QVariantList>
#include <QDir>
#include <QSettings>

StelSkyLayerMgr::StelSkyLayerMgr(void) : flagShow(true)
{
        setObjectName("StelSkyLayerMgr");
}

StelSkyLayerMgr::~StelSkyLayerMgr()
{
        for (auto* s : std::as_const(allSkyLayers))
                delete s;
}

/*************************************************************************
 Reimplementation of the getCallOrder method
*************************************************************************/
double StelSkyLayerMgr::getCallOrder(StelModuleActionName actionName) const
{
        if (actionName==StelModule::ActionDraw)
                return GETSTELMODULE(MilkyWay)->getCallOrder(actionName)+5;
        return 0;
}

// read from stream
void StelSkyLayerMgr::init()
{
        QSettings* conf = StelApp::getInstance().getSettings();
        const int decimation=conf->value("astro/nebula_texture_decimation", 1).toInt();
        loadCollection(decimation);

        conf->beginGroup("skylayers");
        for (const auto& key : conf->childKeys())
        {
                QString uri = conf->value(key, "").toString();
                if (!uri.isEmpty())
                {
                        if (key=="clilayer")
                                insertSkyImage(uri, "Command-line layer");
                        else
                                insertSkyImage(uri);
                }
        }
        conf->endGroup();

        setFlagShow(!conf->value("astro/flag_nebula_display_no_texture", false).toBool());
        addAction("actionShow_DSO_Textures", N_("Display Options"), N_("Deep-sky objects background images"), "flagShow", "I");
        addAction("actionShow_DSO_Textures_Reload", N_("Display Options"), N_("Reload the deep-sky objects background images"), "loadCollection()", "Ctrl+I");
}

void StelSkyLayerMgr::loadCollection(int decimateBy)
{
        if (!allSkyLayers.isEmpty())
                allSkyLayers.clear();

        QString path = StelFileMgr::findFile("nebulae/default/textures.json");
        if (path.isEmpty())
                qWarning() << "ERROR while loading nebula texture set default";
        else
                insertSkyImage(path, QString(), true, decimateBy);

#ifdef USE_STATIC_PLUGIN_NEBULATEXTURES
        // [NebulaTextures] The custom textures need to be loaded synchronously at the program startup in order to take effect
        QSettings* conf = StelApp::getInstance().getSettings();
        if(conf->value("plugins_load_at_startup/NebulaTextures", false).toBool()){
                path = StelFileMgr::findFile(StelFileMgr::getUserDir()+"/modules/NebulaTextures/custom_textures.json");
                if (path.isEmpty())
                        qWarning() << "[NebulaTextures] Custom Nebula Textures doesn't exist.";
                else
                        insertSkyImage(path, QString(), true, decimateBy);
        }
#endif
}

QString StelSkyLayerMgr::insertSkyLayer(StelSkyLayerP tile, const QString& keyHint, bool ashow)
{
        SkyLayerElem* bEl = new SkyLayerElem(tile, ashow);
        QString key = tile->getKeyHint();
        if (key.isEmpty() || key=="no name")
        {
                if (!keyHint.isEmpty())
                {
                        key = keyHint;
                }
                else
                {
                        key = "no name";
                }
        }
        if (allSkyLayers.contains(key))
        {
                QString suffix = "_01";
                int i=1;
                while (allSkyLayers.contains(key+suffix))
                {
                        suffix=QString("_%1").arg(i);
                        ++i;
                }
                key+=suffix;
        }
        allSkyLayers.insert(key,bEl);
        connect(bEl->layer.data(), SIGNAL(loadingStateChanged(bool)), this, SLOT(loadingStateChanged(bool)));
        connect(bEl->layer.data(), SIGNAL(percentLoadedChanged(int)), this, SLOT(percentLoadedChanged(int)));
        return key;
}

// Add a new image from its URI (URL or local file name)
QString StelSkyLayerMgr::insertSkyImage(const QString& uri, const QString& keyHint, bool ashow, int decimateBy)
{
        return insertSkyLayer(StelSkyLayerP(new StelSkyImageTile(uri, Q_NULLPTR, decimateBy)), keyHint, ashow);
}

// Remove a sky image tile from the list of background images
void StelSkyLayerMgr::removeSkyLayer(const QString& key)
{
        //qDebug() << "StelSkyLayerMgr::removeSkyImage removing image:" << key;
        if (allSkyLayers.contains(key))
        {
                SkyLayerElem* bEl = allSkyLayers[key];
                disconnect(bEl->layer.data(), SIGNAL(loadingStateChanged(bool)), this, SLOT(loadingStateChanged(bool)));
                disconnect(bEl->layer.data(), SIGNAL(percentLoadedChanged(int)), this, SLOT(percentLoadedChanged(int)));
                delete bEl;
                allSkyLayers.remove(key);
        }
        else
        {
                qDebug() << "StelSkyLayerMgr::removeSkyLayer there is no such key" << key << "nothing is removed";
        }
}

// Remove a sky image tile from the list of background images
void StelSkyLayerMgr::removeSkyLayer(StelSkyLayerP l)
{
        const QString k = keyForLayer(l.data());
        if (!k.isEmpty())
                removeSkyLayer(k);
}

// Draw all the multi-res images collection
void StelSkyLayerMgr::draw(StelCore* core)
{
        if (!flagShow)
                return;

        StelPainter sPainter(core->getProjection(StelCore::FrameJ2000));
        sPainter.setBlending(true, GL_ONE, GL_ONE); //additive blending
        for (auto* s : std::as_const(allSkyLayers))
        {
                if (s->show) 
                {
                        sPainter.setProjector(core->getProjection(s->layer->getFrameType()));
                        s->layer->draw(core, sPainter, 1.);
                }
        }
}

void noDelete(StelSkyLayer*) {}

// Called when loading of data started or stopped for one collection
void StelSkyLayerMgr::loadingStateChanged(bool b)
{
        StelSkyLayer* tile = qobject_cast<StelSkyLayer*>(QObject::sender());
        Q_ASSERT(tile!=Q_NULLPTR);
        SkyLayerElem* elem = skyLayerElemForLayer(tile);
        Q_ASSERT(elem!=Q_NULLPTR);
        if (b)
        {
                Q_ASSERT(elem->progressBar==Q_NULLPTR);
                elem->progressBar = StelApp::getInstance().addProgressBar();
                QString serverStr = elem->layer->getShortServerCredits();
                QString shortName = elem->layer->getShortName();
                if (serverStr.isEmpty())
                {
                        // TRANSLATORS: The full phrase is "Loading '%SHORT_NAME%'" in progress bar
                        elem->progressBar->setFormat(q_("Loading '%1'").arg(shortName));
                }
                else
                {
                        // TRANSLATORS: The full phrase is "Loading '%SHORT_NAME%' from %URL%" in progress bar
                        elem->progressBar->setFormat(q_("Loading '%1' from %2").arg(shortName, serverStr));
                }
                elem->progressBar->setRange(0,100);
        }
        else
        {
                Q_ASSERT(elem->progressBar!=Q_NULLPTR);
                StelApp::getInstance().removeProgressBar(elem->progressBar);
                elem->progressBar = Q_NULLPTR;
                emit collectionLoaded();
        }
}

// Called when the percentage of loading tiles/tiles to be displayed changed for one collection
void StelSkyLayerMgr::percentLoadedChanged(int percentage)
{
        StelSkyLayer* tile = qobject_cast<StelSkyLayer*>(QObject::sender());
        Q_ASSERT(tile!=Q_NULLPTR);
        SkyLayerElem* elem = skyLayerElemForLayer(tile);
        Q_ASSERT(elem!=Q_NULLPTR);
        Q_ASSERT(elem->progressBar!=Q_NULLPTR);
        elem->progressBar->setValue(percentage);
}

StelSkyLayerMgr::SkyLayerElem* StelSkyLayerMgr::skyLayerElemForLayer(const StelSkyLayer* t)
{
    for (auto* e : std::as_const(allSkyLayers))
        {
                if (e->layer==t)
                {
                        return e;
                }
        }
        return Q_NULLPTR;
}

QString StelSkyLayerMgr::keyForLayer(const StelSkyLayer* t)
{
        return allSkyLayers.key(skyLayerElemForLayer(t));
}

StelSkyLayerMgr::SkyLayerElem::SkyLayerElem(StelSkyLayerP t, bool ashow) : layer(t), progressBar(Q_NULLPTR), show(ashow)
{}

StelSkyLayerMgr::SkyLayerElem::~SkyLayerElem()
{
        if (progressBar)
                StelApp::getInstance().removeProgressBar(progressBar);
        progressBar = Q_NULLPTR;
}

bool StelSkyLayerMgr::loadSkyImage(const QString& id, const QString& filename,
                                   double long0, double lat0,
                                   double long1, double lat1,
                                   double long2, double lat2,
                                   double long3, double lat3,
                                   double minRes, double maxBright,
                                   bool visible, StelCore::FrameType frameType,
                                   bool withAberration, int decimateBy)
{
        Q_UNUSED(decimateBy)
        if (allSkyLayers.contains(id))
        {
                qWarning() << "Image ID" << id << "already exists, removing old image before loading";
                removeSkyLayer(id);
        }

        QString path = StelFileMgr::findFile(filename);
        if (path.isEmpty())
        {
                qWarning() << "Could not find image" << QDir::toNativeSeparators(filename);
                return false;
        }
        QVariantMap vm;
        QVariantList cl; // coordinates list for adding worldCoords and textureCoords
        QVariantList c;  // a list for a pair of coordinates
        QVariantList ol; // outer list - we want a structure 3 levels deep...
        vm["imageUrl"] = QVariant(path);
        vm["maxBrightness"] = QVariant(maxBright);
        vm["minResolution"] = QVariant(minRes);
        vm["shortName"] = QVariant(id);
        vm["withAberration"] = QVariant(withAberration);

        // textureCoords (define the ordering of worldCoords)
        cl.clear();
        ol.clear();
        c.clear(); c.append(0); c.append(0); cl.append(QVariant(c));
        c.clear(); c.append(1); c.append(0); cl.append(QVariant(c));
        c.clear(); c.append(1); c.append(1); cl.append(QVariant(c));
        c.clear(); c.append(0); c.append(1); cl.append(QVariant(c));
        ol.append(QVariant(cl));
        vm["textureCoords"] = ol;

        // world coordinates
        cl.clear();
        ol.clear();
        c.clear(); c.append(long0); c.append(lat0); cl.append(QVariant(c));
        c.clear(); c.append(long1); c.append(lat1); cl.append(QVariant(c));
        c.clear(); c.append(long2); c.append(lat2); cl.append(QVariant(c));
        c.clear(); c.append(long3); c.append(lat3); cl.append(QVariant(c));
        ol.append(QVariant(cl));
        vm["worldCoords"] = ol;

        vm["alphaBlend"] = true; // new 2017-3: Make black correctly see-through.

        StelSkyLayerP tile = StelSkyLayerP(new StelSkyImageTile(vm, Q_NULLPTR));
        tile->setFrameType(frameType);
        
        try
        {
                QString key = insertSkyLayer(tile, filename, visible);
                if (key == id)
                        return true;
                else
                        return false;
        }
        catch (std::runtime_error& e)
        {
                qWarning() << e.what();
                return false;
        }
}

void StelSkyLayerMgr::showLayer(const QString& id, bool b)
{
        if (allSkyLayers.contains(id))
        {
                if (allSkyLayers[id]!=Q_NULLPTR)
                        allSkyLayers[id]->show = b;
        }
}

bool StelSkyLayerMgr::getShowLayer(const QString& id) const
{
        if (allSkyLayers.contains(id))
        {
                if (allSkyLayers[id]!=Q_NULLPTR)
                        return allSkyLayers[id]->show;
        }
        return false;
}


//! Get the list of all the currently loaded layers.
QMap<QString, StelSkyLayerP> StelSkyLayerMgr::getAllSkyLayers() const
{
        QMap<QString, StelSkyLayerP> res;
        for (QMap<QString, StelSkyLayerMgr::SkyLayerElem*>::ConstIterator iter=allSkyLayers.constBegin();iter!=allSkyLayers.constEnd();++iter)
        {
                //qDebug() << iter.key() << iter.value()->layer->getShortName();
                res.insert(iter.key(), iter.value()->layer);
        }
        return res;
}

StelSkyLayerP StelSkyLayerMgr::getSkyLayer(const QString& key) const
{
        if (allSkyLayers.contains(key))
                return allSkyLayers[key]->layer;
        return StelSkyLayerP();
}

1	/*
2	* Stellarium
3	* Copyright (C) 2008 Fabien Chereau
4	*
5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of the GNU General Public License
7	* as published by the Free Software Foundation; either version 2
8	* of the License, or (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
18	*/
19
20	#include "StelSkyLayerMgr.hpp"
21	#include "StelApp.hpp"
22	#include "StelCore.hpp"
23	#include "StelFileMgr.hpp"
24	#include "StelSkyImageTile.hpp"
25	#include "StelModuleMgr.hpp"
26	#include "StelPainter.hpp"
27	#include "MilkyWay.hpp"
28	#include "StelTranslator.hpp"
29	#include "StelProgressController.hpp"
30
31	#include <QNetworkAccessManager>
32	#include <stdexcept>
33	#include <QDebug>
34	#include <QString>
35	#include <QVariantMap>
36	#include <QVariantList>
37	#include <QDir>
38	#include <QSettings>
39
40	StelSkyLayerMgr::StelSkyLayerMgr(void) : flagShow(true)	×
41	{
42	setObjectName("StelSkyLayerMgr");	×
43	}	×
44
45	StelSkyLayerMgr::~StelSkyLayerMgr()	×
46	{
47	for (auto* s : std::as_const(allSkyLayers))	×
48	delete s;	×
49	}	×
50
51	/*************************************************************************
52	Reimplementation of the getCallOrder method
53	*************************************************************************/
54	double StelSkyLayerMgr::getCallOrder(StelModuleActionName actionName) const	×
55	{
56	if (actionName==StelModule::ActionDraw)	×
57	return GETSTELMODULE(MilkyWay)->getCallOrder(actionName)+5;	×
58	return 0;	×
59	}
60
61	// read from stream
62	void StelSkyLayerMgr::init()	×
63	{
64	QSettings* conf = StelApp::getInstance().getSettings();	×
65	const int decimation=conf->value("astro/nebula_texture_decimation", 1).toInt();	×
66	loadCollection(decimation);	×
67
68	conf->beginGroup("skylayers");	×
69	for (const auto& key : conf->childKeys())	×
70	{
71	QString uri = conf->value(key, "").toString();	×
72	if (!uri.isEmpty())	×
73	{
74	if (key=="clilayer")	×
75	insertSkyImage(uri, "Command-line layer");	×
76	else
77	insertSkyImage(uri);	×
78	}
79	}	×
80	conf->endGroup();	×
81
82	setFlagShow(!conf->value("astro/flag_nebula_display_no_texture", false).toBool());	×
83	addAction("actionShow_DSO_Textures", N_("Display Options"), N_("Deep-sky objects background images"), "flagShow", "I");	×
84	addAction("actionShow_DSO_Textures_Reload", N_("Display Options"), N_("Reload the deep-sky objects background images"), "loadCollection()", "Ctrl+I");	×
85	}	×
86
87	void StelSkyLayerMgr::loadCollection(int decimateBy)	×
88	{
89	if (!allSkyLayers.isEmpty())	×
90	allSkyLayers.clear();	×
91
92	QString path = StelFileMgr::findFile("nebulae/default/textures.json");	×
93	if (path.isEmpty())	×
94	qWarning() << "ERROR while loading nebula texture set default";	×
95	else
96	insertSkyImage(path, QString(), true, decimateBy);	×
97
98	#ifdef USE_STATIC_PLUGIN_NEBULATEXTURES
99	// [NebulaTextures] The custom textures need to be loaded synchronously at the program startup in order to take effect
100	QSettings* conf = StelApp::getInstance().getSettings();	×
101	if(conf->value("plugins_load_at_startup/NebulaTextures", false).toBool()){	×
102	path = StelFileMgr::findFile(StelFileMgr::getUserDir()+"/modules/NebulaTextures/custom_textures.json");	×
103	if (path.isEmpty())	×
104	qWarning() << "[NebulaTextures] Custom Nebula Textures doesn't exist.";	×
105	else
106	insertSkyImage(path, QString(), true, decimateBy);	×
107	}
108	#endif
109	}	×
110
111	QString StelSkyLayerMgr::insertSkyLayer(StelSkyLayerP tile, const QString& keyHint, bool ashow)	×
112	{
113	SkyLayerElem* bEl = new SkyLayerElem(tile, ashow);	×
114	QString key = tile->getKeyHint();	×
115	if (key.isEmpty() \|\| key=="no name")	×
116	{
117	if (!keyHint.isEmpty())	×
118	{
119	key = keyHint;	×
120	}
121	else
122	{
123	key = "no name";	×
124	}
125	}
126	if (allSkyLayers.contains(key))	×
127	{
128	QString suffix = "_01";	×
129	int i=1;	×
130	while (allSkyLayers.contains(key+suffix))	×
131	{
132	suffix=QString("_%1").arg(i);	×
133	++i;	×
134	}
135	key+=suffix;	×
136	}	×
137	allSkyLayers.insert(key,bEl);	×
138	connect(bEl->layer.data(), SIGNAL(loadingStateChanged(bool)), this, SLOT(loadingStateChanged(bool)));	×
139	connect(bEl->layer.data(), SIGNAL(percentLoadedChanged(int)), this, SLOT(percentLoadedChanged(int)));	×
140	return key;	×
141	}	×
142
143	// Add a new image from its URI (URL or local file name)
144	QString StelSkyLayerMgr::insertSkyImage(const QString& uri, const QString& keyHint, bool ashow, int decimateBy)	×
145	{
146	return insertSkyLayer(StelSkyLayerP(new StelSkyImageTile(uri, Q_NULLPTR, decimateBy)), keyHint, ashow);	×
147	}
148
149	// Remove a sky image tile from the list of background images
150	void StelSkyLayerMgr::removeSkyLayer(const QString& key)	×
151	{
152	//qDebug() << "StelSkyLayerMgr::removeSkyImage removing image:" << key;
153	if (allSkyLayers.contains(key))	×
154	{
155	SkyLayerElem* bEl = allSkyLayers[key];	×
156	disconnect(bEl->layer.data(), SIGNAL(loadingStateChanged(bool)), this, SLOT(loadingStateChanged(bool)));	×
157	disconnect(bEl->layer.data(), SIGNAL(percentLoadedChanged(int)), this, SLOT(percentLoadedChanged(int)));	×
158	delete bEl;	×
159	allSkyLayers.remove(key);	×
160	}
161	else
162	{
163	qDebug() << "StelSkyLayerMgr::removeSkyLayer there is no such key" << key << "nothing is removed";	×
164	}
165	}	×
166
167	// Remove a sky image tile from the list of background images
168	void StelSkyLayerMgr::removeSkyLayer(StelSkyLayerP l)	×
169	{
170	const QString k = keyForLayer(l.data());	×
171	if (!k.isEmpty())	×
172	removeSkyLayer(k);	×
173	}	×
174
175	// Draw all the multi-res images collection
176	void StelSkyLayerMgr::draw(StelCore* core)	×
177	{
178	if (!flagShow)	×
179	return;	×
180
181	StelPainter sPainter(core->getProjection(StelCore::FrameJ2000));	×
182	sPainter.setBlending(true, GL_ONE, GL_ONE); //additive blending	×
183	for (auto* s : std::as_const(allSkyLayers))	×
184	{
185	if (s->show)	×
186	{
187	sPainter.setProjector(core->getProjection(s->layer->getFrameType()));	×
188	s->layer->draw(core, sPainter, 1.);	×
189	}
190	}
191	}	×
192
193	void noDelete(StelSkyLayer*) {}	×
194
195	// Called when loading of data started or stopped for one collection
196	void StelSkyLayerMgr::loadingStateChanged(bool b)	×
197	{
198	StelSkyLayer* tile = qobject_cast<StelSkyLayer*>(QObject::sender());	×
199	Q_ASSERT(tile!=Q_NULLPTR);	×
200	SkyLayerElem* elem = skyLayerElemForLayer(tile);	×
201	Q_ASSERT(elem!=Q_NULLPTR);	×
202	if (b)	×
203	{
204	Q_ASSERT(elem->progressBar==Q_NULLPTR);	×
205	elem->progressBar = StelApp::getInstance().addProgressBar();	×
206	QString serverStr = elem->layer->getShortServerCredits();	×
207	QString shortName = elem->layer->getShortName();	×
208	if (serverStr.isEmpty())	×
209	{
210	// TRANSLATORS: The full phrase is "Loading '%SHORT_NAME%'" in progress bar
211	elem->progressBar->setFormat(q_("Loading '%1'").arg(shortName));	×
212	}
213	else
214	{
215	// TRANSLATORS: The full phrase is "Loading '%SHORT_NAME%' from %URL%" in progress bar
216	elem->progressBar->setFormat(q_("Loading '%1' from %2").arg(shortName, serverStr));	×
217	}
218	elem->progressBar->setRange(0,100);	×
219	}	×
220	else
221	{
222	Q_ASSERT(elem->progressBar!=Q_NULLPTR);	×
223	StelApp::getInstance().removeProgressBar(elem->progressBar);	×
224	elem->progressBar = Q_NULLPTR;	×
225	emit collectionLoaded();	×
226	}
227	}	×
228
229	// Called when the percentage of loading tiles/tiles to be displayed changed for one collection
230	void StelSkyLayerMgr::percentLoadedChanged(int percentage)	×
231	{
232	StelSkyLayer* tile = qobject_cast<StelSkyLayer*>(QObject::sender());	×
233	Q_ASSERT(tile!=Q_NULLPTR);	×
234	SkyLayerElem* elem = skyLayerElemForLayer(tile);	×
235	Q_ASSERT(elem!=Q_NULLPTR);	×
236	Q_ASSERT(elem->progressBar!=Q_NULLPTR);	×
237	elem->progressBar->setValue(percentage);	×
238	}	×
239
240	StelSkyLayerMgr::SkyLayerElem* StelSkyLayerMgr::skyLayerElemForLayer(const StelSkyLayer* t)	×
241	{
242	for (auto* e : std::as_const(allSkyLayers))	×
243	{
244	if (e->layer==t)	×
245	{
246	return e;	×
247	}
248	}
249	return Q_NULLPTR;	×
250	}
251
252	QString StelSkyLayerMgr::keyForLayer(const StelSkyLayer* t)	×
253	{
254	return allSkyLayers.key(skyLayerElemForLayer(t));	×
255	}
256
257	StelSkyLayerMgr::SkyLayerElem::SkyLayerElem(StelSkyLayerP t, bool ashow) : layer(t), progressBar(Q_NULLPTR), show(ashow)	×
258	{}	×
259
260	StelSkyLayerMgr::SkyLayerElem::~SkyLayerElem()	×
261	{
262	if (progressBar)	×
263	StelApp::getInstance().removeProgressBar(progressBar);	×
264	progressBar = Q_NULLPTR;	×
265	}	×
266
267	bool StelSkyLayerMgr::loadSkyImage(const QString& id, const QString& filename,	×
268	double long0, double lat0,
269	double long1, double lat1,
270	double long2, double lat2,
271	double long3, double lat3,
272	double minRes, double maxBright,
273	bool visible, StelCore::FrameType frameType,
274	bool withAberration, int decimateBy)
275	{
276	Q_UNUSED(decimateBy)
277	if (allSkyLayers.contains(id))	×
278	{
279	qWarning() << "Image ID" << id << "already exists, removing old image before loading";	×
280	removeSkyLayer(id);	×
281	}
282
283	QString path = StelFileMgr::findFile(filename);	×
284	if (path.isEmpty())	×
285	{
286	qWarning() << "Could not find image" << QDir::toNativeSeparators(filename);	×
287	return false;	×
288	}
289	QVariantMap vm;	×
290	QVariantList cl; // coordinates list for adding worldCoords and textureCoords	×
291	QVariantList c; // a list for a pair of coordinates	×
292	QVariantList ol; // outer list - we want a structure 3 levels deep...	×
293	vm["imageUrl"] = QVariant(path);	×
294	vm["maxBrightness"] = QVariant(maxBright);	×
295	vm["minResolution"] = QVariant(minRes);	×
296	vm["shortName"] = QVariant(id);	×
297	vm["withAberration"] = QVariant(withAberration);	×
298
299	// textureCoords (define the ordering of worldCoords)
300	cl.clear();	×
301	ol.clear();	×
302	c.clear(); c.append(0); c.append(0); cl.append(QVariant(c));	×
303	c.clear(); c.append(1); c.append(0); cl.append(QVariant(c));	×
304	c.clear(); c.append(1); c.append(1); cl.append(QVariant(c));	×
305	c.clear(); c.append(0); c.append(1); cl.append(QVariant(c));	×
306	ol.append(QVariant(cl));	×
307	vm["textureCoords"] = ol;	×
308
309	// world coordinates
310	cl.clear();	×
311	ol.clear();	×
312	c.clear(); c.append(long0); c.append(lat0); cl.append(QVariant(c));	×
313	c.clear(); c.append(long1); c.append(lat1); cl.append(QVariant(c));	×
314	c.clear(); c.append(long2); c.append(lat2); cl.append(QVariant(c));	×
315	c.clear(); c.append(long3); c.append(lat3); cl.append(QVariant(c));	×
316	ol.append(QVariant(cl));	×
317	vm["worldCoords"] = ol;	×
318
319	vm["alphaBlend"] = true; // new 2017-3: Make black correctly see-through.	×
320
321	StelSkyLayerP tile = StelSkyLayerP(new StelSkyImageTile(vm, Q_NULLPTR));	×
322	tile->setFrameType(frameType);	×
323
324	try
325	{
326	QString key = insertSkyLayer(tile, filename, visible);	×
327	if (key == id)	×
328	return true;	×
329	else
330	return false;	×
331	}	×
332	catch (std::runtime_error& e)	×
333	{
334	qWarning() << e.what();	×
335	return false;	×
336	}	×
337	}	×
338
339	void StelSkyLayerMgr::showLayer(const QString& id, bool b)	×
340	{
341	if (allSkyLayers.contains(id))	×
342	{
343	if (allSkyLayers[id]!=Q_NULLPTR)	×
344	allSkyLayers[id]->show = b;	×
345	}
346	}	×
347
348	bool StelSkyLayerMgr::getShowLayer(const QString& id) const	×
349	{
350	if (allSkyLayers.contains(id))	×
351	{
352	if (allSkyLayers[id]!=Q_NULLPTR)	×
353	return allSkyLayers[id]->show;	×
354	}
355	return false;	×
356	}
357
358
359	//! Get the list of all the currently loaded layers.
360	QMap<QString, StelSkyLayerP> StelSkyLayerMgr::getAllSkyLayers() const	×
361	{
362	QMap<QString, StelSkyLayerP> res;	×
363	for (QMap<QString, StelSkyLayerMgr::SkyLayerElem*>::ConstIterator iter=allSkyLayers.constBegin();iter!=allSkyLayers.constEnd();++iter)	×
364	{
365	//qDebug() << iter.key() << iter.value()->layer->getShortName();
366	res.insert(iter.key(), iter.value()->layer);	×
367	}
368	return res;	×
369	}	×
370
371	StelSkyLayerP StelSkyLayerMgr::getSkyLayer(const QString& key) const	×
372	{
373	if (allSkyLayers.contains(key))	×
374	return allSkyLayers[key]->layer;	×
375	return StelSkyLayerP();	×
376	}

Stellarium / stellarium / 15670918640

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous