Tag: cef

Overloading by return value in C++

Here we have a method that allows us to determine return parameter type using templates and operator overloading in C++. This is something that I needed for a project that I am working on where a method call would give me the expected type based on the return type.

Usage

There is two way of using this. First one is by calling the para method and second one is by invoking the conversion method directly parameter.
Personally, I prefer the first one as this one allows me to use it with auto keyword.


std::string p0   = param<std::string>(arguments, 0);
auto        p0_a = param<std::string>(arguments, 0);

int         p1   = param<int>(arguments, 1);
auto        p1_a = param<int>(arguments, 1);

// Invoking parameter conversion directly
std::string p0_p = parameter(arguments, 0); 
int         p1_p = parameter(arguments, 1);

Implemenation

struct parameter
{
	parameter(const CefV8ValueList & arguments, int index) 
		:_arg (arguments.at(index)) 
	{
	};

	operator std::string() { return _arg->GetStringValue().ToString(); }
	operator int() { return _arg->GetIntValue();}
	operator bool() { return _arg->GetBoolValue(); }
	operator double() { return _arg->GetDoubleValue();}

	CefRefPtr _arg;
};

template
T param(const CefV8ValueList & arguments, int index)
{
	return parameter(arguments, index);
}

Reference :
http://en.cppreference.com/w/cpp/language/cast_operator

August 18, 2017

Creating Javascript accessible object from C++ / CEF

Example with Chromium Embedded Framework (CEF) on how to create an object in C++ and make it accessible via Javascript.

console.inof(api)
Object {ready: true, version: "psql.0.0.1", info: Object, getVersion: function}

void ExtractEngineApp::OnContextCreated(
	CefRefPtr browser, 
	CefRefPtr frame, 
	CefRefPtr context)
{

	auto info = CefV8Value::CreateObject(NULL, NULL);
	info->SetValue("major", CefV8Value::CreateString("0"), V8_PROPERTY_ATTRIBUTE_READONLY);
	info->SetValue("minor", CefV8Value::CreateString("1"), V8_PROPERTY_ATTRIBUTE_READONLY);
	
	auto global = context->GetGlobal();
	auto api = CefV8Value::CreateObject(NULL, NULL);

	global->SetValue("api", api, V8_PROPERTY_ATTRIBUTE_NONE);

	auto fun = CefV8Value::CreateFunction("getVersion", new engine:: PhantomExtensionHandler(this));
	api->SetValue("getVersion", fun, V8_PROPERTY_ATTRIBUTE_NONE);
	
	// Readonly properties
	api->SetValue("ready", CefV8Value::CreateBool(true), V8_PROPERTY_ATTRIBUTE_READONLY);
	api->SetValue("version", CefV8Value::CreateString("psql.0.0.1"), V8_PROPERTY_ATTRIBUTE_READONLY);

	// Readonly Object access
	api->SetValue("info", info, V8_PROPERTY_ATTRIBUTE_READONLY);
}


class PhantomExtensionHandler : public CefV8Handler
	{
	public:
		explicit PhantomExtensionHandler(CefRefPtr client_app)
			: client_app(client_app)
			, messageId(0)
		{

		}

		virtual bool Execute(const CefString& name,
			CefRefPtr object,
			const CefV8ValueList& arguments,
			CefRefPtr& retval,
			CefString& exception)
		{
			if (name == "getVersion")
			{
				retval = CefV8Value::CreateString("Version(SemVer) # 0.0.1");
			}

			return true;
		}

	private:
		CefRefPtr client_app;
		int32 messageId;

		IMPLEMENT_REFCOUNTING(PhantomExtensionHandler);
	};

May 1, 2017