TITANIUM_FUNCTION(Buffer, append)
	{
		if (arguments.size() == 0) {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::append", "Buffer::append: Too few argument");
		}

		ENSURE_OBJECT_AT_INDEX(sourceBuffer, 0);
		ENSURE_OPTIONAL_UINT_AT_INDEX(sourceOffset, 1, 0);
		ENSURE_OPTIONAL_UINT_AT_INDEX(sourceLength, 2, 0);

		const auto buffer = sourceBuffer.GetPrivate<Buffer>();
		if (buffer) {
			if (sourceLength == 0) {
				sourceLength = static_cast<std::uint32_t>(buffer->get_length());
			}
		} else {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::append", "Buffer::append: Unable to get Buffer");
		}

		if (buffer->get_length() < sourceOffset + sourceLength) {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::append", "Buffer::append: Invalid argument");
		}

		return get_context().CreateNumber(append(buffer, sourceOffset, sourceLength));
	}
		TITANIUM_FUNCTION(MusicPlayer, setQueue)
		{
			ENSURE_OBJECT_AT_INDEX(js_queue, 0);

			std::vector<std::shared_ptr<Item>> queues;

			const auto queue = js_queue.GetPrivate<Item>();

			if (queue != nullptr) {
				queues.push_back(queue);
			} else if (js_queue.IsArray()) {
				const auto js_array = static_cast<std::vector<JSValue>>(static_cast<JSArray>(js_queue));
				for (const auto v : js_array) {
					queues.push_back(static_cast<JSObject>(v).GetPrivate<Item>());
				}
			} else if (js_queue.HasProperty("items")) {
				// PlayerQueue
				const auto js_playerQueue = static_cast<JSObject>(js_queue.GetProperty("items"));
				if (js_playerQueue.IsArray()) {
					const auto js_array = static_cast<std::vector<JSValue>>(static_cast<JSArray>(js_playerQueue));
					for (const auto v : js_array) {
						queues.push_back(static_cast<JSObject>(v).GetPrivate<Item>());
					}
				}
			}

			setQueue(queues);

			return get_context().CreateUndefined();
		}
Ejemplo n.º 3
0
	TITANIUM_FUNCTION(Module, applyProperties)
	{
		ENSURE_OBJECT_AT_INDEX(props, 0);

		applyProperties(props, this_object);
		return get_context().CreateUndefined();
	}
	TITANIUM_FUNCTION(Buffer, copy)
	{
		if (arguments.size() < 2) {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::copy", "Buffer::copy: Too few argument");
		}

		ENSURE_OBJECT_AT_INDEX(sourceBuffer, 0);
		ENSURE_UINT_AT_INDEX(offset, 1);
		ENSURE_OPTIONAL_UINT_AT_INDEX(sourceOffset, 2, 0);
		ENSURE_OPTIONAL_UINT_AT_INDEX(sourceLength, 3, 0);

		const auto buffer = sourceBuffer.GetPrivate<Buffer>();
		if (buffer) {
			if (sourceLength == 0) {
				sourceLength = static_cast<std::uint32_t>(buffer->get_data().size());
			}
		} else {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::copy", "Buffer::copy: Unable to get Buffer");
		}

		if (get_length() <= offset || buffer->get_length() < sourceOffset + sourceLength) {
			HAL::detail::ThrowRuntimeError("Titanium::Buffer::insert", "Buffer::insert: Invalid argument");
		}

		return get_context().CreateNumber(copy(buffer, offset, sourceOffset, sourceLength));
	}
Ejemplo n.º 5
0
	TITANIUM_FUNCTION(Module, removeEventListener)
	{
		ENSURE_STRING_AT_INDEX(name, 0);
		ENSURE_OBJECT_AT_INDEX(callback, 1);

		TITANIUM_ASSERT(callback.IsFunction());
		removeEventListener(name, callback, this_object);
		return get_context().CreateUndefined();
	}
		TITANIUM_FUNCTION(PickerColumn, removeRow)
		{
			ENSURE_OBJECT_AT_INDEX(row_object, 0);
			const auto row = row_object.GetPrivate<PickerRow>();
			if (row) {
				removeRow(row);
			}
			return get_context().CreateUndefined();
		}
Ejemplo n.º 7
0
		TITANIUM_FUNCTION(Tab, close)
		{
			ENSURE_OBJECT_AT_INDEX(window, 0);
			ENSURE_OPTIONAL_OBJECT_AT_INDEX(options, 1);

			close(window.GetPrivate<Window>(), options.GetPrivate<CloseWindowParams>());

			return get_context().CreateUndefined();
		}
		//
		// _executeListener is internal function for Ti.App event callback.
		//
		TITANIUM_FUNCTION(WebView, _executeListener)
		{
			ENSURE_ARGUMENT_INDEX(1);
			ENSURE_OBJECT_AT_INDEX(callee, 1);
			auto webview = callee.GetProperty("webview");
			if (!webview.IsObject()) {
				TITANIUM_LOG_WARN("WebView._executeListener: Can't find this object");
				return get_context().CreateUndefined();
			}
			auto webview_ptr = static_cast<JSObject>(webview).GetPrivate<Titanium::UI::WebView>();
			TITANIUM_ASSERT(webview_ptr);

			ENSURE_OBJECT_AT_INDEX(data, 0);
			webview_ptr->_executeListener(
				static_cast<std::string>(data.GetProperty("type")),
				static_cast<std::string>(static_cast<JSValue>(data).ToJSONString()));

			return get_context().CreateUndefined();
		}
	TITANIUM_FUNCTION(IOStream, read)
	{
		ENSURE_OBJECT_AT_INDEX(buffer_object, 0);
		ENSURE_OPTIONAL_UINT_AT_INDEX(offset, 1, 0);
		const auto buffer = buffer_object.GetPrivate<Buffer>();
		if (buffer == nullptr) {
			HAL::detail::ThrowRuntimeError("Titanium::IOStream::read", "Titanium::IOStream::read: Invalid arguments");
		}
		ENSURE_OPTIONAL_UINT_AT_INDEX(length, 2, buffer->get_length());
		return get_context().CreateNumber(read(buffer, offset, length));
	}
TITANIUM_FUNCTION(Properties, setObject)
{
    ENSURE_STRING_AT_INDEX(property, 0);
    ENSURE_OBJECT_AT_INDEX(value, 1);

    const auto js_context = this_object.get_context();
    const auto object_ptr = GetStaticObject(js_context).GetPrivate<Properties>();

    object_ptr->setObject(property, value);
    return js_context.CreateUndefined();
}
		TITANIUM_FUNCTION(Group, remove)
		{
			ENSURE_OBJECT_AT_INDEX(person, 0);
			remove(person.GetPrivate<Person>());
			return get_context().CreateUndefined();
		}
		TITANIUM_FUNCTION(ProgressBar, add)
		{
			ENSURE_OBJECT_AT_INDEX(view, 0);
			add(view.GetPrivate<View>());
			return get_context().CreateUndefined();
		}