Sorry for the confusing patch...
* Made KeyboardInputDevice more similar to MouseInputDevice, the object to
track individual keyboards has become the class KeyboardDevice. Moved
much functionality that used to be in KeyboardInputDevice into
KeyboardDevice.
Functionally, it should still be the same, but there are two important
changes:
- Each KeyboardDevice now has it's own Keymap. At first, it is not
visible by the user, since all KeyboardDevices still adopt the keymap
if the user reconfigures it. But it will make it easier to assign
individual keymaps to each attached keyboard (and perhaps associate them
with a vendor/product or some other means). The more immediate side effect
is that there is no longer a confusion about the keyboard locks. If
you press NumLock on your external keyboard, it will no longer enable
NumLock on your notebooks internal keyboard.
- KeyboardDevice now has a Stop() method, which it will call in it's
destructor. This will make sure that the control thread is cleanly
exited and does not end up invoking methods on a deleted object.
* Rewrote the tracing implementation in MouseInputDevice.cpp. At least it
helped track me down the following problem:
* Both KeyboardDevice and MouseDevice now set fActive to "false" *before*
closing the device. Since the control threads run at high priority, chances
are high that rescheduling happens as soon as the device unblocks in
ioctl() and returns an error. In that case, the control threads would
check fActive and it would still be "true" and the whole idea of bailing
out because we're already in Stop() would not work, causing a double free
in the end.
All of this is nice and more correct, but input_server is still crashing
when restarting it via "input_server -q"... :-(
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28352 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus
parent
393f282c79
commit
e01a043190
@ -371,242 +371,195 @@ get_short_name(const char* longName)
|
||||
// #pragma mark -
|
||||
|
||||
|
||||
KeyboardInputDevice::KeyboardInputDevice()
|
||||
:
|
||||
fDevices(2, true),
|
||||
fTeamMonitorWindow(NULL),
|
||||
KeyboardDevice::KeyboardDevice(KeyboardInputDevice* owner, const char* path)
|
||||
: BHandler("keyboard device"),
|
||||
fOwner(owner),
|
||||
fFD(-1),
|
||||
fThread(-1),
|
||||
fActive(false),
|
||||
fInputMethodStarted(false),
|
||||
fKeymapLock("keymap lock")
|
||||
{
|
||||
CALLED();
|
||||
strcpy(fPath, path);
|
||||
fDeviceRef.name = get_short_name(path);
|
||||
fDeviceRef.type = B_KEYBOARD_DEVICE;
|
||||
fDeviceRef.cookie = this;
|
||||
|
||||
StartMonitoringDevice(kKeyboardDevicesDirectory);
|
||||
_RecursiveScan(kKeyboardDevicesDirectory);
|
||||
fIsAT = strstr(path, "keyboard/at") != NULL;
|
||||
|
||||
if (be_app->Lock()) {
|
||||
be_app->AddHandler(this);
|
||||
be_app->Unlock();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
KeyboardInputDevice::~KeyboardInputDevice()
|
||||
KeyboardDevice::~KeyboardDevice()
|
||||
{
|
||||
CALLED();
|
||||
StopMonitoringDevice(kKeyboardDevicesDirectory);
|
||||
if (fActive)
|
||||
Stop();
|
||||
|
||||
free(fDeviceRef.name);
|
||||
|
||||
if (be_app->Lock()) {
|
||||
be_app->RemoveHandler(this);
|
||||
be_app->Unlock();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::SystemShuttingDown()
|
||||
KeyboardDevice::EnqueueInlineInputMethod(int32 opcode,
|
||||
const char* string, bool confirmed, BMessage* keyDown)
|
||||
{
|
||||
CALLED();
|
||||
if (fTeamMonitorWindow)
|
||||
fTeamMonitorWindow->PostMessage(SYSTEM_SHUTTING_DOWN);
|
||||
BMessage* message = new BMessage(B_INPUT_METHOD_EVENT);
|
||||
if (message == NULL)
|
||||
return B_NO_MEMORY;
|
||||
|
||||
message->AddInt32("be:opcode", opcode);
|
||||
message->AddBool("be:inline_only", true);
|
||||
|
||||
if (string != NULL)
|
||||
message->AddString("be:string", string);
|
||||
if (confirmed)
|
||||
message->AddBool("be:confirmed", true);
|
||||
if (keyDown)
|
||||
message->AddMessage("be:translated", keyDown);
|
||||
if (opcode == B_INPUT_METHOD_STARTED)
|
||||
message->AddMessenger("be:reply_to", this);
|
||||
|
||||
status_t status = fOwner->EnqueueMessage(message);
|
||||
if (status != B_OK)
|
||||
delete message;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyboardDevice::MessageReceived(BMessage* message)
|
||||
{
|
||||
if (message->what != B_INPUT_METHOD_EVENT) {
|
||||
BHandler::MessageReceived(message);
|
||||
return;
|
||||
}
|
||||
|
||||
int32 opcode;
|
||||
if (message->FindInt32("be:opcode", &opcode) != B_OK)
|
||||
return;
|
||||
|
||||
if (opcode == B_INPUT_METHOD_STOPPED)
|
||||
fInputMethodStarted = false;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardDevice::Start()
|
||||
{
|
||||
if ((fFD = open(fPath, O_RDWR)) < B_OK) {
|
||||
fprintf(stderr, "error when opening %s: %s\n", fPath, strerror(errno));
|
||||
return B_ERROR;
|
||||
}
|
||||
|
||||
InitFromSettings();
|
||||
|
||||
char threadName[B_OS_NAME_LENGTH];
|
||||
snprintf(threadName, B_OS_NAME_LENGTH, "%s watcher", fDeviceRef.name);
|
||||
|
||||
fActive = true;
|
||||
fThread = spawn_thread(_ThreadEntry, threadName,
|
||||
kKeyboardThreadPriority, this);
|
||||
if (fThread < B_OK)
|
||||
return fThread;
|
||||
|
||||
resume_thread(fThread);
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
void
|
||||
KeyboardDevice::Stop()
|
||||
{
|
||||
fActive = false;
|
||||
|
||||
close(fFD);
|
||||
fFD = -1;
|
||||
|
||||
if (fThread >= 0) {
|
||||
suspend_thread(fThread);
|
||||
resume_thread(fThread);
|
||||
status_t dummy;
|
||||
wait_for_thread(fThread, &dummy);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_InitFromSettings(void* cookie, uint32 opcode)
|
||||
KeyboardDevice::InitFromSettings(uint32 opcode)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
keyboard_device* device = (keyboard_device*)cookie;
|
||||
|
||||
if (opcode == 0 || opcode == B_KEY_REPEAT_RATE_CHANGED) {
|
||||
if (get_key_repeat_rate(&device->settings.key_repeat_rate) != B_OK)
|
||||
if (get_key_repeat_rate(&fSettings.key_repeat_rate) != B_OK)
|
||||
LOG_ERR("error when get_key_repeat_rate\n");
|
||||
else if (ioctl(device->fd, KB_SET_KEY_REPEAT_RATE,
|
||||
&device->settings.key_repeat_rate) != B_OK)
|
||||
LOG_ERR("error when KB_SET_KEY_REPEAT_RATE, fd:%d\n", device->fd);
|
||||
else if (ioctl(fFD, KB_SET_KEY_REPEAT_RATE,
|
||||
&fSettings.key_repeat_rate) != B_OK)
|
||||
LOG_ERR("error when KB_SET_KEY_REPEAT_RATE, fd:%d\n", fFD);
|
||||
}
|
||||
|
||||
if (opcode == 0 || opcode == B_KEY_REPEAT_DELAY_CHANGED) {
|
||||
if (get_key_repeat_delay(&device->settings.key_repeat_delay) != B_OK)
|
||||
if (get_key_repeat_delay(&fSettings.key_repeat_delay) != B_OK)
|
||||
LOG_ERR("error when get_key_repeat_delay\n");
|
||||
else if (ioctl(device->fd, KB_SET_KEY_REPEAT_DELAY,
|
||||
&device->settings.key_repeat_delay) != B_OK)
|
||||
LOG_ERR("error when KB_SET_KEY_REPEAT_DELAY, fd:%d\n", device->fd);
|
||||
else if (ioctl(fFD, KB_SET_KEY_REPEAT_DELAY,
|
||||
&fSettings.key_repeat_delay) != B_OK)
|
||||
LOG_ERR("error when KB_SET_KEY_REPEAT_DELAY, fd:%d\n", fFD);
|
||||
}
|
||||
|
||||
if (opcode == 0 || opcode == B_KEY_MAP_CHANGED
|
||||
|| opcode == B_KEY_LOCKS_CHANGED) {
|
||||
BAutolock lock(fKeymapLock);
|
||||
fKeymap.LoadCurrent();
|
||||
device->modifiers = fKeymap.Locks();
|
||||
_SetLeds(device);
|
||||
fModifiers = fKeymap.Locks();
|
||||
UpdateLEDs();
|
||||
}
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::InitCheck()
|
||||
void
|
||||
KeyboardDevice::UpdateLEDs()
|
||||
{
|
||||
CALLED();
|
||||
return BInputServerDevice::InitCheck();
|
||||
}
|
||||
if (fFD < 0)
|
||||
return;
|
||||
|
||||
uint32 locks = fModifiers;
|
||||
char lockIO[3];
|
||||
memset(lockIO, 0, sizeof(lockIO));
|
||||
if (locks & B_NUM_LOCK)
|
||||
lockIO[0] = 1;
|
||||
if (locks & B_CAPS_LOCK)
|
||||
lockIO[1] = 1;
|
||||
if (locks & B_SCROLL_LOCK)
|
||||
lockIO[2] = 1;
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Start(const char* name, void* cookie)
|
||||
{
|
||||
CALLED();
|
||||
keyboard_device* device = (keyboard_device*)cookie;
|
||||
|
||||
if ((device->fd = open(device->path, O_RDWR)) < B_OK) {
|
||||
fprintf(stderr, "error when opening %s: %s\n", device->path, strerror(errno));
|
||||
return B_ERROR;
|
||||
}
|
||||
|
||||
_InitFromSettings(device);
|
||||
|
||||
char threadName[B_OS_NAME_LENGTH];
|
||||
snprintf(threadName, B_OS_NAME_LENGTH, "%s watcher", name);
|
||||
|
||||
device->active = true;
|
||||
device->device_watcher = spawn_thread(_DeviceWatcher, threadName,
|
||||
kKeyboardThreadPriority, device);
|
||||
if (device->device_watcher < B_OK)
|
||||
return device->device_watcher;
|
||||
|
||||
resume_thread(device->device_watcher);
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Stop(const char* name, void* cookie)
|
||||
{
|
||||
CALLED();
|
||||
keyboard_device* device = (keyboard_device*)cookie;
|
||||
|
||||
LOG("Stop(%s)\n", name);
|
||||
|
||||
close(device->fd);
|
||||
device->fd = -1;
|
||||
|
||||
device->active = false;
|
||||
if (device->device_watcher >= 0) {
|
||||
suspend_thread(device->device_watcher);
|
||||
resume_thread(device->device_watcher);
|
||||
status_t dummy;
|
||||
wait_for_thread(device->device_watcher, &dummy);
|
||||
}
|
||||
|
||||
if (fTeamMonitorWindow) {
|
||||
fTeamMonitorWindow->PostMessage(B_QUIT_REQUESTED);
|
||||
fTeamMonitorWindow = NULL;
|
||||
}
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Control(const char* name, void* cookie,
|
||||
uint32 command, BMessage* message)
|
||||
{
|
||||
CALLED();
|
||||
LOG("Control(%s, code: %lu)\n", name, command);
|
||||
|
||||
if (command == B_NODE_MONITOR)
|
||||
_HandleMonitor(message);
|
||||
else if (command >= B_KEY_MAP_CHANGED
|
||||
&& command <= B_KEY_REPEAT_RATE_CHANGED) {
|
||||
_InitFromSettings(cookie, command);
|
||||
}
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_HandleMonitor(BMessage* message)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
const char* path;
|
||||
int32 opcode;
|
||||
if (message->FindInt32("opcode", &opcode) != B_OK
|
||||
|| (opcode != B_ENTRY_CREATED && opcode != B_ENTRY_REMOVED)
|
||||
|| message->FindString("path", &path) != B_OK)
|
||||
return B_BAD_VALUE;
|
||||
|
||||
if (opcode == B_ENTRY_CREATED)
|
||||
return _AddDevice(path);
|
||||
|
||||
#if 0
|
||||
return _RemoveDevice(path);
|
||||
#else
|
||||
// Don't handle B_ENTRY_REMOVED, let the control thread take care of it.
|
||||
return B_OK;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
keyboard_device*
|
||||
KeyboardInputDevice::_FindDevice(const char* path) const
|
||||
{
|
||||
for (int i = fDevices.CountItems() - 1; i >= 0; i--) {
|
||||
keyboard_device* device = fDevices.ItemAt(i);
|
||||
if (strcmp(device->path, path) == 0)
|
||||
return device;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_AddDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
_RemoveDevice(path);
|
||||
|
||||
keyboard_device* device = new(std::nothrow) keyboard_device(path);
|
||||
if (device == NULL)
|
||||
return B_NO_MEMORY;
|
||||
|
||||
device->owner = this;
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = &device->device_ref;
|
||||
devices[1] = NULL;
|
||||
|
||||
fDevices.AddItem(device);
|
||||
|
||||
return RegisterDevices(devices);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_RemoveDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
keyboard_device* device = _FindDevice(path);
|
||||
if (device == NULL)
|
||||
return B_ENTRY_NOT_FOUND;
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = &device->device_ref;
|
||||
devices[1] = NULL;
|
||||
|
||||
UnregisterDevices(devices);
|
||||
|
||||
fDevices.RemoveItem(device);
|
||||
|
||||
return B_OK;
|
||||
ioctl(fFD, KB_SET_LEDS, &lockIO);
|
||||
}
|
||||
|
||||
|
||||
/*static*/ int32
|
||||
KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
KeyboardDevice::_ThreadEntry(void* arg)
|
||||
{
|
||||
KeyboardDevice* device = (KeyboardDevice*)arg;
|
||||
return device->_Thread();
|
||||
}
|
||||
|
||||
|
||||
int32
|
||||
KeyboardDevice::_Thread()
|
||||
{
|
||||
CALLED();
|
||||
keyboard_device* device = (keyboard_device*)arg;
|
||||
KeyboardInputDevice* owner = device->owner;
|
||||
uint8 buffer[16];
|
||||
uint8 activeDeadKey = 0;
|
||||
Keymap* keymap = &owner->fKeymap;
|
||||
uint32 lastKeyCode = 0;
|
||||
uint32 repeatCount = 1;
|
||||
uint8 states[16];
|
||||
@ -616,13 +569,13 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
|
||||
LOG("%s\n", __PRETTY_FUNCTION__);
|
||||
|
||||
while (device->active) {
|
||||
if (ioctl(device->fd, KB_READ, &buffer) != B_OK) {
|
||||
if (device->active) {
|
||||
device->device_watcher = -1;
|
||||
device->owner->_RemoveDevice(device->path);
|
||||
while (fActive) {
|
||||
if (ioctl(fFD, KB_READ, &buffer) != B_OK) {
|
||||
if (fActive) {
|
||||
fThread = -1;
|
||||
fOwner->_RemoveDevice(fPath);
|
||||
} else {
|
||||
// In case active is already false, another thread
|
||||
// In case fActive is already false, another thread
|
||||
// waits for this thread to quit, and may already hold
|
||||
// locks that _RemoveDevice() wants to acquire. In another
|
||||
// words, the device is already being removed, so we simply
|
||||
@ -638,7 +591,7 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
|
||||
LOG("KB_READ :");
|
||||
|
||||
if (device->isAT) {
|
||||
if (fIsAT) {
|
||||
at_kbd_io* atKeyboard = (at_kbd_io*)buffer;
|
||||
if (atKeyboard->scancode > 0)
|
||||
keycode = kATKeycodeMap[atKeyboard->scancode - 1];
|
||||
@ -687,27 +640,27 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
LOG("TeamMonitor called\n");
|
||||
|
||||
// show the team monitor
|
||||
if (owner->fTeamMonitorWindow == NULL)
|
||||
owner->fTeamMonitorWindow = new(std::nothrow) TeamMonitorWindow();
|
||||
if (fOwner->fTeamMonitorWindow == NULL)
|
||||
fOwner->fTeamMonitorWindow = new(std::nothrow) TeamMonitorWindow();
|
||||
|
||||
if (owner->fTeamMonitorWindow != NULL)
|
||||
owner->fTeamMonitorWindow->Enable();
|
||||
if (fOwner->fTeamMonitorWindow != NULL)
|
||||
fOwner->fTeamMonitorWindow->Enable();
|
||||
|
||||
ctrlAltDelPressed = true;
|
||||
}
|
||||
if (ctrlAltDelPressed) {
|
||||
if (owner->fTeamMonitorWindow != NULL) {
|
||||
if (fOwner->fTeamMonitorWindow != NULL) {
|
||||
BMessage message(kMsgCtrlAltDelPressed);
|
||||
message.AddBool("key down", isKeyDown);
|
||||
owner->fTeamMonitorWindow->PostMessage(&message);
|
||||
fOwner->fTeamMonitorWindow->PostMessage(&message);
|
||||
}
|
||||
if (!isKeyDown)
|
||||
ctrlAltDelPressed = false;
|
||||
}
|
||||
|
||||
BAutolock lock(owner->fKeymapLock);
|
||||
BAutolock lock(fKeymapLock);
|
||||
|
||||
uint32 modifiers = keymap->Modifier(keycode);
|
||||
uint32 modifiers = fKeymap.Modifier(keycode);
|
||||
if (modifiers
|
||||
&& (!(modifiers & (B_CAPS_LOCK | B_NUM_LOCK | B_SCROLL_LOCK))
|
||||
|| isKeyDown)) {
|
||||
@ -717,34 +670,34 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
|
||||
msg->AddInt64("when", timestamp);
|
||||
msg->what = B_MODIFIERS_CHANGED;
|
||||
msg->AddInt32("be:old_modifiers", device->modifiers);
|
||||
msg->AddInt32("be:old_modifiers", fModifiers);
|
||||
|
||||
if ((isKeyDown && !(modifiers & (B_CAPS_LOCK | B_NUM_LOCK | B_SCROLL_LOCK)))
|
||||
|| (isKeyDown && !(device->modifiers & modifiers)))
|
||||
device->modifiers |= modifiers;
|
||||
|| (isKeyDown && !(fModifiers & modifiers)))
|
||||
fModifiers |= modifiers;
|
||||
else
|
||||
device->modifiers &= ~modifiers;
|
||||
fModifiers &= ~modifiers;
|
||||
|
||||
msg->AddInt32("modifiers", device->modifiers);
|
||||
msg->AddInt32("modifiers", fModifiers);
|
||||
msg->AddData("states", B_UINT8_TYPE, states, 16);
|
||||
|
||||
if (owner->EnqueueMessage(msg) != B_OK)
|
||||
if (fOwner->EnqueueMessage(msg) != B_OK)
|
||||
delete msg;
|
||||
|
||||
if (modifiers & (B_CAPS_LOCK | B_NUM_LOCK | B_SCROLL_LOCK))
|
||||
owner->_SetLeds(device);
|
||||
UpdateLEDs();
|
||||
}
|
||||
|
||||
uint8 newDeadKey = 0;
|
||||
if (activeDeadKey == 0)
|
||||
newDeadKey = keymap->IsDeadKey(keycode, device->modifiers);
|
||||
newDeadKey = fKeymap.IsDeadKey(keycode, fModifiers);
|
||||
|
||||
if (newDeadKey == 0) {
|
||||
char* string = NULL;
|
||||
char* rawString = NULL;
|
||||
int32 numBytes = 0, rawNumBytes = 0;
|
||||
keymap->GetChars(keycode, device->modifiers, activeDeadKey, &string, &numBytes);
|
||||
keymap->GetChars(keycode, 0, 0, &rawString, &rawNumBytes);
|
||||
fKeymap.GetChars(keycode, fModifiers, activeDeadKey, &string, &numBytes);
|
||||
fKeymap.GetChars(keycode, 0, 0, &rawString, &rawNumBytes);
|
||||
|
||||
BMessage* msg = new BMessage;
|
||||
if (msg == NULL) {
|
||||
@ -760,7 +713,7 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
|
||||
msg->AddInt64("when", timestamp);
|
||||
msg->AddInt32("key", keycode);
|
||||
msg->AddInt32("modifiers", device->modifiers);
|
||||
msg->AddInt32("modifiers", fModifiers);
|
||||
msg->AddData("states", B_UINT8_TYPE, states, 16);
|
||||
if (numBytes > 0) {
|
||||
for (int i = 0; i < numBytes; i++) {
|
||||
@ -789,28 +742,28 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
delete[] rawString;
|
||||
|
||||
if (isKeyDown && !modifiers && activeDeadKey != 0
|
||||
&& device->input_method_started) {
|
||||
&& fInputMethodStarted) {
|
||||
// a dead key was completed
|
||||
device->EnqueueInlineInputMethod(B_INPUT_METHOD_CHANGED,
|
||||
EnqueueInlineInputMethod(B_INPUT_METHOD_CHANGED,
|
||||
string, true, msg);
|
||||
} else if (owner->EnqueueMessage(msg) != B_OK)
|
||||
} else if (fOwner->EnqueueMessage(msg) != B_OK)
|
||||
delete msg;
|
||||
} else if (isKeyDown) {
|
||||
// start of a dead key
|
||||
if (device->EnqueueInlineInputMethod(B_INPUT_METHOD_STARTED) == B_OK) {
|
||||
if (EnqueueInlineInputMethod(B_INPUT_METHOD_STARTED) == B_OK) {
|
||||
char* string = NULL;
|
||||
int32 numBytes = 0;
|
||||
keymap->GetChars(keycode, device->modifiers, 0, &string, &numBytes);
|
||||
fKeymap.GetChars(keycode, fModifiers, 0, &string, &numBytes);
|
||||
|
||||
if (device->EnqueueInlineInputMethod(B_INPUT_METHOD_CHANGED, string) == B_OK)
|
||||
device->input_method_started = true;
|
||||
if (EnqueueInlineInputMethod(B_INPUT_METHOD_CHANGED, string) == B_OK)
|
||||
fInputMethodStarted = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!isKeyDown && !modifiers) {
|
||||
if (activeDeadKey != 0) {
|
||||
device->EnqueueInlineInputMethod(B_INPUT_METHOD_STOPPED);
|
||||
device->input_method_started = false;
|
||||
EnqueueInlineInputMethod(B_INPUT_METHOD_STOPPED);
|
||||
fInputMethodStarted = false;
|
||||
}
|
||||
|
||||
activeDeadKey = newDeadKey;
|
||||
@ -823,6 +776,174 @@ KeyboardInputDevice::_DeviceWatcher(void* arg)
|
||||
}
|
||||
|
||||
|
||||
// #pragma mark -
|
||||
|
||||
|
||||
KeyboardInputDevice::KeyboardInputDevice()
|
||||
:
|
||||
fDevices(2, true),
|
||||
fTeamMonitorWindow(NULL)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
StartMonitoringDevice(kKeyboardDevicesDirectory);
|
||||
_RecursiveScan(kKeyboardDevicesDirectory);
|
||||
}
|
||||
|
||||
|
||||
KeyboardInputDevice::~KeyboardInputDevice()
|
||||
{
|
||||
CALLED();
|
||||
|
||||
if (fTeamMonitorWindow) {
|
||||
fTeamMonitorWindow->PostMessage(B_QUIT_REQUESTED);
|
||||
fTeamMonitorWindow = NULL;
|
||||
}
|
||||
|
||||
StopMonitoringDevice(kKeyboardDevicesDirectory);
|
||||
fDevices.MakeEmpty();
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::SystemShuttingDown()
|
||||
{
|
||||
CALLED();
|
||||
if (fTeamMonitorWindow)
|
||||
fTeamMonitorWindow->PostMessage(SYSTEM_SHUTTING_DOWN);
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::InitCheck()
|
||||
{
|
||||
CALLED();
|
||||
return BInputServerDevice::InitCheck();
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Start(const char* name, void* cookie)
|
||||
{
|
||||
CALLED();
|
||||
KeyboardDevice* device = (KeyboardDevice*)cookie;
|
||||
|
||||
return device->Start();
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Stop(const char* name, void* cookie)
|
||||
{
|
||||
CALLED();
|
||||
KeyboardDevice* device = (KeyboardDevice*)cookie;
|
||||
|
||||
LOG("Stop(%s)\n", name);
|
||||
|
||||
device->Stop();
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::Control(const char* name, void* cookie,
|
||||
uint32 command, BMessage* message)
|
||||
{
|
||||
CALLED();
|
||||
LOG("Control(%s, code: %lu)\n", name, command);
|
||||
|
||||
if (command == B_NODE_MONITOR)
|
||||
_HandleMonitor(message);
|
||||
else if (command >= B_KEY_MAP_CHANGED
|
||||
&& command <= B_KEY_REPEAT_RATE_CHANGED) {
|
||||
KeyboardDevice* device = (KeyboardDevice*)cookie;
|
||||
device->InitFromSettings(command);
|
||||
}
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_HandleMonitor(BMessage* message)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
const char* path;
|
||||
int32 opcode;
|
||||
if (message->FindInt32("opcode", &opcode) != B_OK
|
||||
|| (opcode != B_ENTRY_CREATED && opcode != B_ENTRY_REMOVED)
|
||||
|| message->FindString("path", &path) != B_OK)
|
||||
return B_BAD_VALUE;
|
||||
|
||||
if (opcode == B_ENTRY_CREATED)
|
||||
return _AddDevice(path);
|
||||
|
||||
#if 0
|
||||
return _RemoveDevice(path);
|
||||
#else
|
||||
// Don't handle B_ENTRY_REMOVED, let the control thread take care of it.
|
||||
return B_OK;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
KeyboardDevice*
|
||||
KeyboardInputDevice::_FindDevice(const char* path) const
|
||||
{
|
||||
for (int i = fDevices.CountItems() - 1; i >= 0; i--) {
|
||||
KeyboardDevice* device = fDevices.ItemAt(i);
|
||||
if (strcmp(device->Path(), path) == 0)
|
||||
return device;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_AddDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
_RemoveDevice(path);
|
||||
|
||||
KeyboardDevice* device = new(std::nothrow) KeyboardDevice(this, path);
|
||||
if (device == NULL)
|
||||
return B_NO_MEMORY;
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
fDevices.AddItem(device);
|
||||
|
||||
return RegisterDevices(devices);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
KeyboardInputDevice::_RemoveDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
KeyboardDevice* device = _FindDevice(path);
|
||||
if (device == NULL)
|
||||
return B_ENTRY_NOT_FOUND;
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
UnregisterDevices(devices);
|
||||
|
||||
fDevices.RemoveItem(device);
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyboardInputDevice::_RecursiveScan(const char* directory)
|
||||
{
|
||||
@ -840,103 +961,10 @@ KeyboardInputDevice::_RecursiveScan(const char* directory)
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyboardInputDevice::_SetLeds(keyboard_device* device)
|
||||
{
|
||||
if (device->fd < 0)
|
||||
return;
|
||||
|
||||
uint32 locks = device->modifiers;
|
||||
char lock_io[3];
|
||||
memset(lock_io, 0, sizeof(lock_io));
|
||||
if (locks & B_NUM_LOCK)
|
||||
lock_io[0] = 1;
|
||||
if (locks & B_CAPS_LOCK)
|
||||
lock_io[1] = 1;
|
||||
if (locks & B_SCROLL_LOCK)
|
||||
lock_io[2] = 1;
|
||||
|
||||
ioctl(device->fd, KB_SET_LEDS, &lock_io);
|
||||
}
|
||||
|
||||
|
||||
// #pragma mark -
|
||||
|
||||
|
||||
keyboard_device::keyboard_device(const char* path)
|
||||
: BHandler("keyboard device"),
|
||||
owner(NULL),
|
||||
fd(-1),
|
||||
device_watcher(-1),
|
||||
active(false),
|
||||
input_method_started(false)
|
||||
{
|
||||
strcpy(this->path, path);
|
||||
device_ref.name = get_short_name(path);
|
||||
device_ref.type = B_KEYBOARD_DEVICE;
|
||||
device_ref.cookie = this;
|
||||
|
||||
isAT = strstr(path, "keyboard/at") != NULL;
|
||||
|
||||
if (be_app->Lock()) {
|
||||
be_app->AddHandler(this);
|
||||
be_app->Unlock();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
keyboard_device::~keyboard_device()
|
||||
{
|
||||
free(device_ref.name);
|
||||
|
||||
if (be_app->Lock()) {
|
||||
be_app->RemoveHandler(this);
|
||||
be_app->Unlock();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
keyboard_device::EnqueueInlineInputMethod(int32 opcode,
|
||||
const char* string, bool confirmed, BMessage* keyDown)
|
||||
{
|
||||
BMessage* message = new BMessage(B_INPUT_METHOD_EVENT);
|
||||
if (message == NULL)
|
||||
return B_NO_MEMORY;
|
||||
|
||||
message->AddInt32("be:opcode", opcode);
|
||||
message->AddBool("be:inline_only", true);
|
||||
|
||||
if (string != NULL)
|
||||
message->AddString("be:string", string);
|
||||
if (confirmed)
|
||||
message->AddBool("be:confirmed", true);
|
||||
if (keyDown)
|
||||
message->AddMessage("be:translated", keyDown);
|
||||
if (opcode == B_INPUT_METHOD_STARTED)
|
||||
message->AddMessenger("be:reply_to", this);
|
||||
|
||||
status_t status = owner->EnqueueMessage(message);
|
||||
if (status != B_OK)
|
||||
delete message;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
keyboard_device::MessageReceived(BMessage* message)
|
||||
{
|
||||
if (message->what != B_INPUT_METHOD_EVENT) {
|
||||
BHandler::MessageReceived(message);
|
||||
return;
|
||||
}
|
||||
|
||||
int32 opcode;
|
||||
if (message->FindInt32("be:opcode", &opcode) != B_OK)
|
||||
return;
|
||||
|
||||
if (opcode == B_INPUT_METHOD_STOPPED)
|
||||
input_method_started = false;
|
||||
}
|
||||
|
||||
|
||||
@ -21,65 +21,77 @@
|
||||
|
||||
class KeyboardInputDevice;
|
||||
|
||||
struct keyboard_device : public BHandler {
|
||||
keyboard_device(const char* path);
|
||||
virtual ~keyboard_device();
|
||||
class KeyboardDevice : public BHandler {
|
||||
public:
|
||||
KeyboardDevice(KeyboardInputDevice* owner,
|
||||
const char* path);
|
||||
virtual ~KeyboardDevice();
|
||||
|
||||
virtual void MessageReceived(BMessage* message);
|
||||
status_t EnqueueInlineInputMethod(int32 opcode,
|
||||
const char* string = NULL,
|
||||
bool confirmed = false,
|
||||
BMessage* keyDown = NULL);
|
||||
virtual void MessageReceived(BMessage* message);
|
||||
status_t EnqueueInlineInputMethod(int32 opcode,
|
||||
const char* string = NULL,
|
||||
bool confirmed = false,
|
||||
BMessage* keyDown = NULL);
|
||||
|
||||
KeyboardInputDevice* owner;
|
||||
input_device_ref device_ref;
|
||||
char path[B_PATH_NAME_LENGTH];
|
||||
int fd;
|
||||
thread_id device_watcher;
|
||||
kb_settings settings;
|
||||
volatile bool active;
|
||||
bool isAT;
|
||||
volatile bool input_method_started;
|
||||
uint32 modifiers;
|
||||
status_t Start();
|
||||
void Stop();
|
||||
|
||||
status_t InitFromSettings(uint32 opcode = 0);
|
||||
void UpdateLEDs();
|
||||
|
||||
const char* Path() const { return fPath; }
|
||||
input_device_ref* DeviceRef() { return &fDeviceRef; }
|
||||
|
||||
private:
|
||||
static int32 _ThreadEntry(void* arg);
|
||||
int32 _Thread();
|
||||
|
||||
private:
|
||||
KeyboardInputDevice* fOwner;
|
||||
input_device_ref fDeviceRef;
|
||||
char fPath[B_PATH_NAME_LENGTH];
|
||||
int fFD;
|
||||
thread_id fThread;
|
||||
kb_settings fSettings;
|
||||
volatile bool fActive;
|
||||
bool fIsAT;
|
||||
volatile bool fInputMethodStarted;
|
||||
uint32 fModifiers;
|
||||
|
||||
Keymap fKeymap;
|
||||
BLocker fKeymapLock;
|
||||
};
|
||||
|
||||
|
||||
class KeyboardInputDevice : public BInputServerDevice {
|
||||
public:
|
||||
KeyboardInputDevice();
|
||||
~KeyboardInputDevice();
|
||||
KeyboardInputDevice();
|
||||
virtual ~KeyboardInputDevice();
|
||||
|
||||
virtual status_t InitCheck();
|
||||
virtual status_t InitCheck();
|
||||
|
||||
virtual status_t Start(const char* name, void* cookie);
|
||||
virtual status_t Stop(const char* name, void* cookie);
|
||||
virtual status_t Start(const char* name, void* cookie);
|
||||
virtual status_t Stop(const char* name, void* cookie);
|
||||
|
||||
virtual status_t Control(const char* name, void* cookie,
|
||||
uint32 command, BMessage* message);
|
||||
virtual status_t Control(const char* name, void* cookie,
|
||||
uint32 command, BMessage* message);
|
||||
|
||||
virtual status_t SystemShuttingDown();
|
||||
virtual status_t SystemShuttingDown();
|
||||
|
||||
private:
|
||||
friend struct keyboard_device;
|
||||
friend struct KeyboardDevice;
|
||||
// TODO: needed by the control thread to remove a dead device
|
||||
// find a better way...
|
||||
|
||||
status_t _HandleMonitor(BMessage* message);
|
||||
status_t _InitFromSettings(void* cookie, uint32 opcode = 0);
|
||||
void _RecursiveScan(const char* directory);
|
||||
status_t _HandleMonitor(BMessage* message);
|
||||
void _RecursiveScan(const char* directory);
|
||||
|
||||
keyboard_device* _FindDevice(const char* path) const;
|
||||
status_t _AddDevice(const char* path);
|
||||
status_t _RemoveDevice(const char* path);
|
||||
KeyboardDevice* _FindDevice(const char* path) const;
|
||||
status_t _AddDevice(const char* path);
|
||||
status_t _RemoveDevice(const char* path);
|
||||
|
||||
void _SetLeds(keyboard_device* device);
|
||||
|
||||
static int32 _DeviceWatcher(void* arg);
|
||||
|
||||
BObjectList<keyboard_device> fDevices;
|
||||
Keymap fKeymap;
|
||||
TeamMonitorWindow* fTeamMonitorWindow;
|
||||
BLocker fKeymapLock;
|
||||
BObjectList<KeyboardDevice> fDevices;
|
||||
TeamMonitorWindow* fTeamMonitorWindow;
|
||||
};
|
||||
|
||||
extern "C" BInputServerDevice* instantiate_input_device();
|
||||
|
||||
@ -29,20 +29,68 @@
|
||||
#include "kb_mouse_driver.h"
|
||||
|
||||
|
||||
#undef TRACE
|
||||
#undef CALLED
|
||||
//#define TRACE_MOUSE_DEVICE
|
||||
#ifdef TRACE_MOUSE_DEVICE
|
||||
|
||||
class FunctionTracer {
|
||||
public:
|
||||
FunctionTracer(const void* pointer, const char* className,
|
||||
const char* functionName,
|
||||
int32& depth)
|
||||
: fFunctionName(),
|
||||
fPrepend(),
|
||||
fFunctionDepth(depth),
|
||||
fPointer(pointer)
|
||||
{
|
||||
fFunctionDepth++;
|
||||
fPrepend.Append(' ', fFunctionDepth * 2);
|
||||
fFunctionName << className << "::" << functionName << "()";
|
||||
|
||||
debug_printf("%p -> %s%s {\n", fPointer, fPrepend.String(),
|
||||
fFunctionName.String());
|
||||
}
|
||||
|
||||
~FunctionTracer()
|
||||
{
|
||||
debug_printf("%p -> %s}\n", fPointer, fPrepend.String());
|
||||
fFunctionDepth--;
|
||||
}
|
||||
|
||||
private:
|
||||
BString fFunctionName;
|
||||
BString fPrepend;
|
||||
int32& fFunctionDepth;
|
||||
const void* fPointer;
|
||||
};
|
||||
|
||||
|
||||
static int32 sFunctionDepth = -1;
|
||||
# define MD_CALLED(x...) FunctionTracer _ft(this, "MouseDevice", \
|
||||
__FUNCTION__, sFunctionDepth)
|
||||
# define MID_CALLED(x...) FunctionTracer _ft(this, "MouseInputDevice", \
|
||||
__FUNCTION__, sFunctionDepth)
|
||||
# define TRACE(x...) { BString _to; \
|
||||
_to.Append(' ', (sFunctionDepth + 1) * 2); \
|
||||
debug_printf("%p -> %s", this, _to.String()); \
|
||||
debug_printf(x); }
|
||||
# define LOG(text...) debug_printf(text)
|
||||
# define LOG_EVENT(text...) do {} while (0)
|
||||
# define LOG_ERR(text...) LOG(text)
|
||||
#else
|
||||
# define LOG(text...) do {} while (0)
|
||||
# define TRACE(x...) do {} while (0)
|
||||
# define MD_CALLED(x...) TRACE(x)
|
||||
# define MID_CALLED(x...) TRACE(x)
|
||||
# define LOG(text...) TRACE(x)
|
||||
# define LOG_ERR(text...) debug_printf(text)
|
||||
# define LOG_EVENT(text...) TRACE(x)
|
||||
#endif
|
||||
|
||||
|
||||
//#define LOG_DEVICES(text...) debug_printf(text)
|
||||
#define LOG_DEVICES(text...) LOG(text)
|
||||
|
||||
#define CALLED() LOG("%s\n", __PRETTY_FUNCTION__)
|
||||
|
||||
|
||||
|
||||
const static uint32 kMouseThreadPriority = B_FIRST_REAL_TIME_PRIORITY + 4;
|
||||
@ -103,9 +151,12 @@ MouseDevice::MouseDevice(MouseInputDevice& target, const char* driverPath)
|
||||
fTarget(target),
|
||||
fPath(driverPath),
|
||||
fDevice(-1),
|
||||
fDeviceRemapsButtons(false),
|
||||
fThread(-1),
|
||||
fActive(false)
|
||||
{
|
||||
MD_CALLED();
|
||||
|
||||
fDeviceRef.name = _BuildShortName();
|
||||
fDeviceRef.type = B_POINTING_DEVICE;
|
||||
fDeviceRef.cookie = this;
|
||||
@ -115,13 +166,17 @@ MouseDevice::MouseDevice(MouseInputDevice& target, const char* driverPath)
|
||||
fSettings.map.button[1] = B_SECONDARY_MOUSE_BUTTON;
|
||||
fSettings.map.button[2] = B_TERTIARY_MOUSE_BUTTON;
|
||||
#endif
|
||||
|
||||
fDeviceRemapsButtons = false;
|
||||
};
|
||||
|
||||
|
||||
MouseDevice::~MouseDevice()
|
||||
{
|
||||
MD_CALLED();
|
||||
TRACE("delete\n");
|
||||
|
||||
if (fTarget._HasDevice(this))
|
||||
TRACE("still in the list!\n");
|
||||
|
||||
if (fActive)
|
||||
Stop();
|
||||
|
||||
@ -132,6 +187,8 @@ MouseDevice::~MouseDevice()
|
||||
status_t
|
||||
MouseDevice::Start()
|
||||
{
|
||||
MD_CALLED();
|
||||
|
||||
fDevice = open(fPath.String(), O_RDWR);
|
||||
if (fDevice < 0)
|
||||
return errno;
|
||||
@ -166,12 +223,14 @@ MouseDevice::Start()
|
||||
void
|
||||
MouseDevice::Stop()
|
||||
{
|
||||
close(fDevice);
|
||||
fDevice = -1;
|
||||
MD_CALLED();
|
||||
|
||||
fActive = false;
|
||||
// this will stop the thread as soon as it reads the next packet
|
||||
|
||||
close(fDevice);
|
||||
fDevice = -1;
|
||||
|
||||
if (fThread >= B_OK) {
|
||||
// unblock the thread, which might wait on a semaphore.
|
||||
suspend_thread(fThread);
|
||||
@ -186,7 +245,7 @@ MouseDevice::Stop()
|
||||
status_t
|
||||
MouseDevice::UpdateSettings()
|
||||
{
|
||||
CALLED();
|
||||
MD_CALLED();
|
||||
|
||||
// retrieve current values
|
||||
|
||||
@ -254,10 +313,10 @@ MouseDevice::_Run()
|
||||
int32 deltaX, deltaY;
|
||||
_ComputeAcceleration(movements, deltaX, deltaY);
|
||||
|
||||
LOG("%s: buttons: 0x%lx, x: %ld, y: %ld, clicks:%ld, wheel_x:%ld, wheel_y:%ld\n",
|
||||
LOG_EVENT("%s: buttons: 0x%lx, x: %ld, y: %ld, clicks:%ld, wheel_x:%ld, wheel_y:%ld\n",
|
||||
fDeviceRef.name, movements.buttons, movements.xdelta, movements.ydelta,
|
||||
movements.clicks, movements.wheel_xdelta, movements.wheel_ydelta);
|
||||
LOG("%s: x: %ld, y: %ld\n", fDeviceRef.name, deltaX, deltaY);
|
||||
LOG_EVENT("%s: x: %ld, y: %ld\n", fDeviceRef.name, deltaX, deltaY);
|
||||
|
||||
// Send single messages for each event
|
||||
|
||||
@ -269,9 +328,9 @@ MouseDevice::_Run()
|
||||
if (message != NULL) {
|
||||
if (pressedButton) {
|
||||
message->AddInt32("clicks", movements.clicks);
|
||||
LOG("B_MOUSE_DOWN\n");
|
||||
LOG_EVENT("B_MOUSE_DOWN\n");
|
||||
} else
|
||||
LOG("B_MOUSE_UP\n");
|
||||
LOG_EVENT("B_MOUSE_UP\n");
|
||||
|
||||
fTarget.EnqueueMessage(message);
|
||||
lastButtons = movements.buttons;
|
||||
@ -416,7 +475,7 @@ MouseInputDevice::MouseInputDevice()
|
||||
:
|
||||
fDevices(2, true)
|
||||
{
|
||||
CALLED();
|
||||
MID_CALLED();
|
||||
|
||||
StartMonitoringDevice(kMouseDevicesDirectory);
|
||||
_RecursiveScan(kMouseDevicesDirectory);
|
||||
@ -425,15 +484,18 @@ MouseInputDevice::MouseInputDevice()
|
||||
|
||||
MouseInputDevice::~MouseInputDevice()
|
||||
{
|
||||
CALLED();
|
||||
MID_CALLED();
|
||||
|
||||
StopMonitoringDevice(kMouseDevicesDirectory);
|
||||
fDevices.MakeEmpty();
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MouseInputDevice::InitCheck()
|
||||
{
|
||||
CALLED();
|
||||
MID_CALLED();
|
||||
|
||||
return BInputServerDevice::InitCheck();
|
||||
}
|
||||
|
||||
@ -441,7 +503,8 @@ MouseInputDevice::InitCheck()
|
||||
status_t
|
||||
MouseInputDevice::Start(const char* name, void* cookie)
|
||||
{
|
||||
LOG("%s(%s)\n", __PRETTY_FUNCTION__, name);
|
||||
MID_CALLED();
|
||||
|
||||
MouseDevice* device = (MouseDevice*)cookie;
|
||||
|
||||
return device->Start();
|
||||
@ -451,10 +514,11 @@ MouseInputDevice::Start(const char* name, void* cookie)
|
||||
status_t
|
||||
MouseInputDevice::Stop(const char* name, void* cookie)
|
||||
{
|
||||
LOG("%s(%s)\n", __PRETTY_FUNCTION__, name);
|
||||
MouseDevice* device = (MouseDevice*)cookie;
|
||||
TRACE("%s(%s)\n", __PRETTY_FUNCTION__, name);
|
||||
|
||||
MouseDevice* device = (MouseDevice*)cookie;
|
||||
device->Stop();
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
@ -463,7 +527,8 @@ status_t
|
||||
MouseInputDevice::Control(const char* name, void* cookie,
|
||||
uint32 command, BMessage* message)
|
||||
{
|
||||
LOG("%s(%s, code: %lu)\n", __PRETTY_FUNCTION__, name, command);
|
||||
TRACE("%s(%s, code: %lu)\n", __PRETTY_FUNCTION__, name, command);
|
||||
|
||||
MouseDevice* device = (MouseDevice*)cookie;
|
||||
|
||||
if (command == B_NODE_MONITOR)
|
||||
@ -480,7 +545,7 @@ MouseInputDevice::Control(const char* name, void* cookie,
|
||||
status_t
|
||||
MouseInputDevice::_HandleMonitor(BMessage* message)
|
||||
{
|
||||
CALLED();
|
||||
MID_CALLED();
|
||||
|
||||
const char* path;
|
||||
int32 opcode;
|
||||
@ -501,78 +566,10 @@ MouseInputDevice::_HandleMonitor(BMessage* message)
|
||||
}
|
||||
|
||||
|
||||
MouseDevice*
|
||||
MouseInputDevice::_FindDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
for (int32 i = fDevices.CountItems() - 1; i >= 0; i--) {
|
||||
MouseDevice* device = fDevices.ItemAt(i);
|
||||
if (strcmp(device->Path(), path) == 0)
|
||||
return device;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MouseInputDevice::_AddDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
_RemoveDevice(path);
|
||||
|
||||
MouseDevice* device = new(std::nothrow) MouseDevice(*this, path);
|
||||
if (!device) {
|
||||
LOG("MouseInputDevice::_AddDevice() - No memory\n");
|
||||
return B_NO_MEMORY;
|
||||
}
|
||||
|
||||
if (!fDevices.AddItem(device)) {
|
||||
delete device;
|
||||
return B_NO_MEMORY;
|
||||
}
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
LOG_DEVICES("MouseInputDevice::_AddDevice(%s), name: %s\n", path,
|
||||
devices[0]->name);
|
||||
|
||||
return RegisterDevices(devices);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MouseInputDevice::_RemoveDevice(const char* path)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
MouseDevice* device = _FindDevice(path);
|
||||
if (device == NULL)
|
||||
return B_ENTRY_NOT_FOUND;
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
LOG_DEVICES("MouseInputDevice::_RemoveDevice(%s), name: %s\n", path,
|
||||
devices[0]->name);
|
||||
|
||||
UnregisterDevices(devices);
|
||||
|
||||
fDevices.RemoveItem(device);
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
MouseInputDevice::_RecursiveScan(const char* directory)
|
||||
{
|
||||
CALLED();
|
||||
MID_CALLED();
|
||||
|
||||
BEntry entry;
|
||||
BDirectory dir(directory);
|
||||
@ -592,3 +589,84 @@ MouseInputDevice::_RecursiveScan(const char* directory)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
MouseDevice*
|
||||
MouseInputDevice::_FindDevice(const char* path)
|
||||
{
|
||||
MID_CALLED();
|
||||
|
||||
for (int32 i = fDevices.CountItems() - 1; i >= 0; i--) {
|
||||
MouseDevice* device = fDevices.ItemAt(i);
|
||||
if (strcmp(device->Path(), path) == 0)
|
||||
return device;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MouseInputDevice::_AddDevice(const char* path)
|
||||
{
|
||||
MID_CALLED();
|
||||
|
||||
_RemoveDevice(path);
|
||||
|
||||
MouseDevice* device = new(std::nothrow) MouseDevice(*this, path);
|
||||
if (!device) {
|
||||
TRACE("No memory\n");
|
||||
return B_NO_MEMORY;
|
||||
}
|
||||
|
||||
if (!fDevices.AddItem(device)) {
|
||||
TRACE("No memory in list\n");
|
||||
delete device;
|
||||
return B_NO_MEMORY;
|
||||
}
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
TRACE("adding path: %s, name: %s\n", path, devices[0]->name);
|
||||
|
||||
return RegisterDevices(devices);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MouseInputDevice::_RemoveDevice(const char* path)
|
||||
{
|
||||
MID_CALLED();
|
||||
|
||||
MouseDevice* device = _FindDevice(path);
|
||||
if (device == NULL) {
|
||||
TRACE("%s not found\n", path);
|
||||
return B_ENTRY_NOT_FOUND;
|
||||
}
|
||||
|
||||
input_device_ref* devices[2];
|
||||
devices[0] = device->DeviceRef();
|
||||
devices[1] = NULL;
|
||||
|
||||
TRACE("removing path: %s, name: %s\n", path, devices[0]->name);
|
||||
|
||||
UnregisterDevices(devices);
|
||||
|
||||
fDevices.RemoveItem(device);
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
MouseInputDevice::_HasDevice(const MouseDevice* device) const
|
||||
{
|
||||
for (int32 i = fDevices.CountItems() - 1; i >= 0; i--) {
|
||||
if (device == fDevices.ItemAt(i))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -42,6 +42,9 @@ private:
|
||||
status_t _AddDevice(const char* path);
|
||||
status_t _RemoveDevice(const char* path);
|
||||
|
||||
bool _HasDevice(const MouseDevice* device) const;
|
||||
|
||||
private:
|
||||
BObjectList<MouseDevice> fDevices;
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user