Пример #1
0
KeyRange::KeyRange(FB::variant left, FB::variant right, int flags)
	: flags(flags), left(left), right(right)
	{
	if(left.get_type() != right.get_type() && !left.empty() && !right.empty())
		throw new DatabaseException("NOT_ALLOWED_ERR", DatabaseException::NOT_ALLOWED_ERR);

	initializeMethods();
	}
Пример #2
0
KeyRangePtr KeyRange::bound(FB::variant left, FB::variant right, const bool openLeft, const bool openRight)
{ 
    int flags(!left.empty() ? LEFT_BOUND : 0);
    if (!right.empty()) flags |= RIGHT_BOUND;
    if (openLeft) flags |= LEFT_OPEN;
    if (openRight) flags |= RIGHT_OPEN;
    
    return boost::make_shared<KeyRange>(left, right, flags);

}
FB::variant BracExtenssionProviderAPI::getLogMessage(const FB::variant& msg) {
	int max_id = m_log_messages.size() - 1;
	if (msg.empty() && max_id >= 0)
		return m_log_messages[max_id];
	else {
		int msg_id = msg.convert_cast<int>();
		if (msg_id >= 0 && msg_id <= max_id) 
			return m_log_messages[max_id - msg_id];
	}

	return "Invalid index";
}
FB::variant BracExtenssionProviderAPI::getSysCallResult(const FB::variant& msg) {
	int max_id = m_syscall_results.size() - 1;
	if (msg.empty() && max_id >= 0)
		return m_syscall_results[max_id];
	else {
		int msg_id = msg.convert_cast<int>();
		if (msg_id >= 0 && msg_id <= max_id) 
			return m_syscall_results[max_id - msg_id];
	}

	return "Invalid index";
}
Пример #5
0
void NpapiBrowserHost::getNPVariant(NPVariant *dst, const FB::variant &var)
{
    assertMainThread();
    
    const NPVariantBuilderMap& builderMap = getNPVariantBuilderMap();
    const std::type_info& type = var.get_type();
    NPVariantBuilderMap::const_iterator it = builderMap.find(&type);
    
    if (it == builderMap.end()) {
        // unhandled type :(
        return;
    }
    
    *dst = (it->second)(FB::ptr_cast<NpapiBrowserHost>(shared_from_this()), var);
}
Пример #6
0
std::string Convert::stringify(const FB::BrowserHostPtr& host, const FB::JSObjectPtr& object)
	{
	if(host == NULL)
		throw DatabaseException("Browser host was null.", DatabaseException::NOT_FOUND_ERR);
	else if(!host->getDOMWindow()->getProperty<FB::variant>("JSON").is_of_type<FB::JSObjectPtr>())
		throw DatabaseException("Could not cast window.JSON to type object.", DatabaseException::UNKNOWN_ERR);

	FB::JSObjectPtr json = host->getDOMWindow()->getProperty<FB::JSObjectPtr>("JSON");

	if(json == NULL)
		throw DatabaseException("window.JSON support not available.", DatabaseException::NOT_FOUND_ERR);
	else if(json->HasMethod("stringify"))
		{
		FB::VariantList arguments(1, object);
		FB::variant result = json->Invoke("stringify", arguments);

		if(result.empty())
			throw DatabaseException("JSON Stringification failed.", DatabaseException::RECOVERABLE_ERR);
		else
			return result.cast<std::string>();
		}
	else
		throw DatabaseException("window.JSON missing method stringify().", DatabaseException::NOT_FOUND_ERR);
	}
Пример #7
0
Data::ECMAType Convert::getType(const FB::variant& variant)
	{
	if(variant.is_of_type<wstring>())
		return Data::String;
	else if(variant.is_of_type<string>())
		return Data::String;
    else if (variant.can_be_type<int>())
        return Data::Integer;
	else if(variant.is_of_type<double>())
		return Data::Number;
	else if(variant.is_of_type<FB::JSObjectPtr>())
		return Data::Object;
	else if(variant.empty())
		return Data::Undefined;
	else
		throw DatabaseException("An unexpected variant type was encountered.", DatabaseException::UNKNOWN_ERR);
	}
Пример #8
0
void ActiveXBrowserHost::getComVariant(VARIANT *dest, const FB::variant &var)
{
    CComVariant outVar;
    ::VariantInit(dest);

    const ComVariantBuilderMap& builderMap = getComVariantBuilderMap();
    const std::type_info& type = var.get_type();
    ComVariantBuilderMap::const_iterator it = builderMap.find(&type);
    
    if (it == builderMap.end()) {
        // unhandled type :(
        return;
    }
    
    outVar = (it->second)(FB::ptr_cast<ActiveXBrowserHost>(shared_ptr()), var);

    outVar.Detach(dest);
}
FB::variant BracExtenssionProviderAPI::saveToBracFile(const FB::variant& msg) {
	std::string command = "";

	if (msg.empty())
		log("Received message is empty.");

	std::string msg_str = msg.cast<std::string>();
	std::istringstream input(msg_str);
	jsonxx::Object o;
	if(!jsonxx::Object::parse(input, o)) {
		log("Couldn't parse the JSON message.");
		return "error";
	}
	
	if(!o.has<jsonxx::Object>("brac")) {
		log("Couldn't find the brac JSON object.");
		return "error";
	}

	jsonxx::Object & brac_info = o.get<jsonxx::Object>("brac");
	jsonxx::Object & bric_info = o.get<jsonxx::Object>("bric");
	std::string path = brac_info.get<std::string>("filepath");
	std::string path_orig = path;
	path += ".zip";
	
	#if defined _WIN32
		char drive[_MAX_DRIVE];
		char dir[_MAX_DIR];
		char fname[_MAX_FNAME];
		char ext[_MAX_EXT];
		_splitpath(path.c_str(), drive, dir, fname, ext);
		command = "rename \"" + path_orig + "\"  \"" + fname + ext + "\"";
	#elif defined __APPLE__
		std::string escaped_path = escape_path(path);
		std::string escaped_path_orig = escape_path(path_orig);
		command = "mv " + escaped_path_orig + " " + escaped_path;
	#endif
	systemCall(command);

	#if defined _WIN32
		command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe e -y \"" + path + "\" brac.xml";
	#elif defined __APPLE__
		std::string escaped_extension_path = escape_path(m_extension_path);
		command = "cd " + escaped_extension_path + "; bin/7za e -y " + escaped_path + " brac.xml";
	#endif
	systemCall(command);

	std::string in_file = m_extension_path + "/brac.xml";

	pugi::xml_document brac_xml;
	pugi::xml_parse_result result = brac_xml.load_file(in_file.c_str());
	if (!result)
		log(result.description());
	pugi::xml_node brac_node = brac_xml.child("brac");

	if (brac_node.empty()) {
		log("brac node could not be found");
		return "error";
	}

	pugi::xml_node layers_node = brac_node.child("layers");

	if (layers_node.empty()) {
		log("layers node could not be found");
		return "error";
	}

	pugi::xml_object_range<pugi::xml_node_iterator> layers = layers_node.children();
	int max_id = -1;
	if (layers.begin() != layers.end())
		for (pugi::xml_node_iterator itr = layers.begin(); itr != layers.end(); ++itr)
			if (max_id < itr->attribute("id").as_int())
				max_id = itr->attribute("id").as_int();
	int new_brac_num = max_id + 1;

	pugi::xml_node bric_node = layers_node.append_child("bric");

	time_t t = time(0);   // get current time
	struct tm * now = localtime( &t );
	char time_now[50];
	sprintf(time_now, "%d-%02d-%02d %02d:%02d:%02d",
		now->tm_year + 1900,
		now->tm_mon + 1,
		now->tm_mday,
		now->tm_hour,
		now->tm_min,
		now->tm_sec
	);

	bric_node.append_attribute("revision"    ).set_value(1);
	bric_node.append_attribute("lastupdate"  ).set_value(time_now);
	bric_node.append_attribute("id"          ).set_value(new_brac_num);
	bric_node.append_attribute("alpha"       ).set_value(bric_info.get<std::string>("alpha"       ).c_str());
	bric_node.append_attribute("order"       ).set_value(bric_info.get<std::string>("order"       ).c_str());
	bric_node.append_attribute("resolution"  ).set_value(bric_info.get<std::string>("resolution"  ).c_str());
	bric_node.append_attribute("position"    ).set_value(bric_info.get<std::string>("position"    ).c_str());
	bric_node.append_attribute("maskposition").set_value(bric_info.get<std::string>("maskposition").c_str());
	bric_node.append_attribute("rotate"      ).set_value(bric_info.get<std::string>("rotation"    ).c_str());
	bric_node.append_attribute("scale"       ).set_value(bric_info.get<std::string>("scale"       ).c_str());
	bric_node.append_attribute("timeinterval").set_value(bric_info.get<std::string>("timeInterval").c_str());

	bric_node.append_child(pugi::node_pcdata).set_value(bric_info.get<std::string>("comment").c_str());

	brac_node.attribute("name")  .set_value(brac_info.get<std::string>("name").c_str());
	brac_node.attribute("artist").set_value(brac_info.get<std::string>("artist").c_str());
	brac_node.attribute("tags")  .set_value(brac_info.get<std::string>("tags").c_str());
	
	pugi::xml_object_range<pugi::xml_node_iterator> children = brac_node.children();
	for (pugi::xml_node_iterator itr = children.begin(); itr != children.end(); ++itr)
		if (itr->type() == pugi::node_pcdata) {
			brac_node.remove_child(*itr);
			itr = children.begin();
		}
	brac_node.append_child(pugi::node_pcdata).set_value(brac_info.get<std::string>("comment").c_str());

	std::string out_file = m_extension_path + "/brac.xml";
	
	if (!brac_xml.save_file(out_file.c_str()))
		log("Error occurred while creating the new brac file: " + out_file);

	#if defined _WIN32
		command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe u \"" + path + "\" brac.xml & del /F /Q brac.xml";
	#elif defined __APPLE__
		command = "cd " + escaped_extension_path + "; bin/7za u " + escaped_path + " brac.xml; rm -f brac.xml";
	#endif
	systemCall(command);

	std::stringstream stm;
	stm << new_brac_num;
	std::string new_bric_path = m_extension_path + "/temp/bric." + stm.str();
	#if defined _WIN32
		command = "mkdir \"" + new_bric_path + "\"";
	#elif defined __APPLE__
		std::string escaped_new_bric_path = escape_path(new_bric_path);
		command = "mkdir -p " + escaped_new_bric_path;
	#endif
	systemCall(command);

	pugi::xml_document bric_xml;
	pugi::xml_node root_node = bric_xml.append_child("bric");
	root_node.append_attribute("version"     ).set_value("1.0");
	root_node.append_attribute("title"       ).set_value(bric_info.get<std::string>("title"       ).c_str());
	root_node.append_attribute("timeinterval").set_value(bric_info.get<std::string>("timeInterval").c_str());
	root_node.append_attribute("startdate"   ).set_value(bric_info.get<std::string>("startDate"   ).c_str());
	root_node.append_attribute("url"         ).set_value(bric_info.get<std::string>("url"         ).c_str());
	root_node.append_attribute("region"      ).set_value(bric_info.get<std::string>("region"      ).c_str());
	root_node.append_attribute("tags"        ).set_value(bric_info.get<std::string>("tags"        ).c_str());

	pugi::xml_node snapshot_node = root_node.append_child("snapshot");
	snapshot_node.append_attribute("revision").set_value("1");
	snapshot_node.append_attribute("date").set_value(time_now);

	std::string new_bric_filepath = new_bric_path + "/bric.xml";
	std::string bric_screenshot_filename = "1.png";
	std::string bric_screenshot = new_bric_path + "/" + bric_screenshot_filename;
	std::string bric_thumbnail = "thumb.png";
	std::string bric_thumbnail_path = new_bric_path + "/" + bric_thumbnail;

	if (!bric_xml.save_file(new_bric_filepath.c_str()))
		log("Error occurred while creating the new bric file: " + new_bric_filepath);

	std::vector<std::string> brac_resolution = split(brac_info.get<std::string>("resolution"), ' ');
	if (brac_resolution.size() != 2)
		log("Brac resolution should be a pair of integer numbers, separated by space character.");

	std::vector<std::string> bric_region = split(bric_info.get<std::string>("local_region"), ' ');
	if (bric_region.size() != 4)
		log("Bric region should be four integer numbers, separated by space character.");
	
	std::string mask_layer_b64 = bric_info.get<std::string>("mask_b64").c_str();
	bool mask_created = false;
	std::string mask_filename = new_bric_path + "/mask.png";
	if (!mask_layer_b64.empty()) {
		std::string	decoded = base64_decode(mask_layer_b64);
		mask_created = saveBinaryFile(mask_filename.c_str(), decoded.c_str(), decoded.size());
	}

	#if defined _WIN32
		command = "cd /d \"" + m_extension_path + "\" & move \"" + m_screenshot_dir + "\\" + m_screenshot_filename + "\" \"" + bric_screenshot + "\"";
		systemCall(command);

//*/
		command = "cd /d \"" + m_extension_path + "\" & bin\\clg-crop.exe"
			+ " \"" + bric_screenshot + "\" "
			+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
/*/
    
        command = "cd /d \"" + m_extension_path + "\" & python bin\\crop.py"
            + " \"" + bric_screenshot + "\" "
            + bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
 //*/
		systemCall(command);

		command = "cd /d \"" + new_bric_path + "\" & copy " + bric_screenshot_filename + " " + bric_thumbnail;
		systemCall(command);

		command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe a \"" + path + "\" \"" + new_bric_path + "\"";
		systemCall(command);

		command = "rmdir /S /Q \"" + m_extension_path + "\\temp\"";
		systemCall(command);

		_splitpath(path_orig.c_str(), drive, dir, fname, ext);
		command = "rename \"" + path + "\"  \"" + fname + ext + "\"";
		systemCall(command);
	#elif defined __APPLE__
		std::string escaped_bric_screenshot = escape_path(bric_screenshot);
		std::string escaped_screenshot_dir  = escape_path(m_screenshot_dir);
		command = "mv " + escaped_screenshot_dir + "/" + m_screenshot_filename + " " + escaped_bric_screenshot;
		systemCall(command);

//*/
		command = "cd " + escaped_extension_path + "; open -gW bin/clg-crop.app --args "
			+ " " + escaped_bric_screenshot + " "
			+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
/*/
        command = "cd " + escaped_extension_path + "; bin/crop.py"
            + " " + escaped_bric_screenshot + " "
            + bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
//*/
		systemCall(command);

		std::string escaped_bric_thumbnail = escape_path(bric_thumbnail_path);
		command = "cp \"" + escaped_bric_screenshot + "\" \"" + escaped_bric_thumbnail + "\"";
		systemCall(command);

		command = "cd " + escaped_extension_path + "; bin/7za a " + escaped_path + " " + escaped_new_bric_path;
		systemCall(command);

		command = "rm -Rf " + escaped_extension_path + "/temp";
		systemCall(command);

		command = "mv " + escaped_path + " " + escaped_path_orig;
		systemCall(command);
	#endif

	fire_cleanup();

	return "done!";
}
FB::variant BracExtenssionProviderAPI::takeSnapShot(const FB::variant& msg) {

	if (msg.empty()) {
		log("Received message is empty.");
		return false;
	}

	std::string msg_str = msg.cast<std::string>();
	std::istringstream input(msg_str);
	jsonxx::Object o;
	if(!jsonxx::Object::parse(input, o))
		log("Couldn't parse the JSON message.");

	std::string url = o.get<std::string>("url");

	std::string width      = o.get<std::string>("width");
	std::string height     = o.get<std::string>("height");
	std::string scrollLeft = o.get<std::string>("scrollLeft");
	std::string scrollTop  = o.get<std::string>("scrollTop");
	m_screenshot_dir       = m_extension_path + "/img/screenshot";
	m_screenshot_filename  = o.get<std::string>("filename");
	std::string command    = "";

	#if defined _WIN32
		command = "mkdir \"" + escape_path(m_screenshot_dir) + "\"";
		systemCall(command);

		std::string filepath = m_screenshot_dir + "/" + m_screenshot_filename;
    
//*/
		command = "cd /d \"" + m_extension_path + "\" & bin\\clg-snapshot.exe "
			+ "\"" + url + "\" "      // target url
			+ "\"" + filepath + "\" " // target filepath
			+ width      + " "      // window width
			+ height     + " "      // window height
			+ scrollLeft + " "      // scrollLeft
			+ scrollTop             // scrollTop
			;// using default timeout
/*/
    
        command = "cd /d \"" + m_extension_path + "\" & python bin\\snapshot.py "
            + "\"" + url + "\" "      // target url
            + "\"" + filepath + "\" " // target filepath
            + width      + " "      // window width
            + height     + " "      // window height
            + scrollLeft + " "      // scrollLeft
            + scrollTop             // scrollTop
            ;// using default timeout
//*/
		systemCall(command);
	#elif defined __APPLE__
		std::string escaped_extension_path = escape_path(m_extension_path);
		std::string escaped_dir = escape_path(m_screenshot_dir);

		command = "mkdir -p " + escaped_dir;
		systemCall(command);

		std::string filepath = escaped_dir + "/" + m_screenshot_filename;

//*/
		command = "cd " + escaped_extension_path + "; "
			+ "open -gW bin/clg-snapshot.app --args "
			+ "'" + url + "' "      // target url
			+ "'" + filepath + "' " // target filepath
			+ width      + " "      // window width
			+ height     + " "      // window height
			+ scrollLeft + " "      // scrollLeft
			+ scrollTop             // scrollTop
			;// using default timeout
/*/
    
        command = "cd " + escaped_extension_path + "; "
            + "bin/snapshot.py "
            + "'" + url + "' "      // target url
            + "'" + filepath + "' " // target filepath
            + width      + " "      // window width
            + height     + " "      // window height
            + scrollLeft + " "      // scrollLeft
            + scrollTop             // scrollTop
            ;// using default timeout
 //*/
		systemCall(command);
	#endif

	return "done!";
}
Пример #11
0
FB::AutoPtr<KeyRange> KeyRange::bound(FB::variant left, FB::variant right, const bool openLeft, const bool openRight)
	{ return new KeyRange(left, right, 
		(!left.empty() ? KeyRange::LEFT_BOUND : 0) | 
		(!right.empty() ? KeyRange::RIGHT_BOUND : 0) |
		(openLeft ? KeyRange::LEFT_OPEN : 0) |
		(openRight ? KeyRange::RIGHT_OPEN : 0)); }
Пример #12
0
void NpapiBrowserHost::getNPVariant(NPVariant *dst, const FB::variant &var)
{
    if (var.get_type() == typeid(FB::Npapi::NpapiNull)) {
        dst->type = NPVariantType_Null;

    } else if (var.get_type() == typeid(int)
        || var.get_type() == typeid(long)
        || var.get_type() == typeid(short)
        || var.get_type() == typeid(char)
        || var.get_type() == typeid(unsigned int)
        || var.get_type() == typeid(unsigned short)
        || var.get_type() == typeid(unsigned char)) {
        // Integer type
        dst->type = NPVariantType_Int32;
        dst->value.intValue = var.convert_cast<long>();

    } else if (var.get_type() == typeid(double)
        || var.get_type() == typeid(float)) {
        dst->type = NPVariantType_Double;
        dst->value.doubleValue = var.convert_cast<double>();

    } else if (var.get_type() == typeid(bool)) {
        dst->type = NPVariantType_Bool;
        dst->value.boolValue = var.convert_cast<bool>();

    } else if (var.get_type() == typeid(std::string)) {
        std::string str = var.convert_cast<std::string>();
        char *outStr = (char*)this->MemAlloc(str.size() + 1);
        memcpy(outStr, str.c_str(), str.size() + 1);
        dst->type = NPVariantType_String;
        dst->value.stringValue.UTF8Characters = outStr;
        dst->value.stringValue.UTF8Length = str.size();

    } else if (var.get_type() == typeid(FB::VariantList)) {
        JSAPI_DOMNode outArr = this->getDOMWindow().createArray();
        FB::VariantList inArr = var.cast<FB::VariantList>();
        for (FB::VariantList::iterator it = inArr.begin(); it != inArr.end(); it++) {
            outArr.callMethod<void>("push", variant_list_of(*it));
        }
        FB::AutoPtr<NPObjectAPI> api = dynamic_cast<NPObjectAPI*>(outArr.getJSObject().ptr());
        if (api.ptr() != NULL) {
            dst->type = NPVariantType_Object;
            dst->value.objectValue = api->getNPObject();
            this->RetainObject(dst->value.objectValue);
        }

    } else if (var.get_type() == typeid(FB::VariantMap)) {
        JSAPI_DOMNode out = this->getDOMWindow().createMap();
        FB::VariantMap inMap = var.cast<FB::VariantMap>();
        for (FB::VariantMap::iterator it = inMap.begin(); it != inMap.end(); it++) {
            out.setProperty(it->first, it->second);
        }
        FB::AutoPtr<NPObjectAPI> api = dynamic_cast<NPObjectAPI*>(out.getJSObject().ptr());
        if (api.ptr() != NULL) {
            dst->type = NPVariantType_Object;
            dst->value.objectValue = api->getNPObject();
            this->RetainObject(dst->value.objectValue);
        }

    } else if (var.get_type() == typeid(FB::JSOutObject)) {
        NPObject *outObj = NULL;
        FB::JSOutObject obj = var.cast<FB::JSOutObject>();
        NPObjectAPI *tmpObj = dynamic_cast<NPObjectAPI *>(obj.ptr());

        if (tmpObj == NULL) {
            outObj = NPJavascriptObject::NewObject(this, obj);
        } else {
            outObj = tmpObj->getNPObject();
            this->RetainObject(outObj);
        }

        dst->type = NPVariantType_Object;
        dst->value.objectValue = outObj;

    } else if (var.get_type() == typeid(FB::JSObject)) {
        NPObject *outObj = NULL;
        FB::JSObject obj = var.cast<JSObject>();
        NPObjectAPI *tmpObj = dynamic_cast<NPObjectAPI *>(obj.ptr());

        if (tmpObj == NULL) {
            outObj = NPJavascriptObject::NewObject(this, obj);
        } else {
            outObj = tmpObj->getNPObject();
            this->RetainObject(outObj);
        }

        dst->type = NPVariantType_Object;
        dst->value.objectValue = outObj;
    }
    // TODO: implement object types
}