Пример #1
0
rho::String js_barcode1_enumerate(const rho::String& strID, CJSONArrayIterator& oParams)
{
    CMethodResult oRes;

    if ( !oParams.isEnd() )
    {
        oRes.setError("Barcode1::enumerate - wrong number of arguments");
        return oRes.toJSON();
    }

    CBarcode1::enumerate(oRes);

    rho::Vector<rho::String>& arIDs = oRes.getStringArray();

    for( int i = 0; i < arIDs.size(); i++ )
    {
        if ( !CBarcode1::getBarcodes().containsKey(arIDs[i]) )
        {
            IBarcode1* pObj = CBarcode1::create(arIDs[i]);
            CBarcode1::getBarcodes().put(arIDs[i], pObj );
        }
    }

    return oRes.toJSON();
}
Пример #2
0
rho::String js_Barcode1_setDefaultID(rho::json::CJSONArray& argv, const rho::String& strObjID)
{
    CMethodResult oRes;
    CBarcode1FactoryBase::getBarcode1SingletonS()->setDefaultID(convertToStringW(strObjID));

    return oRes.toJSON();
}
Пример #3
0
void CSystemImpl::getScreenAutoRotate(CMethodResult& oResult)
{
	if(DisplayProperties::AutoRotationPreferences == Windows::Graphics::Display::DisplayOrientations::None)
		oResult.set(false);
	else 
		oResult.set(true);
}
Пример #4
0
rho::String js_Barcode1_getDefaultID(rho::json::CJSONArray& argv, const rho::String& strObjID)
{
    CMethodResult oRes;
    rho::StringW strDefaultID = CBarcode1FactoryBase::getBarcode1SingletonS()->getDefaultID();
    oRes.set(strDefaultID);

    return oRes.toJSON();
}
Пример #5
0
    virtual rho::String getInitialDefaultID()
    {
        CMethodResult oRes;
        enumerate(oRes);

        rho::Vector<rho::String>& arIDs = oRes.getStringArray();

        return ""; // arIDs[0];
    }
Пример #6
0
rho::String CShareExtensionSingleton::getInitialDefaultID()
{
    CMethodResult oRes;
    enumerate(oRes);

    rho::Vector<rho::String>& arIDs = oRes.getStringArray();
        
    return arIDs[0];
}
Пример #7
0
rho::String C<%= name.camel_case %>Singleton::getInitialDefaultID()
{
    CMethodResult oRes;
    enumerate(oRes);

    rho::Vector<rho::String>& arIDs = oRes.getStringArray();
        
    return arIDs[0];
}
Пример #8
0
rho::StringW CBarcodeSingleton::getInitialDefaultID()
{
    CMethodResult oRes;
    enumerate(oRes);

    rho::Vector<rho::StringW>& arIDs = oRes.getStringArray();
        
    return arIDs[0];
}
Пример #9
0
rho::String js_Barcode1_enumerate(rho::json::CJSONArray& argv, const rho::String& strObjID)
{
    CMethodResult oRes;

    rho::common::IRhoRunnable* pFunctor = 0;
    bool bUseCallback = false;
    int argc = argv.getSize();
    int nCallbackArg = 0;




    if ( argc > nCallbackArg )
    {

        
        if ( !argv[nCallbackArg].isString() )
        {
            oRes.setArgError(L"Type error: callback should be String");
            return oRes.toJSON();
        }

        oRes.setCallInUIThread(false);
        oRes.setRubyCallback( argv[nCallbackArg].getString() );
        if ( argc > nCallbackArg + 1 )
        {
            if ( !argv[nCallbackArg + 1].isString() )
            {
                oRes.setArgError(L"Type error: callback parameter should be String");
                return oRes.toJSON();
            }

            oRes.setCallbackParam( argv[nCallbackArg + 1].getString() );
        }
        
    }


    pFunctor = rho_makeInstanceClassFunctor1( CBarcode1FactoryBase::getBarcode1SingletonS(), &IBarcode1Singleton::enumerate,  oRes );




    if ( bUseCallback )
        CBarcode1FactoryBase::getBarcode1SingletonS()->addCommandToQueue( pFunctor );
    else
    {
        delete pFunctor;


        CBarcode1FactoryBase::getBarcode1SingletonS()->enumerate(  oRes );


    }


    return oRes.toJSON();

}
Пример #10
0
void CLedSingleton::enumerate(CMethodResult& oResult)
{
    rho::Vector<rho::String> arIDs;
	if (m_pNotifications && m_bNotificationsLoaded)
	{
		//  Initialise the Beeper
		NOTIFY_FINDINFO notifyObject;
		HANDLE	hFindHandle = NULL;
		SI_ALLOC_ALL(&notifyObject);
		notifyObject.StructInfo.dwUsed = 0;
		if(m_pNotifications->lpfn_Notify_FindFirst(&notifyObject, &hFindHandle) == E_NTFY_SUCCESS)
		{
			int iObCount = 0;
			do 
			{
				if(notifyObject.dwObjectType == NOTIFY_TYPE_LED)
				{
					//  Found an LED
					arIDs.addElement(convertToStringA(iObCount));
				}
				iObCount++;
				SI_ALLOC_ALL(&notifyObject);
				notifyObject.StructInfo.dwUsed = 0;
			} while(m_pNotifications->lpfn_Notify_FindNext(&notifyObject, hFindHandle) == E_NTFY_SUCCESS);
		}
		m_pNotifications->lpfn_Notify_FindClose(hFindHandle);
	}	
	oResult.set(arIDs);
}
Пример #11
0
void CSystemImpl::getCountry(CMethodResult& oResult)
{
	wchar_t szCountry[20];
	int nRes = GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT,LOCALE_SISO3166CTRYNAME , szCountry, sizeof(szCountry)/sizeof(szCountry[0]));
	szCountry[2] = 0;

	oResult.set(StringW(szCountry));
}
Пример #12
0
void CShareExtensionSingleton::enumerate(CMethodResult& oResult)
{
    rho::Vector<rho::String> arIDs;
    arIDs.addElement("SC1");
    arIDs.addElement("SC2");

    oResult.set(arIDs);
}
Пример #13
0
void CSystemImplBase::getDevicePushId(CMethodResult& oResult)
{
    rho::String strDeviceID;
	if ( rho::sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) 
		strDeviceID = rho::sync::RhoconnectClientManager::clientRegisterGetDevicePin();

    oResult.set( strDeviceID );
}
Пример #14
0
void CBarcodeSingleton::enumerate(CMethodResult& oResult)
{
    rho::Vector<rho::StringW> arIDs;
    arIDs.addElement(L"SC1");
    arIDs.addElement(L"SC2");

    oResult.set(arIDs);
}
Пример #15
0
void CGenPropBagSingleton::enumerate(CMethodResult& oResult)
{
    rho::Vector<rho::String> arIDs;
    arIDs.addElement("ID1");
    arIDs.addElement("ID2");

    oResult.set(arIDs);
}
Пример #16
0
    virtual void enumerate(CMethodResult& oResult)
    {
        rho::Vector<rho::String> arIDs;
        arIDs.addElement("SC1");
        arIDs.addElement("SC2");

        oResult.set(arIDs);
    }
Пример #17
0
void CEventsourceSingleton::enumerate(CMethodResult& oResult)
{
    rho::Vector<rho::String> arIDs;
    arIDs.addElement("SC1");
    arIDs.addElement("SC2");

    oResult.set(arIDs);
}
Пример #18
0
void CSystemImpl::getLocale(CMethodResult& oResult)
{
	wchar_t szLang[20];
	int nRes = GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT,LOCALE_SABBREVLANGNAME , szLang, sizeof(szLang)/sizeof(szLang[0]));
	szLang[2] = 0;
	wcslwr(szLang);

	oResult.set(StringW(szLang));
}
Пример #19
0
void CMegamoduleBase::setProperties( const rho::Hashtable<rho::String, rho::String>& propertyMap, CMethodResult& oResult)
{
    for ( rho::Hashtable<rho::String, rho::String>::const_iterator it = propertyMap.begin();  it != propertyMap.end(); ++it )
    {
        setProperty( it->first, it->second, oResult );
        if ( oResult.isError() )
            break;
    }
}
Пример #20
0
void CMegamoduleBase::getProperty( const rho::String& propertyName, CMethodResult& oResult)
{
    CMethodAccessor< IMegamodule >* pAccessor = m_mapPropAccessors[propertyName];
    if ( pAccessor )
        pAccessor->callGetter(this, oResult);
    else
    {
        
        oResult.set(m_hashProps[propertyName]);
        
    }
}
Пример #21
0
bool CMethodResult::isEqualCallback(CMethodResult& oResult)
{
    if (!hasCallback())
        return hasCallback() == oResult.hasCallback();

    if ( m_strRubyCallback.length() != 0 )
        return m_strRubyCallback == oResult.m_strRubyCallback;

    if ( m_pRubyCallbackProc )
        return m_pRubyCallbackProc == oResult.m_pRubyCallbackProc;

    return m_strJSCallback == oResult.m_strJSCallback;
}
Пример #22
0
void FcmPushClient::getDeviceId(CMethodResult& result)
{
    String deviceId = m_hashProps["deviceId"];

    if(deviceId.length() != 0)
    {
        LOG(TRACE) + "FCM deviceId: " + deviceId;
        result.set(deviceId);
    }
    else
    {
        LOG(TRACE) + "Still waiting for FCM deviceId";
        m_deviceIdResult = result;
    }
}
Пример #23
0
bool CMethodResult::isEqualCallback(CMethodResult& oResult)
{
    if (!hasCallback())
    {
        return hasCallback() == oResult.hasCallback();
    }

    if ( m_strRubyCallback.length() != 0 )
    {
        return m_strRubyCallback == oResult.m_strRubyCallback;
    }
#ifndef RHO_NO_RUBY
    if ( m_pRubyCallbackProc )
    {
        return m_pRubyCallbackProc == oResult.m_pRubyCallbackProc;
    }
#endif
    return m_strJSCallback == oResult.m_strJSCallback;
}
Пример #24
0
void CSystemImplBase::zipFile( const rho::String& localPathToZip,  const rho::String& localPathToFile,  const rho::String& password, CMethodResult& oResult)
{
    ZRESULT res;

#if defined(UNICODE) && defined(WIN32) && !defined(OS_WP8)
    rho::StringW strZipFilePathW;
    convertToStringW(localPathToZip.c_str(), strZipFilePathW);

    CFilePath oPath(localPathToFile);
    rho::StringW strFileNameW;
    convertToStringW(oPath.getBaseName(), strFileNameW);

    rho::StringW strToZipPathW;
    convertToStringW(localPathToFile.c_str(), strToZipPathW);

    HZIP hz = CreateZip(strZipFilePathW.c_str(), password.c_str());
    if ( !hz )
        res = -1;
    else
    {
        res = ZipAdd( hz, strFileNameW.c_str(), strToZipPathW.c_str() );

        res = CloseZip(hz);
    }

#else
    HZIP hz = CreateZip((TCHAR*)localPathToZip.c_str(), password.c_str());
    if(!hz)
    {
        res = -1;
    } else
    {
        CFilePath oPath(localPathToFile);
        res = ZipAdd(hz, (TCHAR*)oPath.getBaseName(), (TCHAR*)localPathToFile.c_str());
        res = CloseZip(hz);
    }
#endif

    oResult.set(res);
}
Пример #25
0
void CMegamoduleBase::getProperties( const rho::Vector<rho::String>& arrayofNames, CMethodResult& oResult)
{
    rho::Hashtable<rho::String, rho::String> res;
    oResult.setCollectionMode(true);
    for ( int i = 0; i < (int)arrayofNames.size(); i++ )
    {
        getProperty(arrayofNames[i], oResult);

        if ( oResult.isError() )
            break;

        res[arrayofNames[i]] = oResult.toString();
    }

    oResult.setCollectionMode(false);
    if ( oResult.isError() )
        oResult.callCallback();
    else
        oResult.set(res);
}
Пример #26
0
static VALUE _api_generator_Barcode_enable(int argc, VALUE *argv, IBarcode* pObj)

{
    CMethodResult oRes;



    rho::common::IRhoRunnable* pFunctor = 0;
    bool bUseCallback = false;
    int nCallbackArg = 0;




    nCallbackArg = 1;

    






    rho::Hashtable<rho::StringW, rho::StringW> arg0;
    if ( argc > 0 )
    {
        if ( rho_ruby_is_hash(argv[0]) )
            getStringHashFromValue(argv[0], arg0);
        else if (!rho_ruby_is_NIL(argv[0]))
        {
            oRes.setArgError(L"Type error: argument " L"0" L" should be " L"hash" );
            return oRes.toRuby();
        }
    }

        




    if ( argc > nCallbackArg )
    {


        if ( rho_ruby_is_proc(argv[nCallbackArg]) || rho_ruby_is_method(argv[nCallbackArg]) )
        {
            oRes.setRubyCallbackProc( argv[nCallbackArg] );
        }else if ( rho_ruby_is_string(argv[nCallbackArg]) )
        {
            oRes.setRubyCallback( getStringFromValue(argv[nCallbackArg]) );
        }else
        {
            oRes.setArgError(L"Type error: callback should be String");
            return oRes.toRuby();
        }

        oRes.setCallInUIThread(false);
        if ( argc > nCallbackArg + 1 )
        {
            if ( !rho_ruby_is_string(argv[nCallbackArg + 1]) )
            {
                oRes.setArgError(L"Type error: callback parameter should be String");
                return oRes.toRuby();
            }

            oRes.setCallbackParam( getStringFromValue(argv[nCallbackArg + 1]) );
        }
        
        bUseCallback = true;
    }


    pFunctor = rho_makeInstanceClassFunctor2( pObj, &IBarcode::enable, arg0,  oRes );




    if ( bUseCallback )
        CBarcodeFactoryBase::getBarcodeSingletonS()->addCommandToQueue( pFunctor );
    else
    {
        delete pFunctor;


        pObj->enable( arg0,  oRes );


    }


    return oRes.toRuby();
}
Пример #27
0
 virtual unsigned long getObjectValue()
 {
     m_oResult.convertStringParamToHash();
     return m_oResult.toRuby();
 }
Пример #28
0
static VALUE _api_generator_Barcode_getAllProperties(int argc, VALUE *argv, IBarcode* pObj)

{
    CMethodResult oRes;



    rho::common::IRhoRunnable* pFunctor = 0;
    bool bUseCallback = false;
    int nCallbackArg = 0;




    if ( argc > nCallbackArg )
    {


        if ( rho_ruby_is_proc(argv[nCallbackArg]) || rho_ruby_is_method(argv[nCallbackArg]) )
        {
            oRes.setRubyCallbackProc( argv[nCallbackArg] );
        }else if ( rho_ruby_is_string(argv[nCallbackArg]) )
        {
            oRes.setRubyCallback( getStringFromValue(argv[nCallbackArg]) );
        }else
        {
            oRes.setArgError(L"Type error: callback should be String");
            return oRes.toRuby();
        }

        oRes.setCallInUIThread(false);
        if ( argc > nCallbackArg + 1 )
        {
            if ( !rho_ruby_is_string(argv[nCallbackArg + 1]) )
            {
                oRes.setArgError(L"Type error: callback parameter should be String");
                return oRes.toRuby();
            }

            oRes.setCallbackParam( getStringFromValue(argv[nCallbackArg + 1]) );
        }
        
        bUseCallback = true;
    }


    pFunctor = rho_makeInstanceClassFunctor1( pObj, &IBarcode::getAllProperties,  oRes );




    if ( bUseCallback )
        CBarcodeFactoryBase::getBarcodeSingletonS()->addCommandToQueue( pFunctor );
    else
    {
        delete pFunctor;


        pObj->getAllProperties(  oRes );


    }


    return oRes.toRuby();
}
Пример #29
0
VALUE rb_s_Barcode_enumerate(int argc, VALUE *argv)

{
    CMethodResult oRes;


    oRes.setRubyObjectClass(getRuby_Barcode_Module());


    rho::common::IRhoRunnable* pFunctor = 0;
    bool bUseCallback = false;
    int nCallbackArg = 0;




    if ( argc > nCallbackArg )
    {


        if ( rho_ruby_is_proc(argv[nCallbackArg]) || rho_ruby_is_method(argv[nCallbackArg]) )
        {
            oRes.setRubyCallbackProc( argv[nCallbackArg] );
        }else if ( rho_ruby_is_string(argv[nCallbackArg]) )
        {
            oRes.setRubyCallback( getStringFromValue(argv[nCallbackArg]) );
        }else
        {
            oRes.setArgError(L"Type error: callback should be String");
            return oRes.toRuby();
        }

        oRes.setCallInUIThread(false);
        if ( argc > nCallbackArg + 1 )
        {
            if ( !rho_ruby_is_string(argv[nCallbackArg + 1]) )
            {
                oRes.setArgError(L"Type error: callback parameter should be String");
                return oRes.toRuby();
            }

            oRes.setCallbackParam( getStringFromValue(argv[nCallbackArg + 1]) );
        }
        
        bUseCallback = true;
    }


    pFunctor = rho_makeInstanceClassFunctor1( CBarcodeFactoryBase::getBarcodeSingletonS(), &IBarcodeSingleton::enumerate,  oRes );




    if ( bUseCallback )
        CBarcodeFactoryBase::getBarcodeSingletonS()->addCommandToQueue( pFunctor );
    else
    {
        delete pFunctor;


        CBarcodeFactoryBase::getBarcodeSingletonS()->enumerate(  oRes );


    }


    return oRes.toRuby();
}
Пример #30
0
static VALUE _api_generator_Barcode_setProperty(int argc, VALUE *argv, IBarcode* pObj)

{
    CMethodResult oRes;



    rho::common::IRhoRunnable* pFunctor = 0;
    bool bUseCallback = false;
    int nCallbackArg = 0;




    nCallbackArg = 1;

    
    if ( argc == 0 )
    {
        oRes.setArgError(L"Wrong number of arguments: " + convertToStringW(argc) + L" instead of " + convertToStringW(2) );
        return oRes.toRuby();
    }
    


    rho::StringW arg0;
    if ( argc > 0 )
    {
        if ( rho_ruby_is_string(argv[0]) )
        {
            arg0 = convertToStringW(getStringFromValue(argv[0]));

            oRes.setStringParam(getStringFromValue(argv[0]));

        }
        else if (!rho_ruby_is_NIL(argv[0]))
        {
            oRes.setArgError(L"Type error: argument " L"0" L" should be " L"string" );
            return oRes.toRuby();
        }
    }





        




    nCallbackArg = 2;

    
    if ( argc == 1 )
    {
        oRes.setArgError(L"Wrong number of arguments: " + convertToStringW(argc) + L" instead of " + convertToStringW(2) );
        return oRes.toRuby();
    }
    


    rho::StringW arg1;
    if ( argc > 1 )
    {
        if ( rho_ruby_is_string(argv[1]) )
        {
            arg1 = convertToStringW(getStringFromValue(argv[1]));

        }
        else if (!rho_ruby_is_NIL(argv[1]))
        {
            oRes.setArgError(L"Type error: argument " L"1" L" should be " L"string" );
            return oRes.toRuby();
        }
    }





        




    if ( argc > nCallbackArg )
    {

        oRes.setArgError(L"Wrong number of arguments: " + convertToStringW(argc) + L" instead of " + convertToStringW(2) );
        return oRes.toRuby();


        if ( rho_ruby_is_proc(argv[nCallbackArg]) || rho_ruby_is_method(argv[nCallbackArg]) )
        {
            oRes.setRubyCallbackProc( argv[nCallbackArg] );
        }else if ( rho_ruby_is_string(argv[nCallbackArg]) )
        {
            oRes.setRubyCallback( getStringFromValue(argv[nCallbackArg]) );
        }else
        {
            oRes.setArgError(L"Type error: callback should be String");
            return oRes.toRuby();
        }

        oRes.setCallInUIThread(false);
        if ( argc > nCallbackArg + 1 )
        {
            if ( !rho_ruby_is_string(argv[nCallbackArg + 1]) )
            {
                oRes.setArgError(L"Type error: callback parameter should be String");
                return oRes.toRuby();
            }

            oRes.setCallbackParam( getStringFromValue(argv[nCallbackArg + 1]) );
        }
        
        bUseCallback = true;
    }


    pFunctor = rho_makeInstanceClassFunctor3( pObj, &IBarcode::setProperty, arg0, arg1,  oRes );




    if ( bUseCallback )
        CBarcodeFactoryBase::getBarcodeSingletonS()->addCommandToQueue( pFunctor );
    else
    {
        delete pFunctor;


        pObj->setProperty( arg0, arg1,  oRes );


    }


    return oRes.toRuby();
}