static void openComponentSourcePropertyOfLoader(const ModelNode &modelNode)
{
QmlDesignerPlugin::instance()->viewManager().nextFileIsCalledInternally();
QHash<PropertyName, QVariant> propertyHash;
getProperties(modelNode, propertyHash);
ModelNode componentModelNode;
if (modelNode.hasNodeProperty("sourceComponent")) {
componentModelNode = modelNode.nodeProperty("sourceComponent").modelNode();
} else if (modelNode.hasNodeListProperty("component")) {
/*
* The component property should be a NodeProperty, but currently is a NodeListProperty, because
* the default property is always implcitly a NodeListProperty. This is something that has to be fixed.
*/
componentModelNode = modelNode.nodeListProperty("component").toModelNodeList().first();
}
Core::EditorManager::openEditor(componentModelNode.metaInfo().componentFileName(), Core::Id(), Core::EditorManager::DoNotMakeVisible);
ModelNode rootModelNode = currentDesignDocument()->rewriterView()->rootModelNode();
applyProperties(rootModelNode, propertyHash);
}
TITANIUM_FUNCTION(Module, applyProperties)
{
ENSURE_OBJECT_AT_INDEX(props, 0);
applyProperties(props, this_object);
return get_context().CreateUndefined();
}
TITANIUM_FUNCTION(SocketModule, createUDP)
{
TITANIUM_LOG_DEBUG("SocketModule::createUDP: ");
ENSURE_OPTIONAL_OBJECT_AT_INDEX(parameters, 0);
JSValue Titanium_property = get_context().get_global_object().GetProperty("Titanium");
TITANIUM_ASSERT(Titanium_property.IsObject()); // precondition
JSObject Titanium = static_cast<JSObject>(Titanium_property);
JSValue Network_property = Titanium.GetProperty("Network");
TITANIUM_ASSERT(Network_property.IsObject()); // precondition
JSObject Network = static_cast<JSObject>(Network_property);
JSValue Socket_property = Network.GetProperty("Socket");
TITANIUM_ASSERT(Socket_property.IsObject()); // precondition
JSObject Socket = static_cast<JSObject>(Socket_property);
JSValue UDP_property = Socket.GetProperty("UDP");
TITANIUM_ASSERT(UDP_property.IsObject()); // precondition
JSObject UDP = static_cast<JSObject>(UDP_property);
auto udp = UDP.CallAsConstructor();
applyProperties(parameters, udp);
return udp;
}
static void openFileComponent(const ModelNode &modelNode)
{
QmlDesignerPlugin::instance()->viewManager().nextFileIsCalledInternally();
QHash<PropertyName, QVariant> propertyHash;
getProperties(modelNode, propertyHash);
Core::EditorManager::openEditor(modelNode.metaInfo().componentFileName(), Core::Id(), Core::EditorManager::DoNotMakeVisible);
ModelNode rootModelNode = currentDesignDocument()->rewriterView()->rootModelNode();
applyProperties(rootModelNode, propertyHash);
}
MenuBar::MenuBar(double x, double y, const WideString&label_text, AssetManager*assetManager, const Dictionary&properties) : SpriteActor(x, y)
{
addAnimation("MenuBar", new Animation(1, assetManager, "elements/menu_bar.png"));
changeAnimation("MenuBar", Animation::FORWARD);
autoLayoutMgr.setFrame(getFrame());
Font* font = assetManager->getFont("fonts/default.ttf");
label_color = Color::BLACK;
label_actor = new TextActor(label_text, font, label_color, 24, Font::STYLE_PLAIN, TextActor::ALIGN_BOTTOMLEFT);
autoLayoutMgr.add(RectD(0.05, 0.05, 0.575, 0.95), label_actor);
applyProperties(properties);
}
static void openSourcePropertyOfLoader(const ModelNode &modelNode)
{
QmlDesignerPlugin::instance()->viewManager().nextFileIsCalledInternally();
QHash<PropertyName, QVariant> propertyHash;
QString componentFileName = modelNode.variantProperty("source").value().toString();
QString componentFilePath = modelNode.model()->fileUrl().resolved(QUrl::fromLocalFile(componentFileName)).toLocalFile();
getProperties(modelNode, propertyHash);
Core::EditorManager::openEditor(componentFilePath, Core::Id(), Core::EditorManager::DoNotMakeVisible);
ModelNode rootModelNode = currentDesignDocument()->rewriterView()->rootModelNode();
applyProperties(rootModelNode, propertyHash);
}
int QwtDesignerPlugin::TaskMenuExtension::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: editProperties(); break;
case 1: applyProperties((*reinterpret_cast< const QString(*)>(_a[1]))); break;
default: ;
}
_id -= 2;
}
return _id;
}
/////////////////////////////////////////////////////////
// backendMess
//
/////////////////////////////////////////////////////////
void multimodel :: backendMess(t_symbol*s, int argc, t_atom*argv)
{
#if 0
gem::any value=ids;
m_properties.set("backends", value);
applyProperties();
#endif
int i;
m_backends.clear();
if(argc) {
for(i=0; i<argc; i++) {
if(A_SYMBOL == argv->a_type) {
t_symbol *b=atom_getsymbol(argv+i);
m_backends.push_back(b->s_name);
} else {
error("%s must be symbolic", s->s_name);
}
}
} else {
/* no backend requested, just enumerate them */
if(m_loader) {
std::vector<gem::any>atoms;
gem::any value;
gem::Properties props;
std::vector<std::string> backends;
props.set("backends", value);
m_loader->getProperties(props);
if(props.type("backends")!=gem::Properties::UNSET) {
props.get("backends", backends);
}
atoms.clear();
atoms.push_back(value=(int)(backends.size()));
m_infoOut.send("loaders", atoms);
if(!backends.empty()) {
for(i=0; i<backends.size(); i++) {
atoms.clear();
atoms.push_back(value=backends[i]);
post("loader[%d] %s", i, backends[i].c_str());
m_infoOut.send("loader", atoms);
}
} else {
post("no model-loading backends found!");
}
}
}
}
void DocumentManager::goIntoComponent(const ModelNode &modelNode)
{
if (modelNode.isValid() && modelNode.isComponent() && designDocument()) {
QmlDesignerPlugin::instance()->viewManager().setComponentNode(modelNode);
QHash<PropertyName, QVariant> oldProperties = getProperties(modelNode);
if (isFileComponent(modelNode))
openFileComponent(modelNode);
else if (hasDelegateWithFileComponent(modelNode))
openFileComponentForDelegate(modelNode);
else if (hasSourceWithFileComponent(modelNode))
openSourcePropertyOfLoader(modelNode);
else if (isLoaderWithSourceComponent(modelNode))
openComponentSourcePropertyOfLoader(modelNode);
else
openInlineComponent(modelNode);
ModelNode rootModelNode = designDocument()->rewriterView()->rootModelNode();
applyProperties(rootModelNode, oldProperties);
}
}
static inline void openInlineComponent(const ModelNode &modelNode)
{
if (!modelNode.isValid() || !modelNode.metaInfo().isValid())
return;
if (!currentDesignDocument())
return;
QHash<PropertyName, QVariant> propertyHash;
getProperties(modelNode, propertyHash);
handleComponent(modelNode);
handleDelegate(modelNode);
handleTabComponent(modelNode);
ModelNode rootModelNode = currentDesignDocument()->rewriterView()->rootModelNode();
applyProperties(rootModelNode, propertyHash);
}
int QwtPlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QFrame::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = grabProperties(); break;
}
_id -= 1;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: applyProperties(*reinterpret_cast< QString*>(_v)); break;
}
_id -= 1;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 1;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 1;
}
#endif // QT_NO_PROPERTIES
return _id;
}
/////////////////////////////////////////////////////////
// textureMess
//
/////////////////////////////////////////////////////////
void multimodel :: textureMess(int state)
{
std::string textype;
switch(state) {
case 0:
textype="linear";
break;
case 1:
textype="spheremap";
break;
case 2:
textype="UV";
break;
default:
break;
}
if(textype.empty()) {
m_properties.erase("textype");
} else {
gem::any value=textype;
m_properties.set("textype", value);
}
applyProperties();
}
/////////////////////////////////////////////////////////
// materialMess
//
/////////////////////////////////////////////////////////
void multimodel :: materialMess(int material)
{
gem::any value=material;
m_properties.set("usematerials", value);
applyProperties();
}
/////////////////////////////////////////////////////////
// smoothMess
//
/////////////////////////////////////////////////////////
void multimodel :: smoothMess(t_float fsmooth)
{
m_properties.set("smooth", fsmooth);
applyProperties();
}
/////////////////////////////////////////////////////////
// reverseMess
//
/////////////////////////////////////////////////////////
void multimodel :: reverseMess(bool reverse)
{
gem::any value=(double)reverse;
m_properties.set("reverse", value);
applyProperties();
}
/////////////////////////////////////////////////////////
// matrialMess
//
/////////////////////////////////////////////////////////
void multimodel :: rescaleMess(bool state)
{
gem::any value=(double)state;
m_properties.set("rescale", value);
applyProperties();
}
void QuteWidget::apply()
{
applyProperties();
}
/////////////////////////////////////////////////////////
// groupMess
//
/////////////////////////////////////////////////////////
void multimodel :: groupMess(int state)
{
gem::any value=state;
m_properties.set("group", value);
applyProperties();
}