QByteArray convertToId(const QMetaObject *mo) { QByteArray className(mo->className()); if (!className.isEmpty()) return convertToId(className); // likely a metaobject generated for an extended qml object if (mo->superClass()) { className = convertToId(mo->superClass()); className.append("_extended"); return className; } static QHash<const QMetaObject *, QByteArray> generatedNames; className = generatedNames.value(mo); if (!className.isEmpty()) return className; std::cerr << "Found a QMetaObject without a className, generating a random name" << std::endl; className = QByteArray("error-unknown-name-"); className.append(QByteArray::number(generatedNames.size())); generatedNames.insert(mo, className); return className; }
/*! \internal Returns the index of the signal with name \n or -1 if no such signal exists. If \a super is TRUE, inherited signals are included. */ int QMetaObject::findSignal( const char* n, bool super ) const { const QMetaObject *mo = this; int offset = -1; do { const QMetaData *md = mo->signalDict ? mo->signalDict->find( n ) : 0; if ( md ) { #if defined(QT_CHECK_RANGE) if ( offset != -1 ) { qWarning( "QMetaObject::findSignal:%s: Conflict with %s::%s", className(), mo->className(), n ); return offset; } #endif offset = mo->signalOffset() + ( md - mo->signalData ); #if !defined(QT_CHECK_RANGE) return offset; #endif } } while ( super && (mo = mo->superclass) ); return offset; }
Task::Task(WId win, TaskManager * parent, const char *name) : QObject(parent, name), _active(false), _win(win), _lastWidth(0), _lastHeight(0), _lastResize(false), _lastIcon(), _thumbSize(0.2), _thumb(), _grab() { #ifdef KDE_3_2 _info = KWin::windowInfo(_win, 0, 0); #else _info = KWin::info(_win); #endif // try to load icon via net_wm _pixmap = KWin::icon(_win, 16, 16, true); // try to guess the icon from the classhint if(_pixmap.isNull()) KGlobal::instance()->iconLoader()->loadIcon(className().lower(), KIcon::Small,KIcon::Small, KIcon::DefaultState, 0, true); // load xapp icon if (_pixmap.isNull()) _pixmap = SmallIcon("kcmx"); }
bool Log::shouldLog(CallSite& site) { LogLock lock; if (!lock.ok()) { return false; } Globals& g = Globals::get(); Settings& s = Settings::get(); s.shouldLogCallCounter += 1; std::string class_name = className(site.mClassInfo); std::string function_name = functionName(site.mFunction); if (site.mClassInfo != typeid(NoClassInfo)) { function_name = class_name + "::" + function_name; } ELevel compareLevel = s.defaultLevel; // The most specific match found will be used as the log level, // since the computation short circuits. // So, in increasing order of importance: // Default < Broad Tag < File < Class < Function < Narrow Tag ((site.mNarrowTag != NULL) ? checkLevelMap(s.tagLevelMap, site.mNarrowTag, compareLevel) : false) || checkLevelMap(s.functionLevelMap, function_name, compareLevel) || checkLevelMap(s.classLevelMap, class_name, compareLevel) || checkLevelMap(s.fileLevelMap, abbreviateFile(site.mFile), compareLevel) || ((site.mBroadTag != NULL) ? checkLevelMap(s.tagLevelMap, site.mBroadTag, compareLevel) : false); site.mCached = true; g.addCallSite(site); return site.mShouldLog = site.mLevel >= compareLevel; }
void Log::flush(std::ostringstream* out, const CallSite& site) { LogLock lock; if (!lock.ok()) { return; } Globals& g = Globals::get(); Settings& s = Settings::get(); std::string message = out->str(); if (out == &g.messageStream) { g.messageStream.clear(); g.messageStream.str(""); g.messageStreamInUse = false; } else { delete out; } if (site.mLevel == LEVEL_ERROR) { std::ostringstream fatalMessage; fatalMessage << abbreviateFile(site.mFile) << "(" << site.mLine << ") : error"; writeToRecorders(site.mLevel, fatalMessage.str()); } std::ostringstream prefix; switch (site.mLevel) { case LEVEL_DEBUG: prefix << "DEBUG: "; break; case LEVEL_INFO: prefix << "INFO: "; break; case LEVEL_WARN: prefix << "WARNING: "; break; case LEVEL_ERROR: prefix << "ERROR: "; break; default: prefix << "XXX: "; break; }; if (s.printLocation) { prefix << abbreviateFile(site.mFile) << "(" << site.mLine << ") : "; } if (message.find(functionName(site.mFunction)) == std::string::npos) { #if LL_WINDOWS // DevStudio: __FUNCTION__ already includes the full class name #else if (site.mClassInfo != typeid(NoClassInfo)) { prefix << className(site.mClassInfo) << "::"; } #endif prefix << site.mFunction << ": "; } prefix << message; message = prefix.str(); writeToRecorders(site.mLevel, message); if (site.mLevel == LEVEL_ERROR && s.crashFunction) { s.crashFunction(message); } }
void FSPlaceObject2::encodeToStream(FSOutputStream* aStream) { aStream->startEncoding(className()); FSMovieObject::encodeToStream(aStream); aStream->setContext(FSStream::ColorContainsAlpha, 1); aStream->write(containsClipEvents() ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(containsClippingDepth() ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(containsName() ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(containsRatio() ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(containsColorTransform(aStream) ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(containsTransform() ? 1 : 0, FSStream::UnsignedBit, 1); aStream->write(place, FSStream::UnsignedBit, 2); aStream->write(layer, FSStream::UnsignedWord, 16); if (place == New || place == Replace) aStream->write(identifier, FSStream::UnsignedWord, 16); if (containsTransform()) transform.encodeToStream(aStream); if (containsColorTransform(aStream)) colorTransform.encodeToStream(aStream); if (containsRatio()) aStream->write((int)(ratio*65535.0f), FSStream::UnsignedWord, 16); if (containsName()) { aStream->write((byte*)name.c_str(), name.length()); aStream->write(0, FSStream::UnsignedWord, 8); } if (containsClippingDepth()) aStream->write(depth+1, FSStream::UnsignedWord, 16); if (containsClipEvents()) { if (encodedLength > 0) { aStream->write(encodedEvents, encodedLength); } else { int eventSize = aStream->getContext(FSStream::Version) > 5 ? 32 : 16; int eventMask = 0; aStream->write(0, FSStream::UnsignedWord, 16); for (FSVector<FSClipEvent>::iterator i = events.begin(); i != events.end(); ++i) eventMask += (*i).getEvent(); aStream->write(eventMask, FSStream::UnsignedWord, eventSize); #ifdef _DEBUG aStream->startEncoding("array"); #endif for (FSVector<FSClipEvent>::iterator i = events.begin(); i != events.end(); ++i) (*i).encodeToStream(aStream); aStream->write(0, FSStream::UnsignedWord, eventSize); #ifdef _DEBUG aStream->endEncoding("array"); #endif } } aStream->setContext(FSStream::ColorContainsAlpha, 0); aStream->endEncoding(className()); }
void js_register_PluginAppnextJS_PluginAppnext(JSContext *cx, JS::HandleObject global) { static JSClass PluginAgeCheq_class = { "PluginAppnext", JSCLASS_HAS_PRIVATE, nullptr }; jsb_sdkbox_PluginAppnext_class = &PluginAgeCheq_class; #if MOZJS_MAJOR_VERSION < 52 jsb_sdkbox_PluginAppnext_class->addProperty = JS_PropertyStub; jsb_sdkbox_PluginAppnext_class->delProperty = JS_DeletePropertyStub; jsb_sdkbox_PluginAppnext_class->getProperty = JS_PropertyStub; jsb_sdkbox_PluginAppnext_class->setProperty = JS_StrictPropertyStub; jsb_sdkbox_PluginAppnext_class->enumerate = JS_EnumerateStub; jsb_sdkbox_PluginAppnext_class->resolve = JS_ResolveStub; jsb_sdkbox_PluginAppnext_class->convert = JS_ConvertStub; jsb_sdkbox_PluginAppnext_class->finalize = js_PluginAppnextJS_PluginAppnext_finalize; jsb_sdkbox_PluginAppnext_class->flags = JSCLASS_HAS_RESERVED_SLOTS(2); #endif static JSPropertySpec properties[] = { JS_PS_END }; static JSFunctionSpec funcs[] = { JS_FS_END }; static JSFunctionSpec st_funcs[] = { JS_FN("hideAd", js_PluginAppnextJS_PluginAppnext_hideAd, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("cacheAd", js_PluginAppnextJS_PluginAppnext_cacheAd, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("showVideo", js_PluginAppnextJS_PluginAppnext_showVideo, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("refreshAds", js_PluginAppnextJS_PluginAppnext_refreshAds, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("isVideoReady", js_PluginAppnextJS_PluginAppnext_isVideoReady, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setRewardsRewardTypeCurrency", js_PluginAppnextJS_PluginAppnext_setRewardsRewardTypeCurrency, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("isAdReady", js_PluginAppnextJS_PluginAppnext_isAdReady, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("refreshVideo", js_PluginAppnextJS_PluginAppnext_refreshVideo, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("cacheVideo", js_PluginAppnextJS_PluginAppnext_cacheVideo, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("init", js_PluginAppnextJS_PluginAppnext_init, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setRewardsTransactionId", js_PluginAppnextJS_PluginAppnext_setRewardsTransactionId, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setRewardsUserId", js_PluginAppnextJS_PluginAppnext_setRewardsUserId, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("showAd", js_PluginAppnextJS_PluginAppnext_showAd, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setRewardsCustomParameter", js_PluginAppnextJS_PluginAppnext_setRewardsCustomParameter, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FN("setRewardsAmountRewarded", js_PluginAppnextJS_PluginAppnext_setRewardsAmountRewarded, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE), JS_FS_END }; JS::RootedObject parent_proto(cx, nullptr); JSObject* objProto = JS_InitClass( cx, global, parent_proto, jsb_sdkbox_PluginAppnext_class, dummy_constructor<sdkbox::PluginAppnext>, 0, // no constructor properties, funcs, NULL, // no static properties st_funcs); JS::RootedObject proto(cx, objProto); #if (SDKBOX_COCOS_JSB_VERSION >= 2) #if MOZJS_MAJOR_VERSION >= 52 jsb_register_class<sdkbox::PluginAppnext>(cx, jsb_sdkbox_PluginAppnext_class, proto); #else jsb_register_class<sdkbox::PluginAppnext>(cx, jsb_sdkbox_PluginAppnext_class, proto, JS::NullPtr()); #endif #else TypeTest<sdkbox::PluginAppnext> t; js_type_class_t *p; std::string typeName = t.s_name(); if (_js_global_type_map.find(typeName) == _js_global_type_map.end()) { p = (js_type_class_t *)malloc(sizeof(js_type_class_t)); p->jsclass = jsb_sdkbox_PluginAppnext_class; p->proto = objProto; p->parentProto = NULL; _js_global_type_map.insert(std::make_pair(typeName, p)); } #endif // add the proto and JSClass to the type->js info hash table JS::RootedValue className(cx); JSString* jsstr = JS_NewStringCopyZ(cx, "PluginAppnext"); className = JS::StringValue(jsstr); JS_SetProperty(cx, proto, "_className", className); JS_SetProperty(cx, proto, "__nativeObj", JS::TrueHandleValue); JS_SetProperty(cx, proto, "__is_ref", JS::FalseHandleValue); }
int JViewSet::compareTo(const JObject& s) const { if (className() != s.className()) return JObject::compareTo(s); return children.compareTo(((JViewSet*)&s)->children); }
int JDouble::compareTo(const JObject& s) const { if (className() != s.className()) return JObject::compareTo(s); return cmp(value, ((JDouble*)&s)->value); }
void Log::flush(std::ostringstream* out, const CallSite& site) { LogLock lock; if (!lock.ok()) { return; } Globals& g = Globals::get(); Settings& s = Settings::get(); std::string message = out->str(); if (out == &g.messageStream) { g.messageStream.clear(); g.messageStream.str(""); g.messageStreamInUse = false; } else { delete out; } if (site.mLevel == LEVEL_ERROR) { std::ostringstream fatalMessage; fatalMessage << abbreviateFile(site.mFile) << "(" << site.mLine << ") : error"; writeToRecorders(site.mLevel, fatalMessage.str()); } std::ostringstream prefix; switch (site.mLevel) { case LEVEL_DEBUG: prefix << "DEBUG: "; break; case LEVEL_INFO: prefix << "INFO: "; break; case LEVEL_WARN: prefix << "WARNING: "; break; case LEVEL_ERROR: prefix << "ERROR: "; break; default: prefix << "XXX: "; break; }; if (s.printLocation) { prefix << abbreviateFile(site.mFile) << "(" << site.mLine << ") : "; } #if LL_WINDOWS // DevStudio: __FUNCTION__ already includes the full class name #else #if LL_LINUX // gross, but typeid comparison seems to always fail here with gcc4.1 if (0 != strcmp(site.mClassInfo.name(), typeid(NoClassInfo).name())) #else if (site.mClassInfo != typeid(NoClassInfo)) #endif // LL_LINUX { prefix << className(site.mClassInfo) << "::"; } #endif prefix << site.mFunction << ": "; if (site.mPrintOnce) { std::map<std::string, unsigned int>::iterator messageIter = s.uniqueLogMessages.find(message); if (messageIter != s.uniqueLogMessages.end()) { messageIter->second++; unsigned int num_messages = messageIter->second; if (num_messages == 10 || num_messages == 50 || (num_messages % 100) == 0) { prefix << "ONCE (" << num_messages << "th time seen): "; } else { return; } } else { prefix << "ONCE: "; s.uniqueLogMessages[message] = 1; } } prefix << message; message = prefix.str(); writeToRecorders(site.mLevel, message); if (site.mLevel == LEVEL_ERROR && s.crashFunction) { s.crashFunction(message); } }
std::string ParserKeyword::createCode() const { std::stringstream ss; const std::string lhs = "keyword"; const std::string indent = " "; ss << className() << "::" << className() << "( ) : ParserKeyword(\"" << m_name << "\") {" << std::endl; { const std::string sizeString(ParserKeywordSizeEnum2String(m_keywordSizeType)); ss << indent; switch (m_keywordSizeType) { case SLASH_TERMINATED: ss << "setSizeType(" << sizeString << ");" << std::endl; break; case UNKNOWN: ss << "setSizeType(" << sizeString << ");" << std::endl; break; case FIXED: ss << "setFixedSize( (size_t) " << m_fixedSize << ");" << std::endl; break; case OTHER_KEYWORD_IN_DECK: ss << "setSizeType(" << sizeString << ");" << std::endl; ss << indent << "initSizeKeyword(\"" << m_sizeDefinitionPair.first << "\",\"" << m_sizeDefinitionPair.second << "\");" << std::endl; if (m_isTableCollection) ss << "setTableCollection( true );" << std::endl; break; } } ss << indent << "setDescription(\"" << getDescription() << "\");" << std::endl; // add the valid sections for the keyword ss << indent << "clearValidSectionNames();\n"; for (auto sectionNameIt = m_validSectionNames.begin(); sectionNameIt != m_validSectionNames.end(); ++sectionNameIt) { ss << indent << "addValidSectionName(\"" << *sectionNameIt << "\");" << std::endl; } // add the deck names ss << indent << "clearDeckNames();\n"; for (auto deckNameIt = m_deckNames.begin(); deckNameIt != m_deckNames.end(); ++deckNameIt) { ss << indent << "addDeckName(\"" << *deckNameIt << "\");" << std::endl; } // set the deck name match regex if (hasMatchRegex()) ss << indent << "setMatchRegex(\"" << m_matchRegexString << "\");" << std::endl; { if (m_records.size() > 0 ) { for( const auto& record : *this ) { const std::string local_indent = indent + " "; ss << indent << "{" << std::endl; ss << local_indent << "ParserRecord record;" << std::endl; for( const auto& item : record ) { ss << local_indent << "{" << std::endl; { std::string indent3 = local_indent + " "; ss << indent3 << item.createCode() << std::endl << indent3 << "item.setDescription(\"" << item.getDescription() << "\");" << std::endl; for (size_t idim=0; idim < item.numDimensions(); idim++) ss << indent3 <<"item.push_backDimension(\"" << item.getDimension( idim ) << "\");" << std::endl; { std::string addItemMethod = "addItem"; if (isDataKeyword()) addItemMethod = "addDataItem"; ss << indent3 << "record." << addItemMethod << "(item);" << std::endl; } } ss << local_indent << "}" << std::endl; } if (record.isDataRecord()) ss << local_indent << "addDataRecord( record );" << std::endl; else ss << local_indent << "addRecord( record );" << std::endl; ss << indent << "}" << std::endl; } } } ss << "}" << std::endl; ss << "const std::string " << className() << "::keywordName = \"" << getName() << "\";" << std::endl; for( const auto& record : *this ) { for( const auto& item : record ) { ss << item.inlineClassInit(className()); } } ss << std::endl; return ss.str(); }
std::string ParserKeyword::createDecl() const { return className() + "::" + className() + "()"; }
/*!\internal */ void QMetaObject::resolveProperty( QMetaProperty* prop ) { QMetaObject* super = superclass; while ( super ) { const QMetaProperty* p = super->property( prop->n ); if( p ) { if ( qstrcmp( prop->type(), p->type() ) != 0 ) { #if defined(CHECK_STATE) qWarning( "QMetaObject::resolveProperty: Attempt to override property type: %s %s::%s clashes with %s %s::%s", p->type(), super->className(), p->name(), prop->type(), className(), prop->name() ); #endif } if ( prop->get == 0 ) { if ( p->get != 0 ) { prop->get = p->get; prop->gspec = p->gspec; } } if ( prop->set == 0 ) { if ( p->set != 0 ) { prop->set = p->set; prop->sspec = p->sspec; } } if ( prop->testFlags( QMetaProperty::UnresolvedStored ) ) { if ( !p->testFlags( QMetaProperty::UnresolvedStored ) ) { prop->clearFlags( QMetaProperty::UnresolvedStored ); if ( p->testFlags( QMetaProperty::NotStored ) ) prop->setFlags( QMetaProperty::NotStored ); prop->store = p->store; } } if ( prop->testFlags( QMetaProperty::UnresolvedDesignable ) ) { if ( !p->testFlags( QMetaProperty::UnresolvedDesignable ) ) { prop->clearFlags( QMetaProperty::UnresolvedDesignable ); if ( p->testFlags( QMetaProperty::NotDesignable ) ) prop->setFlags( QMetaProperty::NotDesignable ); } } } if ( prop->testFlags( QMetaProperty::UnresolvedEnum | QMetaProperty::UnresolvedSet | QMetaProperty::UnresolvedEnumOrSet ) ) { QMetaEnum* e = super->enumerator( prop->t); if ( e && e->set ) { if ( !prop->testFlags( QMetaProperty::UnresolvedSet | QMetaProperty::UnresolvedEnumOrSet ) ) { #if defined(CHECK_STATE) qWarning("QMetaObject::resolveProperty: The property %s %s::%s assumed that '%s' was listed in Q_ENUMS, but it was listed in Q_SETS", prop->type(), className(), prop->name(), prop->type() ); #endif } prop->enumData = e; prop->clearFlags( QMetaProperty::UnresolvedEnum ); } else if ( e && !e->set ) { if ( !prop->testFlags( QMetaProperty::UnresolvedEnum | QMetaProperty::UnresolvedEnumOrSet ) ) { #if defined(CHECK_STATE) qWarning("QMetaObject::resolveProperty: The property %s %s::%s assumed that '%s' was listed in Q_SETS, but it was listed in Q_ENUMS", prop->type(), className(), prop->name(), prop->type() ); #endif } prop->enumData = e; prop->clearFlags( QMetaProperty::UnresolvedEnum ); } } super = super->superclass; } if ( !prop->isValid() ) { #if defined(CHECK_STATE) qWarning("QMetaObject::resolveProperty: Could not resolve property %s::%s. Property not available.", className(), prop->name() ); #endif } }
static void marshall_basetype(Marshall *m) { switch(m->type().element()) { case Smoke::t_bool: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (!value.isBool()) { m->item().s_bool = false; } else { m->item().s_bool = value.toBool(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_bool); break; default: m->unsupported(); break; } break; case Smoke::t_char: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_char = 0; } else { m->item().s_char = (char) value.toInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_char); break; default: m->unsupported(); break; } break; case Smoke::t_uchar: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_uchar = 0; } else { m->item().s_uchar = (uchar) value.toUInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_uchar); break; default: m->unsupported(); break; } break; case Smoke::t_short: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_short = 0; } else { m->item().s_short = (short) value.toInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_short); break; default: m->unsupported(); break; } break; case Smoke::t_ushort: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_ushort = 0; } else { m->item().s_ushort = value.toUInt16(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_ushort); break; default: m->unsupported(); break; } break; case Smoke::t_int: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_int = 0; } else { m->item().s_int = value.toInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_int); break; default: m->unsupported(); break; } break; case Smoke::t_uint: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_uint = 0; } else { m->item().s_uint = value.toUInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_uint); break; default: m->unsupported(); break; } break; case Smoke::t_long: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_long = 0; } else { m->item().s_long = (long) value.toInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), (int) m->item().s_long); break; default: m->unsupported(); break; } break; case Smoke::t_ulong: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_ulong = 0; } else { m->item().s_ulong = (ulong) value.toUInt32(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), (uint) m->item().s_ulong); break; default: m->unsupported(); break; } break; case Smoke::t_float: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_float = 0.0; } else { m->item().s_float = (float) value.toNumber(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_float); break; default: m->unsupported(); break; } break; case Smoke::t_double: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_double = 0.0; } else { m->item().s_double = value.toNumber(); } break; } case Marshall::ToQScriptValue: *(m->var()) = QScriptValue(m->engine(), m->item().s_double); break; default: m->unsupported(); break; } break; case Smoke::t_enum: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_enum = 0; } else if (value.instanceOf(JSmoke::Global::QtEnum)) { m->item().s_enum = value.property("value").toUInt32(); } else { m->item().s_enum = value.toUInt32(); } break; } case Marshall::ToQScriptValue: { QScriptValueList args; args << (uint) m->item().s_enum << m->type().name(); *(m->var()) = JSmoke::Global::QtEnum.call(QScriptValue(), args); break; } default: m->unsupported(); break; } break; case Smoke::t_class: switch(m->action()) { case Marshall::FromQScriptValue: { QScriptValue value = *(m->var()); if (value.isNull()) { m->item().s_class = 0; return; } if (value.isDate()) { Smoke::ModuleIndex classId = Smoke::findClass(m->smoke()->classes[m->type().classId()].className); if (classId == JSmoke::Global::QDateClassId) { m->item().s_class = new QDate(value.toDateTime().date()); } else if (classId == JSmoke::Global::QDateTimeClassId) { m->item().s_class = new QDateTime(value.toDateTime()); } else if (classId == JSmoke::Global::QTimeClassId) { m->item().s_class = new QTime(value.toDateTime().time()); } else { m->item().s_class = 0; } return; } else if (value.isRegExp()) { m->item().s_class = new QRegExp(value.toRegExp()); return; } if (!Object::Instance::isSmokeObject(value)) { m->item().s_class = 0; return; } Object::Instance * instance = Object::Instance::get(value); void * ptr = instance->value; if (!m->cleanup() && m->type().isStack()) { ptr = constructCopy(instance); } ptr = instance->classId.smoke->cast( ptr, instance->classId, Smoke::ModuleIndex(m->smoke(), m->type().classId()) ); m->item().s_class = ptr; break; } case Marshall::ToQScriptValue: { if (m->item().s_voidp == 0) { *(m->var()) = m->engine()->nullValue(); return; } void * ptr = m->item().s_voidp; QScriptValue * value = JSmoke::Global::getScriptValue(ptr); if (value != 0) { *(m->var()) = *value; return ; } QByteArray className(m->smoke()->classes[m->type().classId()].className); QScriptValue obj = Global::wrapInstance( m->engine(), Smoke::findClass(className), ptr, QScriptEngine::QtOwnership ); if (m->type().isConst() && m->type().isRef()) { Object::Instance * instance = Object::Instance::get(obj); ptr = constructCopy(instance); if (ptr != 0) { instance->value = ptr; instance->ownership = QScriptEngine::ScriptOwnership; Global::mapPointer(new QScriptValue(obj), instance, instance->classId); } } *(m->var()) = obj; break; } default: m->unsupported(); break; } break; default: m->unsupported(); break; } }
void Log::flush(std::ostringstream* out, const CallSite& site) { LogLock lock; if (!lock.ok()) { return; } std::string message = out->str(); { AIAccess<Globals> globals(Globals::get()); if (out == &globals->messageStream) { globals->messageStream.clear(); globals->messageStream.str(""); globals->messageStreamInUse = false; } else { delete out; } } AIAccess<Settings> settings_w(Settings::get()); if (site.mLevel == LEVEL_ERROR) { std::ostringstream fatalMessage; fatalMessage << abbreviateFile(site.mFile) << "(" << site.mLine << ") : error"; writeToRecorders(settings_w, site.mLevel, fatalMessage.str()); } std::ostringstream prefix; switch (site.mLevel) { case LEVEL_DEBUG: prefix << "DEBUG: "; break; case LEVEL_INFO: prefix << "INFO: "; break; case LEVEL_WARN: prefix << "WARNING: "; break; case LEVEL_ERROR: prefix << "ERROR: "; break; default: prefix << "XXX: "; break; }; if (settings_w->printLocation) { prefix << abbreviateFile(site.mFile) << "(" << site.mLine << ") : "; } #if LL_WINDOWS // DevStudio: __FUNCTION__ already includes the full class name #else if (site.mClassInfo != typeid(NoClassInfo)) { prefix << className(site.mClassInfo) << "::"; } #endif prefix << site.mFunction << ": "; if (site.mPrintOnce) { std::map<std::string, unsigned int>::iterator messageIter = settings_w->uniqueLogMessages.find(message); if (messageIter != settings_w->uniqueLogMessages.end()) { messageIter->second++; unsigned int num_messages = messageIter->second; if (num_messages == 10 || num_messages == 50 || (num_messages % 100) == 0) { prefix << "ONCE (" << num_messages << "th time seen): "; } else { return; } } else { prefix << "ONCE: "; settings_w->uniqueLogMessages[message] = 1; } } if (site.mPrintOnce) { std::map<std::string, unsigned int>::iterator messageIter = settings_w->uniqueLogMessages.find(message); if (messageIter != settings_w->uniqueLogMessages.end()) { messageIter->second++; unsigned int num_messages = messageIter->second; if (num_messages == 10 || num_messages == 50 || (num_messages % 100) == 0) { prefix << "ONCE (" << num_messages << "th time seen): "; } else { return; } } else { prefix << "ONCE: "; settings_w->uniqueLogMessages[message] = 1; } } prefix << message; message = prefix.str(); writeToRecorders(settings_w, site.mLevel, message); if (site.mLevel == LEVEL_ERROR && settings_w->crashFunction) { settings_w->crashFunction(message); } }
GAGenome* GAGenome::clone(CloneMethod) const { GAErr(GA_LOC, className(), "clone", gaErrOpUndef); return new GAGenome(*this); }
// Function: mdlInitializeSizes =============================================== // Abstract: // The sizes information is used by Simulink to determine the S-function // block's characteristics (number of inputs, s, states, etc.). static void mdlInitializeSizes(SimStruct *S) { static char errorBuffer[512]; if (ssGetSFcnParamsCount(S) < 1) { sprintf(errorBuffer, "%s", "The block type parameter must be specified"); ssSetErrorStatus(S, errorBuffer); return; } char *classNameStr = mxArrayToString(ssGetSFcnParam(S, 0)); std::string className(classNameStr); mxFree(classNameStr); wbt::Block *block = wbt::Block::instantiateBlockWithClassName(className); //We cannot save data in PWork during the initializeSizes phase ssSetNumPWork(S, 1); if (!block) { sprintf(errorBuffer, "Could not create an object of type %s", className.c_str()); ssSetErrorStatus(S, errorBuffer); return; } ssSetNumSFcnParams(S, 1 + block->numberOfParameters()); ssSetSFcnParamTunable(S, 0, false); for (unsigned i = 1; i < ssGetNumSFcnParams(S); ++i) { bool tunable = false; block->parameterAtIndexIsTunable(i - 1, tunable); ssSetSFcnParamTunable(S, i, tunable); } #if defined(MATLAB_MEX_FILE) if(ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)){ mdlCheckParameters(S); if(ssGetErrorStatus(S)){ return; } } else{ sprintf(errorBuffer, "%s", "Number of parameters different from those defined"); ssSetErrorStatus(S, errorBuffer); return; } #endif wbt::Error error; if (!block->configureSizeAndPorts(S, &error)) { sprintf(errorBuffer, "%s", error.message.substr(0, 511).c_str()); ssSetErrorStatus(S, errorBuffer); return; } ssSetNumSampleTimes(S, 1); ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE); //?? ssSetNumDiscStates(S, block->numberOfDiscreteStates()); ssSetNumContStates(S, 0);//block->numberOfContinuousStates()); uint_T options = SS_OPTION_WORKS_WITH_CODE_REUSE | SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_ALLOW_INPUT_SCALAR_EXPANSION | SS_OPTION_USE_TLC_WITH_ACCELERATOR | SS_OPTION_CALL_TERMINATE_ON_EXIT; //also ? //SS_OPTION_RUNTIME_EXCEPTION_FREE_CODE options |= block->additionalBlockOptions(); ssSetOptions(S, options); delete block; }
void Task::debug(const QString &str) { client()->debug(QString("%1: ").arg(className()) + str); }
bool f_defined(CStrRef name, bool autoload /* = true */) { if (!name.get()) return false; const char *data = name.data(); int len = name.length(); char *colon; if ((colon = (char*)memchr(data, ':', len)) && colon[1] == ':') { // class constant int classNameLen = colon - data; char *constantName = colon + 2; String className(data, classNameLen, CopyString); // translate "self" or "parent" if (className == "self") { String this_class = hhvm ? g_vmContext->getContextClassName() : FrameInjection::GetClassName(true); if (this_class.empty()) { throw FatalErrorException("Cannot access self:: " "when no class scope is active"); } else { className = this_class; } } else if (className == "parent") { String parent_class = hhvm ? g_vmContext->getParentContextClassName() : FrameInjection::GetParentClassName(true); if (parent_class.empty()) { throw FatalErrorException("Cannot access parent"); } else { className = parent_class; } } if (class_exists(className)) { // taking care of volatile class const ClassInfo *info; for (String parentClass = className; !parentClass.empty(); parentClass = info->getParentClass()) { info = ClassInfo::FindClass(parentClass); if (!info) { assert(false); } if (info->hasConstant(constantName)) return true; } return false; } else { return false; } } else { // system/uniquely defined scalar constant if (ClassInfo::FindConstant(name)) return true; if (hhvm ? g_vmContext->defined(name) : ((Globals*)get_global_variables())->defined(name)) { return true; } if (!autoload || !AutoloadHandler::s_instance->autoloadConstant(name)) { return false; } if (hhvm) return g_vmContext->defined(name); if (ClassInfo::FindConstant(name)) return true; return ((Globals*)get_global_variables())->defined(name); } }
void Editor::slot_ObjectList_MenuRequest( const QPoint& p ) { if(ui.widgetListObj->itemAt(p) == nullptr) return; static QMenu mainMenu; static bool firstExex = true; static QAction* actionDelObj = nullptr; if(firstExex) { firstExex = false; actionDelObj = mainMenu.addAction("Delete"); static QMenu* menuAddComp = mainMenu.addMenu("Add Component"); static QVector<QMenu*> listMenuCompPack; auto ci = CGame::GetComponentClassHead(); while(ci) { for(auto iter = listMenuCompPack.begin(); iter != listMenuCompPack.end(); iter++) { if(ci->packName() == (*iter)->title()) { if(ci->showInEd()) (*iter)->addAction(ci->className()); goto SEC1; } } if(ci->showInEd()) { QMenu* newMenu = menuAddComp->addMenu(ci->packName()); newMenu->addAction(ci->className()); listMenuCompPack.push_back(newMenu); } SEC1: ci = ci->next(); } } QAction* actionRet = mainMenu.exec(ui.widgetListObj->mapToGlobal(p)); if(actionRet) { if(actionRet == actionDelObj) { CGameObject* obj = CGame::GetObjByIndex(ui.widgetListObj->currentRow()); obj->destroy(); delete ui.widgetListObj->takeItem(ui.widgetListObj->currentRow()); Editor::SelectObj(nullptr); } else { CGameObject* obj = CGame::GetObjByIndex(ui.widgetListObj->currentRow()); obj->addComponent(actionRet->text().toAscii().data()); Editor::SelectObj(obj); } CGame::EDTick(); } }
double NodeMatcher::scorePair(long nid1, long nid2) { ConstNodePtr n1 = _map->getNode(nid1); ConstNodePtr n2 = _map->getNode(nid2); const set<long>& wids1 = _map->getIndex().getNodeToWayMap()->at(nid1); const set<long>& wids2 = _map->getIndex().getNodeToWayMap()->at(nid2); double acc = 0; for (set<long>::const_iterator it = wids1.begin(); it != wids1.end(); ++it) { acc = max(acc, _map->getWay(*it)->getCircularError()); } for (set<long>::const_iterator it = wids2.begin(); it != wids2.end(); ++it) { acc = max(acc, _map->getWay(*it)->getCircularError()); } vector<Radians> theta1 = calculateAngles(_map.get(), nid1, wids1, _delta); vector<Radians> theta2 = calculateAngles(_map.get(), nid2, wids2, _delta); int s1 = theta1.size(); int s2 = theta2.size(); if (s1 < 3 || s2 < 3) { return 0.0; } double d = n1->toCoordinate().distance(n2->toCoordinate()); // TODO: this isnt right; Talk to mike double distanceScore = 1 - (Normal::phi(d, acc * 1.5) - 0.5) * 2.0; LOG_VART(nid1); LOG_VART(nid2); LOG_VART(distanceScore); LOG_VART(acc); LOG_VART(d); LOG_VART(Normal::phi(d, acc * 1.5)); LOG_VART(Normal::phi(d, acc / 2.0)); if (theta1.size() < theta2.size()) { swap(theta1, theta2); } double thetaScore; // this is very unsual and will slow things down. if (theta1.size() > 6 && theta2.size() > 6) { if (logWarnCount < Log::getWarnMessageLimit()) { LOG_WARN("Greater than seven intersections at one spot? Odd. Giving it a high angleScore."); } else if (logWarnCount == Log::getWarnMessageLimit()) { LOG_WARN(className() << ": " << Log::LOG_WARN_LIMIT_REACHED_MESSAGE); } logWarnCount++; LOG_VART(nid1); LOG_VART(nid2); LOG_VART(wids1); LOG_VART(wids2); thetaScore = 1.0; } else { if (theta2.size() < theta1.size()) { vector<bool> exclude(theta2.size(), false); thetaScore = _calculateAngleScore(theta2, theta1, exclude, 0); } else { vector<bool> exclude(theta1.size(), false); thetaScore = _calculateAngleScore(theta1, theta2, exclude, 0); } } // simple stupid heuristic. Replace w/ some cosine fanciness later. int diff = abs((int)s1 - (int)s2); double result = (min(s1, s2) - diff) * thetaScore * distanceScore; LOG_VART(result); return result; }
void VCWidget::editProperties() { QMessageBox::information(_app, className(), "This widget has no properties"); }
/* ** Window procedure for the reciever window. ** */ LRESULT CALLBACK PlayerCAD::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { static PlayerCAD* player; switch (msg) { case WM_CREATE: { // Get pointer to the PlayerCAD class from the CreateWindow call player = (PlayerCAD*)((CREATESTRUCT*)lParam)->lpCreateParams; return 0; } case WM_DESTROY: { SendMessage(player->m_PlayerWindow, WM_USER, 0, IPC_SHUTDOWN_NOTIFICATION); return 0; } case WM_USER: switch (lParam) { case IPC_TRACK_CHANGED_NOTIFICATION: { PostMessage(player->m_PlayerWindow, WM_USER, 0, IPC_GET_CURRENT_TRACK); break; } case IPC_STATE_CHANGED_NOTIFICATION: { player->m_State = (StateType)wParam; if (player->m_State == STATE_STOPPED) { player->ClearData(false); } break; } case IPC_VOLUME_CHANGED_NOTIFICATION: { player->m_Volume = (UINT)wParam; break; } case IPC_REPEAT_CHANGED_NOTIFICATION: { player->m_Repeat = wParam != 0; break; } case IPC_SHUFFLE_CHANGED_NOTIFICATION: { player->m_Shuffle = wParam != 0; break; } case IPC_RATING_CHANGED_NOTIFICATION: { player->m_Rating = ((UINT)wParam + 1) / 2; // From 0 - 10 to 0 - 5 break; } case IPC_SHUTDOWN_NOTIFICATION: { player->m_Initialized = false; player->ClearData(); break; } } return 0; case WM_COPYDATA: { PCOPYDATASTRUCT cds = (PCOPYDATASTRUCT)lParam; if (cds->dwData == IPC_CURRENT_TRACK_NOTIFICATION) { player->m_Shuffle = SendMessage(player->m_PlayerWindow, WM_USER, 0, IPC_GET_SHUFFLE) != 0; player->m_Repeat = SendMessage(player->m_PlayerWindow, WM_USER, 0, IPC_GET_REPEAT) != 0; // TODO: Sent on track update? ++player->m_TrackCount; WCHAR* data = (WCHAR*)cds->lpData; WCHAR* pos; UINT index = 1; while ((pos = wcschr(data, '\t')) != nullptr) { switch (index) { case 1: player->m_Title.assign(data, pos - data); break; case 2: player->m_Artist.assign(data, pos - data); break; case 3: player->m_Album.assign(data, pos - data); break; case 4: player->m_Genre.assign(data, pos - data); break; case 5: player->m_Year = (UINT)_wtoi(data); break; case 7: player->m_Number = (UINT)_wtoi(data); break; case 8: player->m_Duration = (UINT)_wtoi(data); break; case 9: player->m_FilePath.assign(data, pos - data); break; case 10: player->m_Rating = ((UINT)_wtoi(data) + 1) / 2; // 0 - 10 -> 0 - 5 break; case 11: if (*data == L' ') { player->FindCover(); } else { player->m_CoverPath.assign(data, pos - data); } break; } data = pos + 1; ++index; if (index == 12) { break; } } if (player->m_Measures & MEASURE_LYRICS) { player->FindLyrics(); } } else if (cds->dwData == IPC_NEW_COVER_NOTIFICATION) { WCHAR* data = (WCHAR*)cds->lpData; if (data) { player->m_CoverPath.assign(data); } } else if (cds->dwData == IPC_REGISTER_NOTIFICATION && !player->m_Initialized) { std::wstring data = (WCHAR*)cds->lpData; if (data[0] == L'1') { data.erase(0, 2); // Get rid of the 1\t at the beginning std::wstring::size_type len = data.find_first_of(L'\t'); std::wstring className(data, 0, len); data.erase(0, ++len); len = data.find_first_of(L'\t'); std::wstring windowName(data, 0, len); data.erase(0, ++len); len = data.find_first_of(L'\t'); player->m_PlayerPath.assign(data, 0, len); data.erase(0, ++len); LPCTSTR classSz = className.empty() ? nullptr : className.c_str(); LPCTSTR windowSz = windowName.empty() ? nullptr : windowName.c_str(); LPCTSTR file = RmGetSettingsFile(); WritePrivateProfileString(L"NowPlaying.dll", L"ClassName", classSz, file); WritePrivateProfileString(L"NowPlaying.dll", L"WindowName", windowSz, file); WritePrivateProfileString(L"NowPlaying.dll", L"PlayerPath", player->m_PlayerPath.c_str(), file); player->m_PlayerWindow = FindWindow(classSz, windowSz); if (player->m_PlayerWindow) { player->m_Initialized = true; player->m_ExtendedAPI = (classSz && wcscmp(classSz, L"CD Art Display IPC Class") == 0); player->m_State = (StateType)SendMessage(player->m_PlayerWindow, WM_USER, 0, IPC_GET_STATE); if (player->m_State != STATE_STOPPED) { PostMessage(player->m_PlayerWindow, WM_USER, 0, IPC_GET_CURRENT_TRACK); } if (player->m_Open) { if (windowSz && wcscmp(windowSz, L"foobar2000") == 0) { // Activate foobar2000 in case it starts minimized SendMessage(player->m_PlayerWindow, WM_USER, 0, IPC_SHOW_WINDOW); } player->m_Open = false; } } } } } return 0; default: return DefWindowProc(hwnd, msg, wParam, lParam); } }
int JComplex::compareTo(const JObject& s) const { if (className() != s.className()) return JObject::compareTo(s); return cmp(value.norm(), ((JComplex*)&s)->value.norm()); }
void JensonTests::testSerializationFailures() { // // Test deserialization failure and error message for empty JSON object // QJsonObject json; QString errorMsg; QVERIFY(errorMsg.isEmpty()); sptr<QObject> qObj = jenson::JenSON::deserializeToObject(&json, &errorMsg); QVERIFY(qObj == 0); QVERIFY(!errorMsg.isEmpty()); // Test exception version QTR_ASSERT_THROW(jenson::JenSON::deserializeToObject(&json), jenson::SerializationException) // // Test deserialization failure and error message for unkown JSON object // QString errorMsg2; QString className("NotRegisteredClass"); json.insert(className, QJsonValue()); qObj = jenson::JenSON::deserializeToObject(&json, &errorMsg2); QVERIFY(qObj == 0); QVERIFY(errorMsg != errorMsg2); QVERIFY(errorMsg2.contains(className)); // Test exception version QTR_ASSERT_THROW(jenson::JenSON::deserializeToObject(&json), jenson::SerializationException) // // Test deserialization failure on non-resetable missing field // QString errorMsg3; Testobject p(0.2, -5.3); QJsonObject json2 = jenson::JenSON::serialize(&p); QJsonObject pObj = json2[jenson::JenSON::toSerialName(p.metaObject()->className())].toObject(); pObj.remove("x"); json2[jenson::JenSON::toSerialName(p.metaObject()->className())] = pObj; qObj = jenson::JenSON::deserializeToObject(&json2, &errorMsg3); QVERIFY(qObj == 0); QVERIFY(errorMsg2 != errorMsg3); QVERIFY(errorMsg3.contains("x")); // Test exception version QTR_ASSERT_THROW(jenson::JenSON::deserializeToObject(&json2), jenson::SerializationException) // // Test exception on cast failure // QJsonObject json3 = jenson::JenSON::serialize(&p); QTR_ASSERT_THROW(sptr<Nestedobject> invalidCast = jenson::JenSON::deserialize<Nestedobject>(&json3), jenson::SerializationException) }
// We don't define this one apriori. Do it in a specialization. template <class T> int GA1DArrayGenome<T>::read(STD_ISTREAM &) { GAErr(GA_LOC, className(), "read", gaErrOpUndef); return 1; }
void FSPlaceObject2::decodeFromStream(FSInputStream* aStream) { bool containsClipEvents = false; bool containsClippingDepth = false; bool containsName = false; bool containsRatio = false; bool containsColorTransform = false; bool containsTransform = false; aStream->startDecoding(className()); FSMovieObject::decodeFromStream(aStream); aStream->setContext(FSStream::ColorContainsAlpha, 1); containsClipEvents = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; containsClippingDepth = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; containsName = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; containsRatio = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; containsColorTransform = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; containsTransform = aStream->read(FSStream::UnsignedBit, 1) != 0 ? true : false; place = aStream->read(FSStream::UnsignedBit, 2); layer = aStream->read(FSStream::UnsignedWord, 16); if (place == New || place == Replace) identifier = aStream->read(FSStream::UnsignedWord, 16); else aStream->read(FSStream::UnsignedWord, 0); if (containsTransform) transform.decodeFromStream(aStream); else aStream->read(FSStream::UnsignedWord, 0); aHaveTransform = containsTransform; if (containsColorTransform) colorTransform.decodeFromStream(aStream); else aStream->read(FSStream::UnsignedWord, 0); aHaveColorTransform = containsColorTransform; if (containsRatio) ratio = aStream->read(FSStream::UnsignedWord, 16) / 65535.0f; else aStream->read(FSStream::UnsignedWord, 0); if (containsName) { const char* str = aStream->readString(); name = str; delete [] str; } else { aStream->read(0); } if (containsClippingDepth) depth = aStream->read(FSStream::UnsignedWord, 16) - 1; else aStream->read(FSStream::UnsignedWord, 0); if (containsClipEvents) { int eventSize = aStream->getContext(FSStream::Version) > 5 ? 32 : 16; aStream->read(FSStream::UnsignedWord, 16); aStream->read(FSStream::UnsignedWord, eventSize); #ifdef _DEBUG aStream->startDecoding("array"); #endif while (aStream->scan(FSStream::UnsignedWord, eventSize)) { aStream->setCursor(aStream->getCursor()-eventSize); events.push_back(FSClipEvent(aStream)); } #ifdef _DEBUG aStream->endDecoding("array"); #endif } aStream->setContext(FSStream::ColorContainsAlpha, 0); aStream->endDecoding(className()); }
const std::string Component::to_string() const noexcept { std::stringstream str; str<<className()<<":: id: "<<getId()<<" active: "<<isActive()<<" "<<getTransform()->to_string()<<" sort value: "<<getValueForSorting(); return str.str(); }
// Get length of class name in characters (not bytes) int Window::classNameLength() const { return className().length(); }
void Juigetfile::uiputfile (JavaVM * jvm_, char const* const* mask, int maskSize, char const* const* description, int descriptionSize, char const* initialDirectory, char const* boxtTitle, bool multipleSelection){ JNIEnv * curEnv = NULL; jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL); jclass cls = curEnv->FindClass( className().c_str() ); jmethodID voiduiputfilejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID = curEnv->GetStaticMethodID(cls, "uiputfile", "([Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V" ) ; if (voiduiputfilejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID == NULL) { throw GiwsException::JniMethodNotFoundException(curEnv, "uiputfile"); } jclass stringArrayClass = curEnv->FindClass("java/lang/String"); // create java array of strings. jobjectArray mask_ = curEnv->NewObjectArray( maskSize, stringArrayClass, NULL); if (mask_ == NULL) { throw GiwsException::JniBadAllocException(curEnv); } // convert each char * to java strings and fill the java array. for ( int i = 0; i < maskSize; i++) { jstring TempString = curEnv->NewStringUTF( mask[i] ); if (TempString == NULL) { throw GiwsException::JniBadAllocException(curEnv); } curEnv->SetObjectArrayElement( mask_, i, TempString); // avoid keeping reference on to many strings curEnv->DeleteLocalRef(TempString); } // create java array of strings. jobjectArray description_ = curEnv->NewObjectArray( descriptionSize, stringArrayClass, NULL); if (description_ == NULL) { throw GiwsException::JniBadAllocException(curEnv); } // convert each char * to java strings and fill the java array. for ( int i = 0; i < descriptionSize; i++) { jstring TempString = curEnv->NewStringUTF( description[i] ); if (TempString == NULL) { throw GiwsException::JniBadAllocException(curEnv); } curEnv->SetObjectArrayElement( description_, i, TempString); // avoid keeping reference on to many strings curEnv->DeleteLocalRef(TempString); } jstring initialDirectory_ = curEnv->NewStringUTF( initialDirectory ); if (initialDirectory != NULL && initialDirectory_ == NULL) { throw GiwsException::JniBadAllocException(curEnv); } jstring boxtTitle_ = curEnv->NewStringUTF( boxtTitle ); if (boxtTitle != NULL && boxtTitle_ == NULL) { throw GiwsException::JniBadAllocException(curEnv); } jboolean multipleSelection_ = (static_cast<bool>(multipleSelection) ? JNI_TRUE : JNI_FALSE); curEnv->CallStaticVoidMethod(cls, voiduiputfilejobjectArray_java_lang_Stringjava_lang_StringjobjectArray_java_lang_Stringjava_lang_Stringjstringjava_lang_Stringjstringjava_lang_StringjbooleanbooleanID ,mask_, description_, initialDirectory_, boxtTitle_, multipleSelection_); curEnv->DeleteLocalRef(stringArrayClass); curEnv->DeleteLocalRef(mask_); curEnv->DeleteLocalRef(description_); curEnv->DeleteLocalRef(initialDirectory_); curEnv->DeleteLocalRef(boxtTitle_); curEnv->DeleteLocalRef(cls); if (curEnv->ExceptionCheck()) { throw GiwsException::JniCallMethodException(curEnv); } }