void LocationDialog::setFieldsFromLocation(const StelLocation& loc)
{
// Deactivate edit signals
disconnectEditSignals();
ui->cityNameLineEdit->setText(loc.name);
int idx = ui->countryNameComboBox->findData(loc.country, Qt::UserRole, Qt::MatchCaseSensitive);
if (idx==-1)
{
// Use France as default
ui->countryNameComboBox->findData(QVariant("France"), Qt::UserRole, Qt::MatchCaseSensitive);
}
ui->countryNameComboBox->setCurrentIndex(idx);
ui->longitudeSpinBox->setDegrees(loc.longitude);
ui->latitudeSpinBox->setDegrees(loc.latitude);
ui->altitudeSpinBox->setValue(loc.altitude);
idx = ui->planetNameComboBox->findData(loc.planetName, Qt::UserRole, Qt::MatchCaseSensitive);
if (idx==-1)
{
// Use Earth as default
idx = ui->planetNameComboBox->findData(QVariant("Earth"), Qt::UserRole, Qt::MatchCaseSensitive);
}
ui->planetNameComboBox->setCurrentIndex(idx);
setMapForLocation(loc);
// Set pointer position
ui->mapLabel->setCursorPos(loc.longitude, loc.latitude);
ui->deleteLocationFromListPushButton->setEnabled(StelApp::getInstance().getLocationMgr().canDeleteUserLocation(loc.getID()));
SolarSystem* ssm = GETSTELMODULE(SolarSystem);
PlanetP p = ssm->searchByEnglishName(loc.planetName);
LandscapeMgr* ls = GETSTELMODULE(LandscapeMgr);
if (ls->getFlagAtmosphereAutoEnable())
{
if (loc.planetName != StelApp::getInstance().getCore()->getCurrentLocation().planetName)
{
QSettings* conf = StelApp::getInstance().getSettings();
ls->setFlagAtmosphere(p->hasAtmosphere() & conf->value("landscape/flag_atmosphere", true).toBool());
ls->setFlagFog(p->hasAtmosphere() & conf->value("landscape/flag_fog", true).toBool());
}
}
// Reactivate edit signals
connectEditSignals();
}
void StelGui::initLandscapeMgr()
{
LandscapeMgr* landscapeMgr = GETSTELMODULE(LandscapeMgr);
getGuiAction("actionShow_Ground")->setChecked(landscapeMgr->getFlagLandscape());
connect(getGuiAction("actionShow_Ground"),
SIGNAL(toggled(bool)),
landscapeMgr,
SLOT(setFlagLandscape(bool)));
connect(landscapeMgr,
SIGNAL(landscapeDisplayedChanged(const bool)),
this,
SLOT(landscapeDisplayedUpdated(const bool)));
getGuiAction("actionShow_Cardinal_Points")->setChecked(landscapeMgr->getFlagCardinalsPoints());
connect(getGuiAction("actionShow_Cardinal_Points"),
SIGNAL(toggled(bool)),
landscapeMgr,
SLOT(setFlagCardinalsPoints(bool)));
connect(landscapeMgr,
SIGNAL(cardinalsPointsDisplayedChanged(const bool)),
this,
SLOT(cardinalsPointsDisplayedUpdated(const bool)));
getGuiAction("actionShow_Atmosphere")->setChecked(landscapeMgr->getFlagAtmosphere());
connect(getGuiAction("actionShow_Atmosphere"),
SIGNAL(toggled(bool)),
landscapeMgr,
SLOT(setFlagAtmosphere(bool)));
connect(landscapeMgr,
SIGNAL(atmosphereDisplayedChanged(const bool)),
this,
SLOT(atmosphereDisplayedUpdated(const bool)));
getGuiAction("actionShow_Fog")->setChecked(landscapeMgr->getFlagFog());
connect(getGuiAction("actionShow_Fog"),
SIGNAL(toggled(bool)),
landscapeMgr,
SLOT(setFlagFog(bool)));
connect(landscapeMgr,
SIGNAL(fogDisplayedChanged(const bool)),
this,
SLOT(fogDisplayedUpdated(const bool)));
}
void SporadicMeteorMgr::draw(StelCore* core)
{
if (!m_flagShow || !core->getSkyDrawer()->getFlagHasAtmosphere())
{
return;
}
LandscapeMgr* landmgr = GETSTELMODULE(LandscapeMgr);
if (landmgr->getFlagAtmosphere() && landmgr->getLuminance() > 5.f)
{
return;
}
// step through and draw all active meteors
StelPainter sPainter(core->getProjection(StelCore::FrameAltAz));
foreach (SporadicMeteor* m, activeMeteors)
{
m->draw(core, sPainter);
}
void MeteorMgr::draw(StelCore* core)
{
if (!flagShow)
return;
LandscapeMgr* landmgr = (LandscapeMgr*)StelApp::getInstance().getModuleMgr().getModule("LandscapeMgr");
if (landmgr->getFlagAtmosphere() && landmgr->getLuminance()>5)
return;
StelPainter sPainter(core->getProjection(StelCore::FrameAltAz));
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
sPainter.enableTexture2d(false);
// step through and draw all active meteors
for (std::vector<Meteor*>::iterator iter = active.begin(); iter != active.end(); ++iter)
{
(*iter)->draw(core, sPainter);
}
}
void StelCore::returnToHome()
{
// Using returnToDefaultLocation() and getCurrentLocation() introduce issue, because for flying
// between planets using SpaceShip and second method give does not exist data
StelLocationMgr& locationMgr = StelApp::getInstance().getLocationMgr();
bool ok = false;
StelLocation loc = locationMgr.locationForString(defaultLocationID, &ok);
if (ok)
moveObserverTo(loc, 0.);
PlanetP p = GETSTELMODULE(SolarSystem)->searchByEnglishName(loc.planetName);
LandscapeMgr* landscapeMgr = GETSTELMODULE(LandscapeMgr);
landscapeMgr->setCurrentLandscapeID(landscapeMgr->getDefaultLandscapeID());
landscapeMgr->setFlagAtmosphere(p->hasAtmosphere());
landscapeMgr->setFlagFog(p->hasAtmosphere());
GETSTELMODULE(StelObjectMgr)->unSelect();
StelMovementMgr* smmgr = getMovementMgr();
smmgr->setViewDirectionJ2000(altAzToJ2000(smmgr->getInitViewingDirection(), StelCore::RefractionOff));
}
// Update the widget to make sure it is synchrone if the location is changed programmatically
void LocationDialog::updateFromProgram(const StelLocation& currentLocation)
{
if (!dialog->isVisible())
return;
StelCore* stelCore = StelApp::getInstance().getCore();
isEditingNew = false;
// Check that the use as default check box needs to be updated
// Move to setFieldsFromLocation()? --BM?
const bool b = currentLocation.getID() == stelCore->getDefaultLocationID();
QSettings* conf = StelApp::getInstance().getSettings();
if (conf->value("init_location/location", "auto").toString() != ("auto"))
{
updateDefaultLocationControls(b);
ui->pushButtonReturnToDefault->setEnabled(!b);
}
const QString& key1 = currentLocation.getID();
const QString& key2 = locationFromFields().getID();
if (key1!=key2)
{
setFieldsFromLocation(currentLocation);
}
LandscapeMgr *lmgr = GETSTELMODULE(LandscapeMgr);
if (lmgr->getFlagUseLightPollutionFromDatabase())
{
int bidx = currentLocation.bortleScaleIndex;
if (!currentLocation.planetName.contains("Earth")) // location not on Earth...
bidx = 1;
if (bidx<1) // ...or it observatory, or it unknown location
bidx = currentLocation.DEFAULT_BORTLE_SCALE_INDEX;
stelCore->getSkyDrawer()->setBortleScaleIndex(bidx);
lmgr->setAtmosphereBortleLightPollution(bidx);
}
}
void StelCore::moveObserverToSelected()
{
StelObjectMgr* objmgr = GETSTELMODULE(StelObjectMgr);
Q_ASSERT(objmgr);
if (objmgr->getWasSelected())
{
Planet* pl = dynamic_cast<Planet*>(objmgr->getSelectedObject()[0].data());
if (pl)
{
// We need to move to the selected planet. Try to generate a location from the current one
StelLocation loc = getCurrentLocation();
if (loc.planetName != pl->getEnglishName())
{
loc.planetName = pl->getEnglishName();
loc.name = "-";
loc.state = "";
moveObserverTo(loc);
LandscapeMgr* landscapeMgr = GETSTELMODULE(LandscapeMgr);
if (pl->getEnglishName() == "Solar System Observer")
{
landscapeMgr->setFlagAtmosphere(false);
landscapeMgr->setFlagFog(false);
landscapeMgr->setFlagLandscape(false);
}
else
{
landscapeMgr->setFlagAtmosphere(pl->hasAtmosphere());
landscapeMgr->setFlagFog(pl->hasAtmosphere());
landscapeMgr->setFlagLandscape(true);
}
}
}
}
StelMovementMgr* mmgr = GETSTELMODULE(StelMovementMgr);
Q_ASSERT(mmgr);
mmgr->setFlagTracking(false);
}
void StelApp::init(QSettings* conf)
{
confSettings = conf;
devicePixelsPerPixel = QOpenGLContext::currentContext()->screen()->devicePixelRatio();
setBaseFontSize(confSettings->value("gui/base_font_size", 13).toInt());
core = new StelCore();
if (saveProjW!=-1 && saveProjH!=-1)
core->windowHasBeenResized(0, 0, saveProjW, saveProjH);
// Initialize AFTER creation of openGL context
textureMgr = new StelTextureMgr();
textureMgr->init();
networkAccessManager = new QNetworkAccessManager(this);
// Activate http cache if Qt version >= 4.5
QNetworkDiskCache* cache = new QNetworkDiskCache(networkAccessManager);
QString cachePath = StelFileMgr::getCacheDir();
qDebug() << "Cache directory is: " << QDir::toNativeSeparators(cachePath);
cache->setCacheDirectory(cachePath);
networkAccessManager->setCache(cache);
connect(networkAccessManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(reportFileDownloadFinished(QNetworkReply*)));
// Stel Object Data Base manager
stelObjectMgr = new StelObjectMgr();
stelObjectMgr->init();
getModuleMgr().registerModule(stelObjectMgr);
localeMgr = new StelLocaleMgr();
skyCultureMgr = new StelSkyCultureMgr();
planetLocationMgr = new StelLocationMgr();
actionMgr = new StelActionMgr();
localeMgr->init();
// Init the solar system first
SolarSystem* ssystem = new SolarSystem();
ssystem->init();
getModuleMgr().registerModule(ssystem);
// Load hipparcos stars & names
StarMgr* hip_stars = new StarMgr();
hip_stars->init();
getModuleMgr().registerModule(hip_stars);
core->init();
// Init nebulas
NebulaMgr* nebulas = new NebulaMgr();
nebulas->init();
getModuleMgr().registerModule(nebulas);
// Init milky way
MilkyWay* milky_way = new MilkyWay();
milky_way->init();
getModuleMgr().registerModule(milky_way);
// Init zodiacal light
ZodiacalLight* zodiacal_light = new ZodiacalLight();
zodiacal_light->init();
getModuleMgr().registerModule(zodiacal_light);
// Init sky image manager
skyImageMgr = new StelSkyLayerMgr();
skyImageMgr->init();
getModuleMgr().registerModule(skyImageMgr);
// Init audio manager
audioMgr = new StelAudioMgr();
// Init video manager
videoMgr = new StelVideoMgr();
// Constellations
ConstellationMgr* asterisms = new ConstellationMgr(hip_stars);
asterisms->init();
getModuleMgr().registerModule(asterisms);
// Landscape, atmosphere & cardinal points section
LandscapeMgr* landscape = new LandscapeMgr();
landscape->init();
getModuleMgr().registerModule(landscape);
GridLinesMgr* gridLines = new GridLinesMgr();
gridLines->init();
getModuleMgr().registerModule(gridLines);
// Sporadic Meteors
SporadicMeteorMgr* meteors = new SporadicMeteorMgr(10, 72);
meteors->init();
getModuleMgr().registerModule(meteors);
// User labels
LabelMgr* skyLabels = new LabelMgr();
skyLabels->init();
getModuleMgr().registerModule(skyLabels);
skyCultureMgr->init();
//Create the script manager here, maybe some modules/plugins may want to connect to it
//It has to be initialized later after all modules have been loaded by calling initScriptMgr
#ifndef DISABLE_SCRIPTING
scriptAPIProxy = new StelMainScriptAPIProxy(this);
scriptMgr = new StelScriptMgr(this);
#endif
// Initialisation of the color scheme
emit colorSchemeChanged("color");
setVisionModeNight(confSettings->value("viewing/flag_night").toBool());
// Enable viewport effect at startup if he set
setViewportEffect(confSettings->value("video/viewport_effect", "none").toString());
// Proxy Initialisation
setupNetworkProxy();
updateI18n();
// Init actions.
actionMgr->addAction("actionShow_Night_Mode", N_("Display Options"), N_("Night mode"), this, "nightMode");
setFlagShowDecimalDegrees(confSettings->value("gui/flag_show_decimal_degrees", false).toBool());
setFlagOldAzimuthUsage(confSettings->value("gui/flag_use_azimuth_from_south", false).toBool());
initialized = true;
}
void Scenery3d::loadSceneCompleted()
{
S3DScene* result = currentLoadFuture.result();
progressBar->setValue(100);
StelApp::getInstance().removeProgressBar(progressBar);
progressBar=Q_NULLPTR;
if(!result)
{
showMessage(q_("Could not load scene, please check log for error messages!"));
return;
}
else
showMessage(q_("Scene successfully loaded."));
//do stuff that requires the main thread
const SceneInfo& info = result->getSceneInfo();
//move to the location specified by the scene
LandscapeMgr* lmgr = GETSTELMODULE(LandscapeMgr);
bool landscapeSetsLocation=lmgr->getFlagLandscapeSetsLocation();
lmgr->setFlagLandscapeSetsLocation(true);
lmgr->setCurrentLandscapeName(info.landscapeName, 0.); // took a second, implicitly.
// Switched to immediate landscape loading: Else,
// Landscape and Navigator at this time have old coordinates! But it should be possible to
// delay rot_z computation up to this point and live without an own location section even
// with meridian_convergence=from_grid.
lmgr->setFlagLandscapeSetsLocation(landscapeSetsLocation); // restore
if (info.hasLocation())
{
qCDebug(scenery3d) << "Setting location to given coordinates";
StelApp::getInstance().getCore()->moveObserverTo(*info.location, 0., 0.);
}
else qCDebug(scenery3d) << "No coordinates given in scenery3d.ini";
if (info.hasLookAtFOV())
{
qCDebug(scenery3d) << "Setting orientation";
Vec3f lookat=currentLoadScene.lookAt_fov;
// This vector is (az_deg, alt_deg, fov_deg)
Vec3d v;
StelUtils::spheToRect(lookat[0]*M_PI/180.0, lookat[1]*M_PI/180.0, v);
mvMgr->setViewDirectionJ2000(StelApp::getInstance().getCore()->altAzToJ2000(v, StelCore::RefractionOff));
mvMgr->zoomTo(lookat[2]);
} else qCDebug(scenery3d) << "No orientation given in scenery3d.ini";
//clear loading scene
currentLoadScene = SceneInfo();
emit loadingSceneIDChanged(QString());
//switch scenes
delete currentScene;
currentScene = result;
//show the scene
setEnableScene(true);
emit currentSceneChanged(info);
emit currentSceneIDChanged(info.id);
}
