예제 #1
0
JNIEXPORT void JNICALL NAME(nativeSetDataSource)(JNIEnv *env, jobject thiz, jstring path)
{
    libvlc_instance_t *instance = (libvlc_instance_t *) getIntValue(env, thiz, "mLibVlcInstance");
    libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
    const char *str = (*env)->GetStringUTFChars(env, path, 0);
    if (!str)
    {
        /* XXX: throw */
        return;
    }
    libvlc_media_t *media = (*str == '/') ? libvlc_media_new_path(instance, str) : libvlc_media_new_location(instance, str);
    if (media)
    {
        libvlc_event_manager_t *em = libvlc_media_event_manager(media);
        for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++)
        {
            libvlc_event_attach(em, md_listening[i], vlc_event_callback, thiz);
        }
        /* this will cancel current input and start a new one */
        libvlc_media_player_set_media(mp, media);
        setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
    }
    (*env)->ReleaseStringUTFChars(env, path, str);
    setIntValue(env, thiz, "mLibVlcMedia", (jint) media);
}
예제 #2
0
void CStateDB::restoreCollection(CSession * const session) {
	if(m_db == 0) throw(CApiMisuseException("Calling restoreCollection(), but DB not opened."));
	bool found;

	int minRev =  getIntValue("CollectionRevMin", found);
	assert(found);
	int maxRev = getIntValue("CollectionRevMax", found);
	assert(found);

	session->setMinCollectionRevision( minRev );

	for(int rev = minRev; rev <= maxRev; rev++) {
		CCollection<CCollectionItem>* collection = new CCollection<CCollectionItem>(rev);

		CCollectionItem* item;
		int pos = 0;
		do {
			item = getCollectionItemByPos(pos, rev);
			pos++;
			if(item) {
				collection->insert(item);
			}
		} while(item != 0);
		session->addCollectionRev(collection);
	}
}
예제 #3
0
static QVariant fcnSubstr( const QVariantList& values, QgsFeature* , QgsExpression* parent )
{
  QString str = getStringValue( values.at( 0 ), parent );
  int from = getIntValue( values.at( 1 ), parent );
  int len = getIntValue( values.at( 2 ), parent );
  return QVariant( str.mid( from -1, len ) );
}
예제 #4
0
void CStateDB::restoreNextlists(CSession * const session) {
	if(m_db == 0) throw(CApiMisuseException("Calling restoreNextlists(), but DB not opened."));
	bool found;

	int minRev = getIntValue("NextlistRevMin", found);
	assert(found);
	int maxRev = getIntValue("NextlistRevMax", found);
	assert(found);

	session->setMinNextlistRevision( minRev );

	for(int rev = minRev; rev < maxRev; rev++) {
		CCollection<CPlaylistItem>* nextlist = new CCollection<CPlaylistItem>(rev);

		CPlaylistItem* item;
		int pos = 0;
		do {
			item = getNextlistItemByPos(pos, rev);
			pos++;
			if(item) {
				nextlist->insert(item);
			}
		} while(item != 0);
		session->addNextlistRev(nextlist);
	}
}
예제 #5
0
bool ECLlocation::extractLocationAttr(const IHqlExpression * location)
{
    if (!location)
    {
        clear();
        return false;
    }
    if (location->isAttribute())
    {
        if (location->queryName() != _location_Atom)
            return false;

        IHqlExpression * sourceExpr = location->queryChild(3);
        if (sourceExpr)
            sourcePath = static_cast<ISourcePath *>(sourceExpr->queryUnknownExtra());
        else
            sourcePath = NULL;
        lineno = (int)getIntValue(location->queryChild(0));
        column = (int)getIntValue(location->queryChild(1));
        position = (int)getIntValue(location->queryChild(2));
        return true;
    }
    IHqlExpression * annotation = queryLocation(const_cast<IHqlExpression *>(location));
    if (annotation)
    {
        sourcePath = annotation->querySourcePath();
        lineno = annotation->getStartLine();
        column = annotation->getStartColumn();
        position = 0;
        return true;
    }
    return false;
}
예제 #6
0
IHqlExpression * CMemberInfo::addDatasetLimits(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlExpression * _value)
{
    LinkedHqlExpr value = _value;
    IHqlExpression * choosen = column->queryAttribute(choosenAtom);
    if (choosen)
    {
        LinkedHqlExpr choosenValue = choosen->queryChild(0);
        if (!choosenValue->queryValue())
        {
            OwnedHqlExpr self = container->getRelativeSelf();
            OwnedHqlExpr absoluteExpr = replaceSelector(choosenValue, querySelfReference(), self);
            choosenValue.setown(selector->queryRootRow()->bindToRow(absoluteExpr, querySelfReference()));
        }
        else
        {
            if (hasNoMoreRowsThan(value, getIntValue(choosenValue)))
                choosenValue.clear();
        }

        if (choosenValue)
            value.setown(createDataset(no_choosen, LINK(value), LINK(choosenValue)));
    }

    IHqlExpression * maxCount = queryAttributeChild(column, maxCountAtom, 0);
    if (maxCount && !hasNoMoreRowsThan(value, getIntValue(maxCount)))
    {
        //Generate a limit test if there isn't a limit that ensures it is small enough
        StringBuffer failText, columnText;
        expandSelectPathText(columnText, true).toLowerCase();
        failText.appendf("Too many rows assigned to field %s", columnText.str());
        OwnedHqlExpr fail = translator.createFailAction(failText.str(), maxCount, NULL, translator.queryCurrentActivityId(ctx));
        value.setown(createDataset(no_limit, LINK(value), createComma(LINK(maxCount), LINK(fail))));
    }
    return value.getClear();
}
예제 #7
0
bool EnabledModuleList::doesModuleHaveHigherCppStandardThanProject (const String& moduleID)
{
    auto projectCppStandard = project.getCppStandardValue().toString();

    if (projectCppStandard == "latest")
        return false;

    auto moduleCppStandard = getModuleInfo (moduleID).getMinimumCppStandard();

    return (moduleCppStandard.getIntValue() > projectCppStandard.getIntValue());
}
예제 #8
0
JNIEXPORT void JNICALL NAME(nativePrepareAsync)(JNIEnv *env, jobject thiz)
{
    libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, thiz, "mLibVlcMedia");
    char *mrl = libvlc_media_get_mrl(media);
    if (strncmp(mrl, "file://", 7) == 0)
        libvlc_media_parse_async(media);
    else
    {
        libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
        libvlc_media_player_play(mp);
    }
    free(mrl);
}
bool CBigStashPaser::parseGoldAndPageSize( CBigStash& ar_oBigStash )
{
    if( m_nIndex >= m_nDataLength )
    {
        return false;
    }

    BYTE* lo_pByteData = &m_pBigStashDatas[m_nIndex];

    int lo_nNextPageIndex = findNextPageHeader();

    if( lo_nNextPageIndex < 0 )
    {
        return false;
    }

    int lo_nDataLength = lo_nNextPageIndex - m_nIndex;

    unsigned int lo_nGold = 0;

    unsigned int lo_nPageSize = 0;

    switch( lo_nDataLength )
    {
    case 4:
        lo_nPageSize = getIntValue( m_pBigStashDatas, m_nDataLength, m_nIndex );
        break;
    case 8:
        lo_nGold = getIntValue( m_pBigStashDatas, m_nDataLength, m_nIndex );

        lo_nPageSize = getIntValue( m_pBigStashDatas, m_nDataLength, m_nIndex+4 );
        break;
    default:
        return false;
    }

    if( lo_nPageSize <= 0 )
    {
        return false;
    }

    ar_oBigStash.Gold(lo_nGold);

    ar_oBigStash.PageSize(lo_nPageSize);

    m_nIndex = lo_nNextPageIndex;

    return true;
}
예제 #10
0
void ofXml::deserialize(ofAbstractParameter & parameter){
	if(!parameter.isSerializable()) return;
	string name = parameter.getEscapedName();
	if(parameter.type()==typeid(ofParameterGroup).name()){
		ofParameterGroup & group = static_cast<ofParameterGroup&>(parameter);
		if(setTo(name)){
			for(int i=0;i<group.size();i++){
				deserialize(group.get(i));
			}
			setToParent();
		}
	}else{
		if(exists(name)){
			if(parameter.type()==typeid(ofParameter<int>).name()){
				parameter.cast<int>() = getIntValue(name);
			}else if(parameter.type()==typeid(ofParameter<float>).name()){
				parameter.cast<float>() = getFloatValue(name);
			}else if(parameter.type()==typeid(ofParameter<bool>).name()){
				parameter.cast<bool>() = getBoolValue(name);
			}else if(parameter.type()==typeid(ofParameter<int64_t>).name()){
				parameter.cast<int64_t>() = getInt64Value(name);
			}else if(parameter.type()==typeid(ofParameter<string>).name()){
				parameter.cast<string>() = getValue(name);
			}else{
				parameter.fromString(getValue(name));
			}
		}
	}

}
예제 #11
0
        void binary_operation(VarType type, R (*binaryFunction)(T const &, T const &)) {
            auto left = popVariable();
            auto right = popVariable();

            T leftValue, rightValue;
            if (type == VT_DOUBLE) {
                leftValue = left.getDoubleValue();
                rightValue = right.getDoubleValue();
            }
            else {
                leftValue = left.getIntValue();
                rightValue = right.getIntValue();
            }

            pushVariable(binaryFunction(leftValue, rightValue));
        }
예제 #12
0
// ----------------------------------------------------------------------------
//
LPCSTR ChannelControllerField::getLabel() {
    CString name;
    CString addresses;
    CString range;

    // Figure out which channel text to show
    for ( Fixture *pf : m_venue->resolveActorFixtures( &m_actor ) ) {
        if ( pf->getNumChannels() > m_channel ) {
            Channel* ch = pf->getChannel(m_channel);

            if ( name.GetLength() == 0 )
                name = ch->getName();
            if ( addresses.GetLength() > 0 )
                addresses += ",";
            addresses.AppendFormat( "%u", pf->getChannelAddress(m_channel) );

            ChannelValueRange* rangep = ch->getRange( getIntValue() );
            if ( rangep && range.Find( rangep->getName() ) == - 1 ) {
                if ( range.GetLength() > 0 )
                    range += ",";
                range += rangep->getName();
            }
        }
    }

    if ( range.GetLength() > 0 )
        range = " \"" + range + "\" ";

    m_label.Format( "%d: %s (@%s)%s", m_channel+1, (LPCTSTR)name, (LPCTSTR)addresses, (LPCTSTR)range );

    return m_label;
}
예제 #13
0
파일: object.cpp 프로젝트: jfakult15/SIP
string Object::getValue()
{
    if (isArray == 1)
    {
        getMapValue();
    }
    
    if (value=="") return "";
    
    if (type=="bool")
    {
        return to_string(getBoolValue());
    }
    else if (type=="int")
    {
        return to_string(getIntValue());
    }
    else if (type=="double")
    {
        std::ostringstream os;
        os << getDoubleValue();
        return os.str();
    }
    return getStringValue();
}
예제 #14
0
string Options::getValueString(OptionId id) {
  Value value = getValue(id);
  switch (id) {
    case OptionId::HINTS:
    case OptionId::ASCII:
    case OptionId::FULLSCREEN:
    case OptionId::AUTOSAVE:
    case OptionId::WASD_SCROLLING:
    case OptionId::SOUND:
    case OptionId::MUSIC: return getOnOff(value);
    case OptionId::KEEP_SAVEFILES:
    case OptionId::SHOW_MAP:
    case OptionId::FAST_IMMIGRATION:
    case OptionId::STARTING_RESOURCE:
    case OptionId::ONLINE:
    case OptionId::ZOOM_UI:
    case OptionId::START_WITH_NIGHT: return getYesNo(value);
    case OptionId::ADVENTURER_NAME:
    case OptionId::KEEPER_SEED:
    case OptionId::KEEPER_NAME: {
        string val = boost::get<string>(value);
        if (val.empty())
          return defaultStrings[id];
        else
          return val;
        }
    case OptionId::FULLSCREEN_RESOLUTION: return choices[id][boost::get<int>(value)];
    case OptionId::MAIN_VILLAINS:
    case OptionId::LESSER_VILLAINS:
    case OptionId::RETIRED_VILLAINS:
    case OptionId::INFLUENCE_SIZE:
    case OptionId::ALLIES: return toString(getIntValue(id));
  }
}
std::string MROMInstaller::checkVersion() const
{
	int min_ver = getIntValue("min_mrom_ver", -1);
	if(min_ver == -1)
		return std::string();

	char cmd[256];
	sprintf(cmd, "rm /tmp/ver; sh -c \"%s/multirom -v > /tmp/ver\"", MultiROM::getPath().c_str());
	system(cmd);

	FILE *f = fopen("/tmp/ver", "r");
	if(!f)
		return "Failed to check MultiROM version!";

	fgets(cmd, sizeof(cmd), f);
	fclose(f);

	int ver = atoi(cmd);
	if(ver < min_ver)
	{
		sprintf(cmd, "Required ver: %d, curr ver: %d", min_ver, ver);
		return std::string(cmd);
	}

	return std::string();
}
예제 #16
0
int getFebNumProcess(char* pname, xmlDoc* doc) {
  int val;
  int idpm;
  int idp;
  char str1[256];
  char str2[256];
  char action[256];
  xmlXPathObjectPtr result;
  xmlNodePtr node;
  char tmp[256];
  val = -1;
  idpm = -1;
  idp = -1;
  getStringFromEpicsName(pname,str1,1);
  getStringFromEpicsName(pname,str2,2);

  if(strcmp(str1,"daq")==0 && strcmp(str2,"dpm")==0) {     
    idpm = getIntFromEpicsName(pname,3);  
    idp = getIntFromEpicsName(pname,4);  
        
    getStringFromEpicsName(pname,action,5);    
    
    if(DEBUG>2)  printf("[ getFebNumProcess ] : get %s from dpm xml\n", action);
    if(strcmp(action,"febnum_sub")==0) {
      sprintf(tmp,"/system/status/DataDpm/RceCore/DataPath[@index=\"%d\"]/FebNum",idp);
    } 
    else if( strcmp(action,"hybnum_sub")==0) {
      sprintf(tmp,"/system/status/DataDpm/RceCore/DataPath[@index=\"%d\"]/HybridNum",idp);
    }
    else {
      strcpy(tmp,"");
    }
    
    if(strcmp(tmp,"")!=0) {
      if(DEBUG>2) printf("[ getFebNumProcess ] : xpath \"%s\"\n",tmp);
      result =  getnodeset(doc, (xmlChar*) tmp);
      if(result!=NULL) {
	if(DEBUG>2) printf("[ getFebNumProcess ] : got %d nodes\n", result->nodesetval->nodeNr);
	if(result->nodesetval->nodeNr==1) {
	  node = result->nodesetval->nodeTab[0];
	  if(node!=NULL) {
	    val = getIntValue(doc, node);
	    if(DEBUG>0) printf("[ getFebNumProcess ]: got val %d.\n",val);      
	  } else {
	    printf("[ getFebNumProcess ] : [ WARNING ] no FebNum nodes found\n");
	  }
	} else {
	  printf("[ getFebNumProcess ] : [ WARNING ] %d FebNum nodes found, should be exactly 1\n", result->nodesetval->nodeNr);
	}
      } else {
	printf("[ getFebNumProcess ] : [ WARNING ] no results found\n");
      }  
    } else {
      printf("[ getFebNumProcess ] : [ WARNING ] wrong action (%s) \n",action);      
    }
  } else {
    printf("[ getFebNumProcess ]: [ ERROR ]: wrong record name? \"%s\"!\n",pname);    
  }
  return val;
}
예제 #17
0
JNIEXPORT void JNICALL NAME(nativeRelease)(JNIEnv *env, jobject thiz)
{
    vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock");
    vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond");
    /* wake up threads that waiting on prepare */
    vlc_mutex_lock(parse_lock);
    setIntValue(env, thiz, "mNativeMediaParsed", 4);
    vlc_cond_broadcast(parse_cond);
    vlc_mutex_unlock(parse_lock);
    jint mLibVlcMediaPlayer = getIntValue(env, thiz, "mLibVlcMediaPlayer");
    if (mLibVlcMediaPlayer != 0)
    {
        libvlc_event_manager_t *em;
        libvlc_media_player_t *mp = (libvlc_media_player_t*) mLibVlcMediaPlayer;
        libvlc_media_t *md = libvlc_media_player_get_media(mp);
        if (md) {
            em = libvlc_media_event_manager(md);
            for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++)
            {
                libvlc_event_detach(em, md_listening[i], vlc_event_callback, thiz);
            }
        }
        em = libvlc_media_player_event_manager(mp);
        for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++)
        {
            libvlc_event_detach(em, mp_listening[i], vlc_event_callback, thiz);
        }
        libvlc_media_player_stop(mp);
        libvlc_media_player_release(mp);
        setIntValue(env, thiz, "mLibVlcMediaPlayer", 0);
    }
    jint mLibVlcInstance = getIntValue(env, thiz, "mLibVlcInstance");
    if (mLibVlcInstance != 0)
    {
        libvlc_instance_t *instance = (libvlc_instance_t*) mLibVlcInstance;
        libvlc_release(instance);
        setIntValue(env, thiz, "mLibVlcInstance", 0);
    }
    setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
    vlc_mutex_destroy(parse_lock);
    free(parse_lock);
    setIntValue(env, thiz, "mNativeMediaParseLock", 0);
    vlc_cond_destroy(parse_cond);
    free(parse_cond);
    setIntValue(env, thiz, "mNativeMediaParseCond", 0);
    freeClasses(env, thiz);
}
예제 #18
0
// ----------------------------------------------------------------------------
//
bool ChannelControllerField::setValue( LPCSTR value ) {
    if ( !IntegerField::setValue( value ) )
        return false;

    setFixtureValues( (BYTE)getIntValue() );

    return true;
}
//!
//! Change function for the MaxRecords parameter.
//!
void TextDelimiterSourceNode::maxRecordsChanged ()
{
	int maxRecords = getIntValue("MaxRecords");
	if (!m_dtxt)
		return;

	m_dtxt->SetMaxRecords(maxRecords);
	updateTable();
}
예제 #20
0
JNIEXPORT void JNICALL NAME(nativePrepare)(JNIEnv *env, jobject thiz)
{
    libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, thiz, "mLibVlcMedia");
    char *mrl = libvlc_media_get_mrl(media);
    if (strncmp(mrl, "file://", 7) == 0)
        libvlc_media_parse(media);
    else {
        vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock");
        vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond");
        libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
        libvlc_media_player_play(mp);
        vlc_mutex_lock(parse_lock);
        while (!getIntValue(env, thiz, "mNativeMediaParsed"))
            vlc_cond_wait(parse_cond, parse_lock);
        vlc_mutex_unlock(parse_lock);
    }
    free(mrl);
}
예제 #21
0
PCRetCode ReaderRecvBody(PacketConnection* pPacketConnection, AMUInt8* pHead, AMUInt8** ppBodyBuffer, AMInt32* pBodyLength)
{
	AMInt32 length = 0;
	
#ifdef AMOS_DEBUG
	AMPrintf("noble:ReaderRecvBody <<<<.\n");
#endif

	*pBodyLength = getIntValue(pHead, 12);
	
	if(*pBodyLength <0 /*|| *pBodyLength > PC_MAX_PROTOCOL_LEN */)
	{
	#ifdef AMOS_DEBUG
		AMPrintf("noble:reader: bodyLength exceed limited(0~20000) = %d\n", *pBodyLength);
	#endif
		//send a body exceed exception to up-layer.
		ReaderExceedExceptionHandler(pPacketConnection->pProtocolEngine, *pBodyLength);
		return eContinue;
	}

	// 分配Body空间并填充
	*ppBodyBuffer = (AMUInt8*)AMMalloc(*pBodyLength);
	if(*ppBodyBuffer == NULL)
	{
	#ifdef AMOS_DEBUG
		AMPrintf("noble:malloc pBodyBuffer error = %d.\n", *pBodyLength);
		AMAssert(0);
	#endif
		return eJumpWhile;
	}
	memset(*ppBodyBuffer, 0, *pBodyLength);
	
    length = PCContextGetInstance()->recv(
		pPacketConnection->pProtocolEngine->pPCCore->socketFd, *ppBodyBuffer, *pBodyLength);

	if( length != *pBodyLength)
	{
	#ifdef AMOS_DEBUG
		AMPrintf("noble:recv = %d != bodyLength = %d\n", length, *pBodyLength);
	#endif
		//first free memory
		AMFree(*ppBodyBuffer);
		*ppBodyBuffer = NULL;

		//send exception to up.
		if(ReaderRecvExceptionHandler(pPacketConnection,*pBodyLength,length) == eContinue)
			return eContinue;
		else
			return eJumpWhile;
	}
	
#ifdef AMOS_DEBUG
	AMPrintf("noble:ReaderRecvBody >>>>>.\n");
#endif
	return eOK;
}
예제 #22
0
JNIEXPORT jint JNICALL NAME(nativeGetDuration)(JNIEnv *env, jobject thiz)
{
    libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
    int64_t duration = libvlc_media_player_get_length(mp);
    if (duration < 0)
    {
        return -1;
    }
    return (jint) (duration / 1000);
}
예제 #23
0
JNIEXPORT jint JNICALL NAME(nativeGetCurrentPosition)(JNIEnv *env, jobject thiz)
{
    libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
    int64_t position = libvlc_media_player_get_time(mp);
    if (position < 0)
    {
        return -1;
    }
    return (jint) (position / 1000);
}
예제 #24
0
void ConeTreeLayouterNode::setCompression ()
{
	double compression = getIntValue(m_CompressionNameParameter);
	if (m_Compression == compression)
		return;

	m_Compression = compression;

	M_LAYOUT->SetCompression(m_Compression);
}
예제 #25
0
void ClusteringLayouterNode::setMaxNumberOfIterations ()
{
	int maxIterations = getIntValue("Set Max Number Of Iterations");
	if (m_maxIterations == maxIterations)
		return;

	m_maxIterations = maxIterations;

	M_LAYOUT->SetMaxNumberOfIterations(m_maxIterations);
}
예제 #26
0
//!
//! Set the layout properties
//!
void ClusteringLayouterNode::setRandomSeed ()
{
	int randomSeed = getIntValue("Set Random Seed");
	if (randomSeed == m_randomSeed)
		return;

	m_randomSeed = randomSeed;

	M_LAYOUT->SetRandomSeed(m_randomSeed);
}
예제 #27
0
void ClusteringLayouterNode::setCoolDownRate ()
{
	int coolDownRate = getIntValue("Set Cool Down Rate");
	if (m_coolDownRate == coolDownRate)
		return;

	m_coolDownRate = coolDownRate;

	M_LAYOUT->SetCoolDownRate(m_coolDownRate);
}
예제 #28
0
void ClusteringLayouterNode::setIterationsPerLayout ()
{
	int layoutIterations = getIntValue("Set Iterations Per Layout");
	if (m_layoutIterations == layoutIterations)
		return;

	m_layoutIterations = layoutIterations;

	M_LAYOUT->SetIterationsPerLayout(m_layoutIterations);
}
예제 #29
0
bool getIntValue(ahm::Properties* pProperties, iop::int32 id, iop::int32 &iresult) {
    if(pProperties) {
        ahm::Property *pProperty = pProperties->findProperty(id);

        if(pProperty) return getIntValue(pProperty->value(), iresult);

    }
    return false;


}
예제 #30
0
int RegElement::getPreconfigureIntValue(const QString& name)
{
    bool exists;
    int ret = getIntValue(
        HKEY_CURRENT_USER, softwareSeafile(), name, &exists);
    if (exists) {
        return ret;
    }

    return RegElement::getIntValue(
        HKEY_LOCAL_MACHINE, softwareSeafile(), name);
}