SceneManager::visibility SceneManager::getVisibility(const vec4d *frustumPlanes, const box3d &b)
{
visibility v0 = getVisibility(frustumPlanes[0], b);
if (v0 == INVISIBLE) {
return INVISIBLE;
}
visibility v1 = getVisibility(frustumPlanes[1], b);
if (v1 == INVISIBLE) {
return INVISIBLE;
}
visibility v2 = getVisibility(frustumPlanes[2], b);
if (v2 == INVISIBLE) {
return INVISIBLE;
}
visibility v3 = getVisibility(frustumPlanes[3], b);
if (v3 == INVISIBLE) {
return INVISIBLE;
}
visibility v4 = getVisibility(frustumPlanes[4], b);
if (v4 == INVISIBLE) {
return INVISIBLE;
}
if (v0 == FULLY_VISIBLE && v1 == FULLY_VISIBLE &&
v2 == FULLY_VISIBLE && v3 == FULLY_VISIBLE &&
v4 == FULLY_VISIBLE)
{
return FULLY_VISIBLE;
}
return PARTIALLY_VISIBLE;
}
QString WeatherPlugin::replace(const QString &text)
{
QString res = text;
QString sun_set, sun_raise, updated;
#if COMPAT_QT_VERSION >= 0x030000
QTime tmp_time;
QDateTime dt;
int h,m;
parseTime(getSun_set(),h,m);
tmp_time.setHMS(h,m,0,0);
sun_set = tmp_time.toString(Qt::LocalDate);
sun_set = sun_set.left(sun_set.length() - 3);
parseTime(getSun_raise(),h,m);
tmp_time.setHMS(h,m,0,0);
sun_raise = tmp_time.toString(Qt::LocalDate);
sun_raise = sun_raise.left(sun_raise.length() - 3);
parseDateTime(getUpdated(),dt);
updated = dt.toString(Qt::LocalDate);
updated = updated.left(updated.length() - 3);
#else
sun_set = getSun_set();
sun_raise = getSun_raise();
updated = getUpdated();
#endif
/* double Expressions *before* single or better RegExp ! */
res = res.replace(QRegExp("\\%mp"), i18n("moonphase", getMoonPhase()));
res = res.replace(QRegExp("\\%mi"), number(getMoonIcon()));
res = res.replace(QRegExp("\\%pp"), number(getPrecipitation()));
res = res.replace(QRegExp("\\%ut"), i18n("weather", getUV_Description()));
res = res.replace(QRegExp("\\%ui"), number(getUV_Intensity()));
res = res.replace(QRegExp("\\%t"), QString::number((int)getTemperature()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%f"), QString::number((int)getFeelsLike()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%d"), QString::number((int)getDewPoint()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%h"), number(getHumidity()) + "%");
res = res.replace(QRegExp("\\%w"), number(getWind_speed()) + " " + i18n(getUS()));
res = res.replace(QRegExp("\\%x"), QString::number(getWind_speed() * 10 / 36) + " " + i18n("m/s"));
res = res.replace(QRegExp("\\%g"), getWindGust() ? QString("(") + i18n("gust ") + number(getWindGust()) + i18n(getUS()) + QString(")") : QString(""));
res = res.replace(QRegExp("\\%y"), getWindGust() ? QString("(") + i18n("gust ") + number(getWindGust() * 10 / 36) + QString(" ") + i18n("m/s") + QString(")") : QString(""));
res = res.replace(QRegExp("\\%p"), number(getPressure()) + " " + i18n(getUP()));
res = res.replace(QRegExp("\\%a"), number(getPressure() * 75 / 100));
res = res.replace(QRegExp("\\%q"), i18n("weather", getPressureD()));
res = res.replace(QRegExp("\\%l"), getLocation());
res = res.replace(QRegExp("\\%b"), i18n("weather", getWind()));
res = res.replace(QRegExp("\\%u"), updated);
res = res.replace(QRegExp("\\%r"), sun_raise);
res = res.replace(QRegExp("\\%s"), sun_set);
res = res.replace(QRegExp("\\%c"), i18n_conditions(getConditions()));
res = res.replace(QRegExp("\\%v"), i18n("weather", getVisibility()) + (atol(getVisibility()) ? QString(" ") + i18n(getUD()) : QString("")));
res = res.replace(QRegExp("\\%i"), number(getIcon()));
return res;
}
void CustomLayer::setVisibility(VisibilityType value) {
if (value == getVisibility())
return;
auto impl_ = mutableImpl();
impl_->visibility = value;
baseImpl = std::move(impl_);
observer->onLayerChanged(*this);
}
void UMLRole::saveToXMI( QDomDocument & qDoc, QDomElement & qElement ) {
QDomElement roleElement = UMLObject::save("UML:AssociationEnd", qDoc);
if (m_pSecondary)
roleElement.setAttribute( "type", ID2STR(m_pSecondary->getID()) );
else
kError() << "UMLRole::saveToXMI(id " << ID2STR(m_nId)
<< "): m_pSecondary is NULL" << endl;
if (!m_Multi.isEmpty())
roleElement.setAttribute("multiplicity", m_Multi);
if (m_role == Uml::A) { // role aggregation based on parent type
// role A
switch (m_pAssoc->getAssocType()) {
case Uml::at_Composition:
roleElement.setAttribute("aggregation", "composite");
break;
case Uml::at_Aggregation:
roleElement.setAttribute("aggregation", "aggregate");
break;
default:
roleElement.setAttribute("aggregation", "none");
break;
}
if (m_pAssoc->getAssocType() == Uml::at_UniAssociation) {
// Normally the isNavigable attribute is "true".
// We set it to false on role A to indicate that
// role B gets an explicit arrowhead.
roleElement.setAttribute("isNavigable", "false");
} else {
roleElement.setAttribute("isNavigable", "true");
}
} else {
roleElement.setAttribute("aggregation", "none");
roleElement.setAttribute("isNavigable", "true");
//FIXME obviously this isn't standard XMI
if (m_pAssoc->getAssocType() == Uml::at_Relationship) {
roleElement.setAttribute("relationship", "true");
}
}
roleElement.setAttribute("visibility", getVisibility().toString(false));
switch (m_Changeability) {
case Uml::chg_Frozen:
roleElement.setAttribute("changeability", "frozen");
break;
case Uml::chg_AddOnly:
roleElement.setAttribute("changeability", "addOnly");
break;
case Uml::chg_Changeable:
roleElement.setAttribute("changeability", "changeable");
break;
}
qElement.appendChild( roleElement );
}
void SceneManager::computeVisibility(ptr<SceneNode> n, visibility v)
{
if (v == PARTIALLY_VISIBLE) {
v = getVisibility(n->getWorldBounds());
}
n->isVisible = v != INVISIBLE;
for (unsigned int i = 0; i < n->getChildrenCount(); ++i) {
computeVisibility(n->getChild(i), v);
}
}
QString WeatherPlugin::replace(const QString &text)
{
QString res = text;
res = res.replace(QRegExp("\\%t"), number(getTemperature()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%f"), number(getFeelsLike()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%d"), number(getDewPoint()) + QChar((unsigned short)176) + getUT());
res = res.replace(QRegExp("\\%h"), number(getHumidity()) + "%");
res = res.replace(QRegExp("\\%w"), number(getWind_speed()) + " " + getUS());
res = res.replace(QRegExp("\\%g"), getWindGust() ? QString("<") + i18n("gust ") + number(getWindGust()) + ")" : "");
res = res.replace(QRegExp("\\%p"), number(getPressure()) + " " + getUP());
res = res.replace(QRegExp("\\%a"), number(getPressure() * 75 / 100));
res = res.replace(QRegExp("\\%q"), i18n("weather", getPressureD()));
res = res.replace(QRegExp("\\%l"), getLocation());
res = res.replace(QRegExp("\\%b"), getWind());
res = res.replace(QRegExp("\\%u"), getUpdated());
res = res.replace(QRegExp("\\%r"), getSun_raise());
res = res.replace(QRegExp("\\%s"), getSun_set());
res = res.replace(QRegExp("\\%c"), i18n_conditions(getConditions()));
res = res.replace(QRegExp("\\%v"), i18n("weather", getVisibility()) + (atol(getVisibility()) ? QString(" ") + getUD() : ""));
return res;
}
SceneManager::visibility CylindricalDeformation::getVisibility(const TerrainNode *t, const box3d &localBox) const
{
vec3d deformedBox[4];
deformedBox[0] = localToDeformed(vec3d(localBox.xmin, localBox.ymin, localBox.zmax));
deformedBox[1] = localToDeformed(vec3d(localBox.xmax, localBox.ymin, localBox.zmax));
deformedBox[2] = localToDeformed(vec3d(localBox.xmax, localBox.ymax, localBox.zmax));
deformedBox[3] = localToDeformed(vec3d(localBox.xmin, localBox.ymax, localBox.zmax));
double dy = localBox.ymax - localBox.ymin;
float f = (float) ((R - localBox.zmin) / ((R - localBox.zmax) * cos(dy / (2.0 * R))));
const vec4d *deformedFrustumPlanes = t->getDeformedFrustumPlanes();
SceneManager::visibility v0 = getVisibility(deformedFrustumPlanes[0], deformedBox, f);
if (v0 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v1 = getVisibility(deformedFrustumPlanes[1], deformedBox, f);
if (v1 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v2 = getVisibility(deformedFrustumPlanes[2], deformedBox, f);
if (v2 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v3 = getVisibility(deformedFrustumPlanes[3], deformedBox, f);
if (v3 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v4 = getVisibility(deformedFrustumPlanes[4], deformedBox, f);
if (v4 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
if (v0 == SceneManager::FULLY_VISIBLE && v1 == SceneManager::FULLY_VISIBLE &&
v2 == SceneManager::FULLY_VISIBLE && v3 == SceneManager::FULLY_VISIBLE &&
v4 == SceneManager::FULLY_VISIBLE)
{
return SceneManager::FULLY_VISIBLE;
}
return SceneManager::PARTIALLY_VISIBLE;
}
int caInclude::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = getMacro(); break;
case 1: *reinterpret_cast< QString*>(_v) = getFileName(); break;
case 2: *reinterpret_cast< Visibility*>(_v) = getVisibility(); break;
case 3: *reinterpret_cast< QString*>(_v) = getVisibilityCalc(); break;
case 4: *reinterpret_cast< QString*>(_v) = getChannelA(); break;
case 5: *reinterpret_cast< QString*>(_v) = getChannelB(); break;
case 6: *reinterpret_cast< QString*>(_v) = getChannelC(); break;
case 7: *reinterpret_cast< QString*>(_v) = getChannelD(); break;
}
_id -= 8;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setMacro(*reinterpret_cast< QString*>(_v)); break;
case 1: setFileName(*reinterpret_cast< QString*>(_v)); break;
case 2: setVisibility(*reinterpret_cast< Visibility*>(_v)); break;
case 3: setVisibilityCalc(*reinterpret_cast< QString*>(_v)); break;
case 4: setChannelA(*reinterpret_cast< QString*>(_v)); break;
case 5: setChannelB(*reinterpret_cast< QString*>(_v)); break;
case 6: setChannelC(*reinterpret_cast< QString*>(_v)); break;
case 7: setChannelD(*reinterpret_cast< QString*>(_v)); break;
}
_id -= 8;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 8;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 8;
}
#endif // QT_NO_PROPERTIES
return _id;
}
SceneManager::visibility SphericalDeformation::getVisibility(const TerrainNode *t, const box3d &localBox) const
{
vec3d deformedBox[4];
deformedBox[0] = localToDeformed(vec3d(localBox.xmin, localBox.ymin, localBox.zmin));
deformedBox[1] = localToDeformed(vec3d(localBox.xmax, localBox.ymin, localBox.zmin));
deformedBox[2] = localToDeformed(vec3d(localBox.xmax, localBox.ymax, localBox.zmin));
deformedBox[3] = localToDeformed(vec3d(localBox.xmin, localBox.ymax, localBox.zmin));
double a = (localBox.zmax + R) / (localBox.zmin + R);
double dx = (localBox.xmax - localBox.xmin) / 2 * a;
double dy = (localBox.ymax - localBox.ymin) / 2 * a;
double dz = localBox.zmax + R;
double f = sqrt(dx * dx + dy * dy + dz * dz) / (localBox.zmin + R);
const vec4d *deformedFrustumPlanes = t->getDeformedFrustumPlanes();
SceneManager::visibility v0 = getVisibility(deformedFrustumPlanes[0], deformedBox, f);
if (v0 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v1 = getVisibility(deformedFrustumPlanes[1], deformedBox, f);
if (v1 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v2 = getVisibility(deformedFrustumPlanes[2], deformedBox, f);
if (v2 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v3 = getVisibility(deformedFrustumPlanes[3], deformedBox, f);
if (v3 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
SceneManager::visibility v4 = getVisibility(deformedFrustumPlanes[4], deformedBox, f);
if (v4 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
vec3d c = t->getDeformedCamera();
double lSq = c.squaredLength();
double rm = R + min(0.0, localBox.zmin);
double rM = R + localBox.zmax;
double rmSq = rm * rm;
double rMSq = rM * rM;
vec4d farPlane = vec4d(c.x, c.y, c.z, sqrt((lSq - rmSq) * (rMSq - rmSq)) - rmSq);
SceneManager::visibility v5 = getVisibility(farPlane, deformedBox, f);
if (v5 == SceneManager::INVISIBLE) {
return SceneManager::INVISIBLE;
}
if (v0 == SceneManager::FULLY_VISIBLE && v1 == SceneManager::FULLY_VISIBLE &&
v2 == SceneManager::FULLY_VISIBLE && v3 == SceneManager::FULLY_VISIBLE &&
v4 == SceneManager::FULLY_VISIBLE && v5 == SceneManager::FULLY_VISIBLE)
{
return SceneManager::FULLY_VISIBLE;
}
return SceneManager::PARTIALLY_VISIBLE;
}
bool WindowsManager::setVisibility (const char* nodeNameCorba,
const char* visibilityModeCorba)
{
const std::string nodeName (nodeNameCorba);
const std::string visibilityMode (visibilityModeCorba);
VisibilityMode visibility = getVisibility (visibilityMode);
if (nodes_.find (nodeName) == nodes_.end ()) {
std::cout << "Node \"" << nodeName << "\" doesn't exist."
<< std::endl;
return false;
}
mtx_.lock();
nodes_[nodeName]->setVisibilityMode (visibility);
mtx_.unlock();
return true;
}
void NodeBase::print(){
if( getVisibility()){
//std::string indent = " ";
//int len = indent.length() * iIndent;
// cout << "Name: " << mName << " | Children: " << mChildren.size() << endl;
int tChildCount = getChildCount();
for (int i=0; i < tChildCount; i++){
mChildren[i]->print();
}
}
}
void NodeGeom::draw(){
if (getVisibility()) {
gl::pushMatrices();
gl::translate(mPosition.x, mPosition.y, mPosition.z);
gl::scale(mScale.x, mScale.y, mScale.z);
gl::rotate( Vec3f( mRotation.x, mRotation.y, mRotation.z ) );
//draw node's contents
gl::color(mColor);
Rectf rect( -mSideLength/2.0, -mSideLength/2.0, mSideLength, mSideLength);
// gl::Texture mTex;
//mTex.enableAndBind();
gl::drawSolidRect( rect);
//mTex.unbind();
//draw children
int tChildCount = getChildCount();
for (int i=0; i<tChildCount; i++){
cout<<"i'm now going to draw this child: " << mName << "w/ children # " << mChildren.size() << endl;
//mChildren[i]->draw();
mChildren.at(i)->draw();
}
gl::popMatrices();
}
}
float Environment::getVisibility( Point p )
{
return getVisibility( p.x, p.y );
}
QtDockRegion::QtDockRegion(IComponentContext& context, QtWindow& qtWindow, QDockWidget& qDockWidget)
: Depends(context), qtWindow_(qtWindow), qDockWidget_(qDockWidget), hidden_(false)
{
auto qMainWindow = qtWindow_.window();
assert(qMainWindow != nullptr);
// Walk our parent hierarchy and make sure we are tabified with the topmost dock widget.
// Dock widgets as children of anything but the main window are not supported.
// We support this in the Qt designer so that we can override the properties of a tab or collection of tabs within a
// dock region
QWidget* qWidget = &qDockWidget_;
while (qWidget != nullptr)
{
qWidget = qWidget->parentWidget();
if (qWidget == nullptr)
{
break;
}
auto qDockWidget = qobject_cast<QDockWidget*>(qWidget);
if (qDockWidget != nullptr)
{
qMainWindow->tabifyDockWidget(qDockWidget, &qDockWidget_);
}
}
qDockWidget_.setVisible(false);
auto layoutTagsProperty = qDockWidget_.property("layoutTags");
if (layoutTagsProperty.isValid())
{
auto tags = layoutTagsProperty.toStringList();
for (auto it = tags.cbegin(); it != tags.cend(); ++it)
{
tags_.tags_.push_back(std::string(it->toUtf8()));
}
}
auto hiddenProperty = qDockWidget_.property("hidden");
if (hiddenProperty.isValid())
{
hidden_ = hiddenProperty.toBool();
}
QObject::connect(&qtWindow_, &QtWindow::windowReady, [&]() {
if (needToRestorePreference_.empty())
{
return;
}
auto qtFramework = get<IQtFramework>();
assert(qtFramework != nullptr);
auto qMainWindow = qtWindow_.window();
for (auto& it : needToRestorePreference_)
{
auto qtDockWidget = it.first;
assert(qtDockWidget != nullptr);
auto pView = it.second;
assert(pView != nullptr);
bool isOk = qMainWindow->restoreDockWidget(qtDockWidget);
if (!isOk)
{
setDefaultPreferenceForDockWidget(qtDockWidget);
}
auto pQWidget = qtFramework->toQWidget(*pView);
assert(pQWidget != nullptr);
qtDockWidget->setWidget(pQWidget);
QmlView* qmlView = dynamic_cast<QmlView*>(pView);
if (qmlView == nullptr)
{
return;
}
auto ngtDockWidget = dynamic_cast<NGTDockWidget*>(qtDockWidget);
if (ngtDockWidget == nullptr)
{
return;
}
if (ngtDockWidget->isVisible() && ngtDockWidget->getVisibility())
{
qmlView->setNeedsToLoad(true);
}
}
needToRestorePreference_.clear();
});
}
void SceneGraphComponent::executeEvent(GameEvent *event)
{
switch (event->id())
{
case GameEvent::E_SET_TRANSFORMATION:
setTransformation(static_cast<const float*>(event->data()));
break;
case GameEvent::E_TRANSFORMATION:
memcpy(static_cast<float*>(event->data()), m_transformation, sizeof(float) * 16);
break;
case GameEvent::E_SET_TRANSLATION:
{
Vec3f* translation = static_cast<Vec3f*>(event->data());
m_transformation[12] = translation->x;
m_transformation[13] = translation->y;
m_transformation[14] = translation->z;
sendTransformation();
}
break;
case GameEvent::E_SET_SCALE:
setScale(static_cast<Vec3f*>(event->data()));
break;
case GameEvent::E_MESH_DATA:
getMeshData(static_cast<MeshData*>(event->data()));
break;
case GameEvent::E_TRANSLATE_LOCAL:
translateLocal(static_cast<Vec3f*>(event->data()));
break;
case GameEvent::E_TRANSLATE_GLOBAL:
translateGlobal(static_cast<Vec3f*>(event->data()));
break;
case GameEvent::E_ROTATE_LOCAL:
rotate(static_cast<Vec3f*>(event->data()));
break;
case GameEvent::E_SET_ROTATION:
setRotation(static_cast<Vec3f*>(event->data()));
break;
case GameEvent::E_ATTACH:
attach(static_cast<Attach*>(event->data()));
break;
case GameEvent::E_SET_NODE_PARENT:
setParentNode(static_cast<Attach*>(event->data()));
break;
case GameEvent::E_MORPH_TARGET:
if (m_hordeID > 0)
{
h3dSetModelMorpher(m_hordeID, static_cast<MorphTarget*>(event->data())->Name, static_cast<MorphTarget*>(event->data())->Value);
h3dUpdateModel(m_hordeID, H3DModelUpdateFlags::Geometry );
}
break;
case GameEvent::E_ACTIVATE_CAM:
if (m_hordeID > 0 && h3dGetNodeType(m_hordeID) == H3DNodeTypes::Camera)
SceneGraphManager::instance()->setActiveCam( m_hordeID );
break;
case GameEvent::E_SET_ANIM_FRAME:
{
if (m_hordeID > 0)
{
const SetAnimFrame* const data = static_cast<SetAnimFrame*>(event->data());
h3dSetModelAnimParams(m_hordeID, data->Stage, data->Time, data->Weight);
h3dUpdateModel(m_hordeID, H3DModelUpdateFlags::Animation | H3DModelUpdateFlags::Geometry );
}
}
break;
case GameEvent::E_SET_ENABLED:
setEnabled(*static_cast<bool*>(event->data()));
break;
case GameEvent::E_GET_VISIBILITY:
{
bool* visible = static_cast<bool*>(event->data());
if (visible)
*visible = getVisibility();
}
break;
case GameEvent::E_GET_PROJECTION_MATRIX:
{
float* mat = static_cast<float*>(event->data());
SceneGraphManager::instance()->getCameraProjectionMatrix(mat);
}
break;
case GameEvent::E_GET_ACTIVE_CAM:
if (SceneGraphManager::instance()->getActiveCam() == m_hordeID)
{
unsigned int* id = static_cast<unsigned int*>(event->data());
if (id)
*id = m_owner->worldId();
}
break;
case GameEvent::E_GET_SCENEGRAPH_ID:
{
int* id = static_cast<int*>(event->data());
if (id)
*id = m_hordeID;
}
break;
}
}
void QtDockRegion::addView(IView& view)
{
auto qMainWindow = qtWindow_.window();
assert(qMainWindow != nullptr);
auto findIt = dockWidgetMap_.find(&view);
if (findIt != dockWidgetMap_.end())
{
// already added into the dockWidget
return;
}
// IView will not control qWidget's life-cycle after this call.
auto qtFramework = get<IQtFramework>();
assert(qtFramework != nullptr);
auto qWidget = qtFramework->toQWidget(view);
if (qWidget == nullptr)
{
return;
}
auto centralWidget = qMainWindow->centralWidget();
if (centralWidget != nullptr)
{
centralWidget->layout()->addWidget(qWidget);
}
qWidget->setSizePolicy(qDockWidget_.sizePolicy());
qWidget->setMinimumSize(qDockWidget_.minimumSize());
qWidget->setMaximumSize(qDockWidget_.maximumSize());
qWidget->setSizeIncrement(qDockWidget_.sizeIncrement());
qWidget->setBaseSize(qDockWidget_.baseSize());
qWidget->resize(qWidget->baseSize());
auto qDockWidget = new NGTDockWidget(&view);
qDockWidget->setObjectName(view.id());
IView* pView = &view;
QtWindow* pWindow = &qtWindow_;
QObject::connect(qDockWidget, &QDockWidget::visibilityChanged, [qDockWidget, pWindow](bool visible) {
qDockWidget->visibilityChanged(visible);
if (visible)
{
if (pWindow->isLoadingPreferences())
{
return;
}
QCoreApplication::postEvent(qDockWidget, new QEvent(QEvent::FocusIn));
}
});
if (qtWindow_.isReady())
{
bool isOk = qMainWindow->restoreDockWidget(qDockWidget);
if (!isOk)
{
setDefaultPreferenceForDockWidget(qDockWidget);
}
QmlView* qmlView = dynamic_cast<QmlView*>(pView);
if (qmlView != nullptr)
{
if (qDockWidget->isVisible() && qDockWidget->getVisibility())
{
qmlView->setNeedsToLoad(true);
}
}
}
else
{
needToRestorePreference_.push_back(std::make_pair(qDockWidget, pView));
}
qDockWidget->setWidget(qWidget);
std::string actionId("View.");
actionId += view.title();
auto action = qtFramework->createAction(actionId.c_str(), view.title(), "View", [pView, qDockWidget](IAction*) {
qDockWidget->show();
qDockWidget->raise();
pView->focusInEvent();
});
auto application = get<IUIApplication>();
assert(application != nullptr);
application->addAction(*action);
dockWidgetMap_[&view] = std::make_pair(std::unique_ptr<QDockWidget>(qDockWidget), std::move(action));
}
SceneManager::visibility SceneManager::getVisibility(const box3d &worldBounds)
{
return getVisibility(worldFrustumPlanes, worldBounds);
}
