///////////////////////////////////////////////////////////////////////////////
/// @fn PyHelloWorldAPI::PyHelloWorldAPI(const PyHelloWorldPtr& plugin, const FB::BrowserHostPtr host)
///
/// @brief Constructor for your JSAPI object. You should register your methods, properties, and events
/// that should be accessible to Javascript from here.
///
/// @see FB::JSAPIAuto::registerMethod
/// @see FB::JSAPIAuto::registerProperty
/// @see FB::JSAPIAuto::registerEvent
///////////////////////////////////////////////////////////////////////////////
PyHelloWorldAPI::PyHelloWorldAPI(const PyHelloWorldPtr& plugin, const FB::BrowserHostPtr& host) : m_plugin(plugin), m_host(host)
{
Py_Initialize();
globals = PyDict_New ();
PyDict_SetItemString (globals, "__builtins__", PyEval_GetBuiltins ());
registerMethod("echo", make_method(this, &PyHelloWorldAPI::echo));
registerMethod("testEvent", make_method(this, &PyHelloWorldAPI::testEvent));
// Read-write property
registerProperty("testString",
make_property(this,
&PyHelloWorldAPI::get_testString,
&PyHelloWorldAPI::set_testString));
// Read-only property
registerProperty("version",
make_property(this,
&PyHelloWorldAPI::get_version));
registerEvent("onfired");
registerMethod("hello_py", make_method(this, &PyHelloWorldAPI::hello_py));
registerMethod("getHelloPyExtension", make_method(this, &PyHelloWorldAPI::hello_py_extension));
// registerMethod("eval", make_method(this, &PyHelloWorldAPI::eval));
}
Realm::Realm(QObject *parent) : WampBase(parent), d_ptr(new RealmPrivate())
{
registerMethod(KEY_LIST_REGISTRATION_URIS, this, "registeredUris()");
registerMethod("wamp.registration.list", this, "registrationIds()");
registerMethod("wamp.registration.list_internal_uris", this, "registeredInternalUris()");
registerMethod("wamp.list_children_keys", this, "childrenKeys(QString)");
registerMethod("wamp.subscription.count_subscribers", this, "subscribersCount(QString)");
registerProcedure(KEY_GET_SUBSCRIPTION, [this](QVariantList args){//register some object
qulonglong subscriptionId = (qulonglong)args[0].toDouble();
if(!this->d_ptr->_subscriptions.contains(subscriptionId))
{
return WampResult(QVariant("wamp.error.no_such_subscription"));
}
WampRouterSubscriptionPointer subscription = this->d_ptr->_subscriptions[subscriptionId];
QVariantList resultArr;
QVariantMap details;
details["id"] = (double)subscription->subscriptionId();
details["created"] = subscription->created().toString("yyyy-mm-ddThh:mm:zzzZ");
details["uri"] = subscription->topic();
resultArr.append(details);
return WampResult(QVariant(resultArr));
});
registerProcedure(KEY_LOOKUP_REGISTRATION, [this](QVariantList args){
QString uri = args[0].toString();
if(!this->d_ptr->_root.containsGenuine(uri)) return WampResult();
WampRouterRegistrationPointer registration = this->d_ptr->_root.findData(uri);
return WampResult(QVariant(registration->registrationId()));
});
}
ZIntTest()
: cxxtools::unit::TestSuite("zim::ZIntTest")
{
registerMethod("zcompress1", *this, &ZIntTest::zcompress1);
registerMethod("zcompress2", *this, &ZIntTest::zcompress2);
registerMethod("zcompress3", *this, &ZIntTest::zcompress3);
}
////////////////////////////////////////////////////////////////////////////
/// @fn jUARTAPI::jUARTAPI(const jUARTPtr& plugin, const FB::BrowserHostPtr host)
///
/// @brief Constructor for your JSAPI object.
/// You should register your methods, properties, and events
/// that should be accessible to Javascript from here.
///
/// @see FB::JSAPIAuto::registerMethod
/// @see FB::JSAPIAuto::registerProperty
/// @see FB::JSAPIAuto::registerEvent
////////////////////////////////////////////////////////////////////////////
jUARTAPI::jUARTAPI(const jUARTPtr& plugin, const FB::BrowserHostPtr& host) :
m_plugin(plugin), m_host(host)
{
registerMethod("echo", make_method(this, &jUARTAPI::echo));
registerMethod("testEvent", make_method(this, &jUARTAPI::testEvent));
registerProperty("Serial", make_property(this, &jUARTAPI::get_Serial));
// Read-write property
registerProperty("testString",
make_property(this,
&jUARTAPI::get_testString,
&jUARTAPI::set_testString));
// Read-only property
registerProperty("version",
make_property(this,
&jUARTAPI::get_version));
std::string domain = m_host->getDOMWindow()->getNode("location")->getProperty<std::string>("host");
size_t colon = domain.find(':');
if (colon != std::string::npos)
domain = domain.substr(0, colon);
int secZone = domain.compare("localhost") == 0 ? FB::SecurityScope_Local : FB::SecurityScope_Public;
m_Serial = boost::make_shared<SerialAPI>(m_host, secZone);
}
server(AfcEventLoop &loop, AfcArgString &ip, AfcArgInteger &port)
: AfcRpcServer(loop, ip, port) {
registerMethod("createref", *this, &server::createref);
registerMethod("readref", *this, &server::readref);
registerMethod("updateref", *this, &server::updateref);
registerMethod("deleteref", *this, &server::deleteref);
}
void NpcScriptInterface::registerFunctions()
{
//npc exclusive functions
lua_register(m_luaState, "selfSay", NpcScriptInterface::luaActionSay);
lua_register(m_luaState, "selfMove", NpcScriptInterface::luaActionMove);
lua_register(m_luaState, "selfMoveTo", NpcScriptInterface::luaActionMoveTo);
lua_register(m_luaState, "selfTurn", NpcScriptInterface::luaActionTurn);
lua_register(m_luaState, "selfFollow", NpcScriptInterface::luaActionFollow);
lua_register(m_luaState, "selfGetPosition", NpcScriptInterface::luaSelfGetPos);
lua_register(m_luaState, "getDistanceTo", NpcScriptInterface::luagetDistanceTo);
lua_register(m_luaState, "doNpcSetCreatureFocus", NpcScriptInterface::luaSetNpcFocus);
lua_register(m_luaState, "getNpcCid", NpcScriptInterface::luaGetNpcCid);
lua_register(m_luaState, "getNpcPos", NpcScriptInterface::luaGetNpcPos);
lua_register(m_luaState, "getNpcName", NpcScriptInterface::luaGetNpcName);
lua_register(m_luaState, "getNpcParameter", NpcScriptInterface::luaGetNpcParameter);
lua_register(m_luaState, "openShopWindow", NpcScriptInterface::luaOpenShopWindow);
lua_register(m_luaState, "closeShopWindow", NpcScriptInterface::luaCloseShopWindow);
lua_register(m_luaState, "doSellItem", NpcScriptInterface::luaDoSellItem);
// metatable
registerMethod("Npc", "getParameter", NpcScriptInterface::luaNpcGetParameter);
registerMethod("Npc", "setFocus", NpcScriptInterface::luaNpcSetFocus);
registerMethod("Npc", "openShopWindow", NpcScriptInterface::luaNpcOpenShopWindow);
registerMethod("Npc", "closeShopWindow", NpcScriptInterface::luaNpcCloseShopWindow);
}
ServerObject::ServerObject(GlobalServerObjectPtr parent) :
m_parent(parent)
{
registerMethod("enumGroups", boost::bind(&ServerObject::enumGroups, this, _1));
registerMethod("enumClients", boost::bind(&ServerObject::enumClients, this, _1));
registerMethod("clientObject", boost::bind(&ServerObject::clientObject, this, _1));
}
encrev2_pluginAPI::encrev2_pluginAPI(FB::BrowserHostPtr host, encrev2_plugin &plugin)
: m_host(host), m_plugin(plugin)
{
// Callable
registerMethod("testEvent", make_method(this, &encrev2_pluginAPI::testEvent));
registerMethod("stream", make_method(this, &encrev2_pluginAPI::stream));
registerMethod("play", make_method(this, &encrev2_pluginAPI::play));
registerMethod("stop", make_method(this, &encrev2_pluginAPI::stop));
registerMethod("setOptions",make_method(this, &encrev2_pluginAPI::setOptions));
// Read-only property
registerProperty("version",
make_property(this,
&encrev2_pluginAPI::get_version));
// Read-Write property
registerProperty("hostname", make_property(this,
&encrev2_pluginAPI::get_hostname,
&encrev2_pluginAPI::set_hostname));
registerProperty("port", make_property(this,
&encrev2_pluginAPI::get_port,
&encrev2_pluginAPI::set_port));
// Event
registerEvent("onfired");
}
///////////////////////////////////////////////////////////////////////////////
/// @fn DNSSDPluginAPI::DNSSDPluginAPI(const DNSSDPluginPtr& plugin, const FB::BrowserHostPtr host)
///
/// @brief Constructor for your JSAPI object. You should register your methods, properties, and events
/// that should be accessible to Javascript from here.
///
/// @see FB::JSAPIAuto::registerMethod
/// @see FB::JSAPIAuto::registerProperty
/// @see FB::JSAPIAuto::registerEvent
///////////////////////////////////////////////////////////////////////////////
DNSSDPluginAPI::DNSSDPluginAPI(const DNSSDPluginPtr& plugin,
const FB::BrowserHostPtr& host)
: m_plugin(plugin), m_host(host)
{
bool safe = true;
std::string msg = "DNSSDPlugin: ";
std::string location = m_host->getDOMWindow()->getLocation();
msg.append("running from ");
msg.append(location);
#ifndef DEBUG
safe = (location == MOZILLA_CHROME_URI
|| location.find("chrome-extension://") == 0);
#endif
msg.append(safe ? " presumed safe" : " presumed unsafe");
FBLOG_INFO("DNSSDPluginAPI()", msg);
if (!safe) return;
registerMethod("plugin_version",
make_method(this, &DNSSDPluginAPI::plugin_version));
registerMethod("daemon_version",
make_method(this, &DNSSDPluginAPI::daemon_version));
registerMethod("browse_domains",
make_method(this, &DNSSDPluginAPI::enum_browse));
registerMethod("browse", make_method(this, &DNSSDPluginAPI::browse));
registerMethod("resolve", make_method(this, &DNSSDPluginAPI::resolve));
}
JoinTest()
: cxxtools::unit::TestSuite("join")
{
registerMethod("joinString", *this, &JoinTest::joinString);
registerMethod("joinInt", *this, &JoinTest::joinInt);
registerMethod("emptyJoin", *this, &JoinTest::emptyJoin);
}
MessageheaderTest()
: cxxtools::unit::TestSuite("messageheader-Test")
{
registerMethod("testMessageheader", *this, &MessageheaderTest::testMessageheader);
registerMethod("testMessageheaderRemove", *this, &MessageheaderTest::testMessageheaderRemove);
registerMethod("testMessageheaderParser", *this, &MessageheaderTest::testMessageheaderParser);
registerMethod("testMessageheaderParserSize", *this, &MessageheaderTest::testMessageheaderParserSize);
}
server(AfcEventLoop &loop, AfcArgString &ip, AfcArgInteger &port)
: AfcRpcServer(loop, ip, port) {
registerMethod("echo", m_api, &api::echo);
registerMethod("clear", m_api, &api::clear);
registerMethod("waitdelay", *this, &server::waitdelay);
registerMethod("addReference", *this, &server::addReference);
registerMethod("removeReferene", *this, &server::removeReferene);
registerFunction("add", add);
}
void Counter_init(){
Class baseClass = getClassWithName("Object");
Class counter = registerClass("Counter", baseClass);
registerMethod(counter, "init", counter_init);
registerProperty(counter, "count");
registerMethod(counter, "increment", increment);
}
ArgTest()
: cxxtools::unit::TestSuite("arg")
{
registerMethod("testArgBool", *this, &ArgTest::testArgBool);
registerMethod("testArgCharP", *this, &ArgTest::testArgCharP);
registerMethod("testArgpInt", *this, &ArgTest::testArgpInt);
registerMethod("testArgpCharp", *this, &ArgTest::testArgpCharp);
registerMethod("testArgpStdString", *this, &ArgTest::testArgpStdString);
}
Bzip2streamTest()
: cxxtools::unit::TestSuite("zim::Bzip2streamTest")
{
registerMethod("bunzip2Istream", *this, &Bzip2streamTest::bunzip2IstreamTest);
registerMethod("bunzip2Ostream", *this, &Bzip2streamTest::bunzip2OstreamTest);
for (unsigned n = 0; n < 10240; ++n)
testtext += "Hello";
}
RegexTest()
: cxxtools::unit::TestSuite("regex")
{
registerMethod("testRegex", *this, &RegexTest::testRegex);
registerMethod("testSubexpression", *this, &RegexTest::testSubexpression);
registerMethod("testEmptyRegex", *this, &RegexTest::testEmptyRegex);
registerMethod("testFormat", *this, &RegexTest::testFormat);
registerMethod("testSubst", *this, &RegexTest::testSubst);
}
ZlibstreamTest()
: cxxtools::unit::TestSuite("zim::ZlibstreamTest")
{
registerMethod("inflatorIstream", *this, &ZlibstreamTest::inflatorIstreamTest);
registerMethod("inflatorOstream", *this, &ZlibstreamTest::inflatorOstreamTest);
for (unsigned n = 0; n < 10240; ++n)
testtext += "Hello";
}
void FriendAPI::initProxy() {
registerProperty("address", make_property(this, &FriendAPI::getAddress, &FriendAPI::setAddress));
registerProperty("incSubscribePolicy", make_property(this, &FriendAPI::getIncSubscribePolicy, &FriendAPI::setIncSubscribePolicy));
registerProperty("name", make_property(this, &FriendAPI::getName, &FriendAPI::setName));
registerProperty("presenceModel", make_property(this, &FriendAPI::getPresenceModel));
registerProperty("refKey", make_property(this, &FriendAPI::getRefKey, &FriendAPI::setRefKey));
registerProperty("subscribesEnabled", make_property(this, &FriendAPI::subscribesEnabled, &FriendAPI::enableSubscribes));
registerMethod("done", make_method(this, &FriendAPI::done));
registerMethod("edit", make_method(this, &FriendAPI::edit));
registerMethod("inList", make_method(this, &FriendAPI::inList));
}
SerialAPI::SerialAPI(const FB::BrowserHostPtr& host) : m_host(host),io(), serial(io)
{
registerMethod("open", make_method(this, &SerialAPI::open));
registerMethod("set_option", make_method(this, &SerialAPI::set_option));
registerMethod("send", make_method(this, &SerialAPI::send));
registerMethod("sendmulti", make_method(this, &SerialAPI::sendmulti));
registerMethod("sendtest", make_method(this, &SerialAPI::sendtest));
registerMethod("is_open", make_method(this, &SerialAPI::is_open));
registerMethod("recv_callback", make_method(this, &SerialAPI::recv_callback));
registerMethod("err_callback", make_method(this, &SerialAPI::err_callback));
registerMethod("close", make_method(this, &SerialAPI::close));
registerMethod("getports", make_method(this, &SerialAPI::getports));
}
PluginAPI::PluginAPI(const BitcoinTrezorPluginPtr &plugin,
const FB::BrowserHostPtr &host) :
_plugin(plugin),
_host(host)
{
registerAttribute("version", FBSTRING_PLUGIN_VERSION, true);
registerMethod("call", make_method(this, &PluginAPI::call));
registerMethod("close", make_method(this, &PluginAPI::close));
registerMethod("devices", make_method(this, &PluginAPI::devices));
registerMethod("configure", make_method(this, &PluginAPI::configure));
registerMethod("deriveChildNode", make_method(this, &PluginAPI::derive_child_node));
}
///////////////////////////////////////////////////////////////////////////////
/// @fn osgWebAPI::osgWebAPI(const osgWebPtr& plugin, const FB::BrowserHostPtr host)
///
/// @brief Constructor for your JSAPI object. You should register your methods, properties, and events
/// that should be accessible to Javascript from here.
///
/// @see FB::JSAPIAuto::registerMethod
/// @see FB::JSAPIAuto::registerProperty
/// @see FB::JSAPIAuto::registerEvent
///////////////////////////////////////////////////////////////////////////////
osgWebAPI::osgWebAPI(const osgWebPtr& plugin, const FB::BrowserHostPtr& host) : m_plugin(plugin), m_host(host)
{
registerMethod("echo", make_method(this, &osgWebAPI::echo));
registerMethod("testEvent", make_method(this, &osgWebAPI::testEvent));
// Read-write property
registerProperty("testString",
make_property(this,
&osgWebAPI::get_testString,
&osgWebAPI::set_testString));
// Read-only property
registerProperty("version",
make_property(this,
&osgWebAPI::get_version));
}
void VideoAPI::initProxy() {
mId = getFactory()->getWhiteBoard()->addValue(VideoAPIWeakPtr(boost::static_pointer_cast<VideoAPI>(this->shared_from_this())));
// Methods
registerProperty("magic", make_property(this, &VideoAPI::getMagic, &VideoAPI::setMagic));
registerProperty("window", make_property(this, &VideoAPI::getWindow));
registerMethod("setBackgroundColor", make_method(this, &VideoAPI::setBackgroundColor));
}
/** This is an overloaded member function, provided
* for convenience. */
void Server::registerMethod( QString methodName, QVariant::Type returnType,
QVariant::Type parameter1Type )
{
QList<QVariant::Type> parameterTypes;
parameterTypes << parameter1Type;
registerMethod( methodName, returnType, parameterTypes );
}
void KeyRange::initializeMethods()
{
registerProperty("left", make_property(this, &KeyRange::getLeft));
registerProperty("right", make_property(this, &KeyRange::getRight));
registerProperty("flags", make_property(this, &KeyRange::getFlags));
registerProperty("SINGLE", make_property(this, &KeyRange::getSingle));
registerProperty("LEFT_OPEN", make_property(this, &KeyRange::GetLeftOpen));
registerProperty("RIGHT_OPEN", make_property(this, &KeyRange::GetRightOpen));
registerProperty("LEFT_BOUND", make_property(this, &KeyRange::GetLeftBound));
registerProperty("RIGHT_BOUND", make_property(this, &KeyRange::GetRightBound));
registerMethod("only", make_method(this, &KeyRange::only));
registerMethod("leftBound", make_method(this, static_cast<FB::JSOutObject (KeyRange::*)(FB::variant, const FB::CatchAll &)>(&KeyRange::leftBound)));
registerMethod("rightBound", make_method(this, static_cast<FB::JSOutObject (KeyRange::*)(FB::variant, const FB::CatchAll &)>(&KeyRange::rightBound)));
registerMethod("bound", make_method(this, static_cast<FB::JSOutObject (KeyRange::*)(FB::variant, FB::variant, const FB::CatchAll &)>(&KeyRange::bound)));
}
BlabbleCall::BlabbleCall(const BlabbleAccountPtr& parent_account)
: call_id_(-1), ringing_(false)
{
if (parent_account)
{
acct_id_ = parent_account->id();
audio_manager_ = parent_account->GetManager()->audio_manager();
parent_ = BlabbleAccountWeakPtr(parent_account);
}
else
{
acct_id_ = -1;
}
id_ = BlabbleCall::GetNextId();
BLABBLE_LOG_DEBUG("New call created. Global id: " << id_);
registerMethod("answer", make_method(this, &BlabbleCall::Answer));
registerMethod("hangup", make_method(this, &BlabbleCall::LocalEnd));
registerMethod("hold", make_method(this, &BlabbleCall::Hold));
registerMethod("unhold", make_method(this, &BlabbleCall::Unhold));
registerMethod("sendDTMF", make_method(this, &BlabbleCall::SendDTMF));
registerMethod("transferReplace", make_method(this, &BlabbleCall::TransferReplace));
registerMethod("transfer", make_method(this, &BlabbleCall::Transfer));
registerProperty("callerId", make_property(this, &BlabbleCall::caller_id));
registerProperty("isActive", make_property(this, &BlabbleCall::is_active));
registerProperty("status", make_property(this, &BlabbleCall::status));
registerProperty("onCallConnected", make_write_only_property(this, &BlabbleCall::set_on_call_connected));
registerProperty("onCallEnd", make_write_only_property(this, &BlabbleCall::set_on_call_end));
}
QueryParamsTest()
: cxxtools::unit::TestSuite("queryparams")
{
registerMethod("testQueryParams", *this, &QueryParamsTest::testQueryParams);
registerMethod("testCopy", *this, &QueryParamsTest::testCopy);
registerMethod("testParseUrl", *this, &QueryParamsTest::testParseUrl);
registerMethod("testParseUrlSpecialChar", *this, &QueryParamsTest::testParseUrlSpecialChar);
registerMethod("testCount", *this, &QueryParamsTest::testCount);
registerMethod("testCombine", *this, &QueryParamsTest::testCombine);
registerMethod("testIterator", *this, &QueryParamsTest::testIterator);
registerMethod("testGetUrl", *this, &QueryParamsTest::testGetUrl);
}
Base64Test()
: cxxtools::unit::TestSuite("base64")
{
registerMethod("encodeTest0", *this, &Base64Test::encodeTest0);
registerMethod("encodeTest1", *this, &Base64Test::encodeTest1);
registerMethod("encodeTest2", *this, &Base64Test::encodeTest2);
registerMethod("encodeStreamTest0", *this, &Base64Test::encodeStreamTest0);
registerMethod("encodeStreamTest1", *this, &Base64Test::encodeStreamTest1);
registerMethod("encodeStreamTest2", *this, &Base64Test::encodeStreamTest2);
registerMethod("encodeDecodeTest", *this, &Base64Test::encodeDecodeTest);
registerMethod("binaryTest", *this, &Base64Test::binaryTest);
}
InlineInstallerAPI::InlineInstallerAPI(FB::BrowserHostWrapper *host) : m_host(host)
{
registerMethod("echo", make_method(this, &InlineInstallerAPI::echo));
registerMethod("testEvent", make_method(this, &InlineInstallerAPI::testEvent));
// Read-write property
registerProperty("testString",
make_property(this,
&InlineInstallerAPI::get_testString,
&InlineInstallerAPI::set_testString));
// Read-only property
registerProperty("version",
make_property(this,
&InlineInstallerAPI::get_version));
registerEvent("onfired");
}
void mog::Pawn::initialRegisteredMethods()
{
registerMethod("moveUpPressed", std::bind(&mog::Pawn::moveUpPressed, this));
registerMethod("moveUpReleased", std::bind(&mog::Pawn::moveUpReleased, this));
registerMethod("moveDownPressed", std::bind(&mog::Pawn::moveDownPressed, this));
registerMethod("moveDownReleased", std::bind(&mog::Pawn::moveDownReleased, this));
registerMethod("moveLeftPressed", std::bind(&mog::Pawn::moveLeftPressed, this));
registerMethod("moveLeftReleased", std::bind(&mog::Pawn::moveLeftReleased, this));
registerMethod("moveRightPressed", std::bind(&mog::Pawn::moveRightPressed, this));
registerMethod("moveRightReleased", std::bind(&mog::Pawn::moveRightReleased, this));
registerMethod("shoot", std::bind(&mog::Pawn::shoot, this));
}
void AddressAPI::initProxy() {
registerMethod("asString", make_method(this, &AddressAPI::asString));
registerMethod("asStringUriOnly", make_method(this, &AddressAPI::asStringUriOnly));
registerMethod("clean", make_method(this, &AddressAPI::clean));
registerMethod("clone", make_method(this, &AddressAPI::clone));
if (isConst()) {
registerProperty("displayName", make_property(this, &AddressAPI::getDisplayName));
registerProperty("domain", make_property(this, &AddressAPI::getDomain));
registerProperty("port", make_property(this, &AddressAPI::getPort));
registerProperty("transport", make_property(this, &AddressAPI::getTransport));
registerProperty("username", make_property(this, &AddressAPI::getUsername));
} else {
registerProperty("displayName", make_property(this, &AddressAPI::getDisplayName, &AddressAPI::setDisplayName));
registerProperty("domain", make_property(this, &AddressAPI::getDomain, &AddressAPI::setDomain));
registerProperty("port", make_property(this, &AddressAPI::getPort, &AddressAPI::setPort));
registerProperty("transport", make_property(this, &AddressAPI::getTransport, &AddressAPI::setTransport));
registerProperty("username", make_property(this, &AddressAPI::getUsername, &AddressAPI::setUsername));
}
registerProperty("scheme", make_property(this, &AddressAPI::getScheme));
}
