示例#1
0
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;
}
示例#2
0
/*! \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;
}
示例#3
0
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");
}
示例#4
0
	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;
	}
示例#5
0
文件: llerror.cpp 项目: Boy/netbook
	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);
}
示例#8
0
int JViewSet::compareTo(const JObject& s) const {
  if (className() != s.className())
    return JObject::compareTo(s);
  return children.compareTo(((JViewSet*)&s)->children);
}
示例#9
0
int JDouble::compareTo(const JObject& s) const {
  if (className() != s.className()) 
    return JObject::compareTo(s);
  return cmp(value, ((JDouble*)&s)->value);
}
示例#10
0
	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);
		}
	}
示例#11
0
    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();
    }
示例#12
0
 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
    }
}
示例#14
0
文件: handlers.cpp 项目: KDE/jsmoke
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;
    }
}
示例#15
0
	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);
		}
	}
示例#16
0
文件: GAGenome.C 项目: pemryan/GAlib
GAGenome*
GAGenome::clone(CloneMethod) const
{
    GAErr(GA_LOC, className(), "clone", gaErrOpUndef);
    return new GAGenome(*this);
}
示例#17
0
// 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;

}
示例#18
0
void Task::debug(const QString &str)
{
	client()->debug(QString("%1: ").arg(className()) + str);
}
示例#19
0
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);
  }
}
示例#20
0
文件: editor.cpp 项目: UFNHGGI/CBGE
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();
	}
}
示例#21
0
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;
}
示例#22
0
文件: vcwidget.cpp 项目: speakman/qlc
void VCWidget::editProperties()
{
	QMessageBox::information(_app, className(),
				 "This widget has no properties");
}
示例#23
0
/*
** 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);
	}
}
示例#24
0
int JComplex::compareTo(const JObject& s) const {
  if (className() != s.className()) 
    return JObject::compareTo(s);
  return cmp(value.norm(), ((JComplex*)&s)->value.norm());
}
示例#25
0
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());
    }
示例#28
0
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();
}
示例#29
0
// Get length of class name in characters (not bytes)
int Window::classNameLength() const
{
	return className().length();
}
示例#30
0
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);
}
}