haiku.git

/*
 * Copyright 2002-2008, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */


#include <InputServerDevice.h>

#include <new>

#include <Directory.h>
#include <Path.h>

#include "InputServer.h"


DeviceAddOn::DeviceAddOn(BInputServerDevice *device)
	:
	fDevice(device)
{
}


DeviceAddOn::~DeviceAddOn()
{
	while (const char* path = fMonitoredPaths.PathAt(0)) {
		gInputServer->AddOnManager()->StopMonitoringDevice(this, path);
	}
}


bool
DeviceAddOn::HasPath(const char* path) const
{
	return fMonitoredPaths.HasPath(path);
}


status_t
DeviceAddOn::AddPath(const char* path)
{
	return fMonitoredPaths.AddPath(path);
}


status_t
DeviceAddOn::RemovePath(const char* path)
{
	return fMonitoredPaths.RemovePath(path);
}


int32
DeviceAddOn::CountPaths() const
{
	return fMonitoredPaths.CountPaths();
}


//	#pragma mark -


BInputServerDevice::BInputServerDevice()
{
	fOwner = new(std::nothrow) DeviceAddOn(this);
}


BInputServerDevice::~BInputServerDevice()
{
	CALLED();

	gInputServer->UnregisterDevices(*this);
	delete fOwner;
}


status_t
BInputServerDevice::InitCheck()
{
	if (fOwner == NULL)
		return B_NO_MEMORY;
	return B_OK;
}


status_t
BInputServerDevice::SystemShuttingDown()
{
	return B_OK;
}


status_t
BInputServerDevice::Start(const char* device, void* cookie)
{
	return B_OK;
}


status_t
BInputServerDevice::Stop(const char* device, void* cookie)
{
	return B_OK;
}


status_t
BInputServerDevice::Control(const char* device, void* cookie,
	uint32 code, BMessage* message)
{
	return B_OK;
}


status_t
BInputServerDevice::RegisterDevices(input_device_ref** devices)
{
	CALLED();
	return gInputServer->RegisterDevices(*this, devices);
}


status_t
BInputServerDevice::UnregisterDevices(input_device_ref** devices)
{
    CALLED();
    // TODO: is this function supposed to remove devices that do not belong to this object?
    //	(at least that's what the previous implementation allowed for)
	return gInputServer->UnregisterDevices(*this, devices);
}


status_t
BInputServerDevice::EnqueueMessage(BMessage* message)
{
	return gInputServer->EnqueueDeviceMessage(message);
}


status_t
BInputServerDevice::StartMonitoringDevice(const char* device)
{
	CALLED();
	PRINT(("StartMonitoringDevice %s\n", device));

	return gInputServer->AddOnManager()->StartMonitoringDevice(fOwner, device);
}


status_t
BInputServerDevice::StopMonitoringDevice(const char* device)
{
	return gInputServer->AddOnManager()->StopMonitoringDevice(fOwner, device);
}


status_t
BInputServerDevice::AddDevices(const char* path)
{
	BDirectory directory;
	status_t status = directory.SetTo(path);
	if (status != B_OK)
		return status;

	BEntry entry;
	while (directory.GetNextEntry(&entry) == B_OK) {
		BPath entryPath(&entry);

		if (entry.IsDirectory()) {
			AddDevices(entryPath.Path());
		} else {
			BMessage added(B_NODE_MONITOR);
			added.AddInt32("opcode", B_ENTRY_CREATED);
			added.AddString("path", entryPath.Path());

			Control(NULL, NULL, B_INPUT_DEVICE_ADDED, &added);
		}
	}

	return B_OK;
}


void BInputServerDevice::_ReservedInputServerDevice1() {}
void BInputServerDevice::_ReservedInputServerDevice2() {}
void BInputServerDevice::_ReservedInputServerDevice3() {}
void BInputServerDevice::_ReservedInputServerDevice4() {}