static void
gdk_device_manager_win32_constructed (GObject *object)
{
GdkDeviceManagerWin32 *device_manager;
GdkSeat *seat;
device_manager = GDK_DEVICE_MANAGER_WIN32 (object);
device_manager->core_pointer =
create_pointer (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_VIRTUAL,
"Virtual Core Pointer",
GDK_DEVICE_TYPE_MASTER);
device_manager->system_pointer =
create_pointer (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_WIN32,
"System Aggregated Pointer",
GDK_DEVICE_TYPE_SLAVE);
_gdk_device_virtual_set_active (device_manager->core_pointer,
device_manager->system_pointer);
_gdk_device_set_associated_device (device_manager->system_pointer, device_manager->core_pointer);
_gdk_device_add_slave (device_manager->core_pointer, device_manager->system_pointer);
device_manager->core_keyboard =
create_keyboard (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_VIRTUAL,
"Virtual Core Keyboard",
GDK_DEVICE_TYPE_MASTER);
device_manager->system_keyboard =
create_keyboard (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_WIN32,
"System Aggregated Keyboard",
GDK_DEVICE_TYPE_SLAVE);
_gdk_device_virtual_set_active (device_manager->core_keyboard,
device_manager->system_keyboard);
_gdk_device_set_associated_device (device_manager->system_keyboard, device_manager->core_keyboard);
_gdk_device_add_slave (device_manager->core_keyboard, device_manager->system_keyboard);
_gdk_device_set_associated_device (device_manager->core_pointer, device_manager->core_keyboard);
_gdk_device_set_associated_device (device_manager->core_keyboard, device_manager->core_pointer);
seat = gdk_seat_default_new_for_master_pair (device_manager->core_pointer,
device_manager->core_keyboard);
gdk_display_add_seat (gdk_device_manager_get_display (GDK_DEVICE_MANAGER (object)), seat);
gdk_seat_default_add_slave (GDK_SEAT_DEFAULT (seat), device_manager->system_pointer);
gdk_seat_default_add_slave (GDK_SEAT_DEFAULT (seat), device_manager->system_keyboard);
g_object_unref (seat);
wintab_init_check (device_manager);
}
static void
test_copy(int fd)
{
void *src, *dst;
/* copy from a fresh src to fresh dst to force pagefault on both */
src = create_pointer(fd);
dst = create_pointer(fd);
memcpy(dst, src, OBJECT_SIZE);
memcpy(src, dst, OBJECT_SIZE);
munmap(dst, OBJECT_SIZE);
munmap(src, OBJECT_SIZE);
}
static void
gdk_device_manager_win32_constructed (GObject *object)
{
GdkDeviceManagerWin32 *device_manager;
device_manager = GDK_DEVICE_MANAGER_WIN32 (object);
device_manager->core_pointer =
create_pointer (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_VIRTUAL,
"Virtual Core Pointer",
GDK_DEVICE_TYPE_MASTER);
device_manager->system_pointer =
create_pointer (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_WIN32,
"System Aggregated Pointer",
GDK_DEVICE_TYPE_SLAVE);
_gdk_device_virtual_set_active (device_manager->core_pointer,
device_manager->system_pointer);
_gdk_device_set_associated_device (device_manager->system_pointer, device_manager->core_pointer);
_gdk_device_add_slave (device_manager->core_pointer, device_manager->system_pointer);
device_manager->core_keyboard =
create_keyboard (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_VIRTUAL,
"Virtual Core Keyboard",
GDK_DEVICE_TYPE_MASTER);
device_manager->system_keyboard =
create_keyboard (GDK_DEVICE_MANAGER (device_manager),
GDK_TYPE_DEVICE_WIN32,
"System Aggregated Keyboard",
GDK_DEVICE_TYPE_SLAVE);
_gdk_device_virtual_set_active (device_manager->core_keyboard,
device_manager->system_keyboard);
_gdk_device_set_associated_device (device_manager->system_keyboard, device_manager->core_keyboard);
_gdk_device_add_slave (device_manager->core_keyboard, device_manager->system_keyboard);
_gdk_device_set_associated_device (device_manager->core_pointer, device_manager->core_keyboard);
_gdk_device_set_associated_device (device_manager->core_keyboard, device_manager->core_pointer);
}
static void
test_read(int fd)
{
void *dst;
uint32_t src;
/* copy from a fresh src to fresh dst to force pagefault on both */
dst = create_pointer(fd);
src = gem_create(fd, OBJECT_SIZE);
gem_read(fd, src, 0, dst, OBJECT_SIZE);
gem_close(fd, src);
munmap(dst, OBJECT_SIZE);
}
static void
test_write(int fd)
{
void *src;
uint32_t dst;
/* copy from a fresh src to fresh dst to force pagefault on both */
src = create_pointer(fd);
dst = gem_create(fd, OBJECT_SIZE);
gem_write(fd, dst, 0, src, OBJECT_SIZE);
gem_close(fd, dst);
munmap(src, OBJECT_SIZE);
}
static void
test_write_gtt(int fd)
{
uint32_t dst;
char *dst_gtt;
void *src;
dst = gem_create(fd, OBJECT_SIZE);
/* prefault object into gtt */
dst_gtt = mmap_bo(fd, dst);
set_domain_gtt(fd, dst);
memset(dst_gtt, 0, OBJECT_SIZE);
munmap(dst_gtt, OBJECT_SIZE);
src = create_pointer(fd);
gem_write(fd, dst, 0, src, OBJECT_SIZE);
gem_close(fd, dst);
munmap(src, OBJECT_SIZE);
}
static void
test_fault_concurrent(int fd)
{
uint32_t *ptr[32];
struct thread_fault_concurrent thread[64];
int n;
for (n = 0; n < 32; n++) {
ptr[n] = create_pointer(fd);
}
for (n = 0; n < 64; n++) {
thread[n].ptr = ptr;
thread[n].id = n;
pthread_create(&thread[n].thread, NULL, thread_fault_concurrent, &thread[n]);
}
for (n = 0; n < 64; n++)
pthread_join(thread[n].thread, NULL);
for (n = 0; n < 32; n++) {
munmap(ptr[n], OBJECT_SIZE);
}
}
ControllerPtr
Manager::create_controller(const Pathname& filename)
{
ControllerPtr controller(new Controller(desc));
ReaderObject reader_object = Reader::parse(filename);
if (reader_object.get_name() != "pingus-controller")
{
raise_exception(std::runtime_error,
"Controller: invalid config file '" << filename.str() << "'");
}
else
{
ReaderMapping reader = reader_object.get_mapping();
ReaderMapping controls_mapping;
if (!reader.read_mapping("controls", controls_mapping))
{
log_warn("%1%: 'controls' section missing", filename);
}
else
{
for (const auto& key : controls_mapping.get_keys())
{
ReaderCollection collection;
if (!controls_mapping.read_collection(key.c_str(), collection))
{
log_error("%1%: mapping must contain object at %2%", filename, key);
}
else
{
if (StringUtil::has_suffix(key, "pointer"))
{
int id = desc.get_definition(key).id;
ControllerPointer* ctrl_pointer = controller->get_pointer(id);
for(const auto& object : collection.get_objects())
{
auto pointer = create_pointer(object, ctrl_pointer);
if (pointer)
{
ctrl_pointer->add_pointer(std::move(pointer));
}
else
{
log_error("Manager: pointer: Couldn't create pointer %1%", object.get_name());
}
}
}
else if (StringUtil::has_suffix(key, "scroller"))
{
int id = desc.get_definition(key).id;
ControllerScroller* ctrl_scroller = controller->get_scroller(id);
for(const auto& object : collection.get_objects())
{
auto scroller = create_scroller(object, ctrl_scroller);
if (scroller)
{
ctrl_scroller->add_scroller(std::move(scroller));
}
else
{
log_error("Manager: scroller: Couldn't create scroller %1%", object.get_name());
}
}
}
else if (StringUtil::has_suffix(key, "button"))
{
int id = desc.get_definition(key).id;
ControllerButton* ctrl_button = controller->get_button(id);
for(const auto& object : collection.get_objects())
{
auto button = create_button(object, ctrl_button);
if (button)
{
ctrl_button->add_button(std::move(button));
}
else
{
log_error("Manager: button: Couldn't create button %1%", object.get_name());
}
}
}
else if (StringUtil::has_suffix(key, "axis"))
{
int id = desc.get_definition(key).id;
ControllerAxis* ctrl_axis = controller->get_axis(id);
for(const auto& object : collection.get_objects())
{
auto axis = create_axis(object, ctrl_axis);
if (axis)
{
ctrl_axis->add_axis(std::move(axis));
}
else
{
log_error("Manager: axis: Couldn't create axis %1%", object.get_name());
}
}
}
else if (StringUtil::has_suffix(key, "keyboard"))
{
int id = desc.get_definition(key).id;
ControllerKeyboard* ctrl_keyboard = controller->get_keyboard(id);
for(const auto& object : collection.get_objects())
{
std::unique_ptr<Keyboard> keyboard = create_keyboard(object, ctrl_keyboard);
if (keyboard)
{
ctrl_keyboard->add_keyboard(std::move(keyboard));
}
else
{
log_error("Manager: keyboard: Couldn't create keyboard %1%", object.get_name());
}
}
}
else
{
raise_exception(std::runtime_error, "Manager: Unkown Element in Controller Config: "
<< key);
}
}
}
}
}
controllers.push_back(controller);
return controller;
}
Controller*
Manager::create_controller(const Pathname& filename)
{
std::unique_ptr<Controller> controller(new Controller(desc));
FileReader reader = FileReader::parse(filename);
if (reader.get_name() != "pingus-controller")
{
throw std::runtime_error("Controller: invalid config file '" + filename.str() + "'");
}
else
{
const std::vector<FileReader>& sections = reader.get_sections();
for (std::vector<FileReader>::const_iterator i = sections.begin();
i != sections.end(); ++i)
{
if (StringUtil::has_suffix(i->get_name(), "pointer"))
{
const std::vector<FileReader>& pointers = i->get_sections();
for(std::vector<FileReader>::const_iterator j = pointers.begin(); j != pointers.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerPointer* ctrl_pointer = controller->get_pointer(id);
Pointer* pointer = create_pointer(*j, ctrl_pointer);
if (pointer)
ctrl_pointer->add_pointer(pointer);
else
std::cout << "Manager: pointer: Couldn't create pointer " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "scroller"))
{
const std::vector<FileReader>& scrollers = i->get_sections();
for(std::vector<FileReader>::const_iterator j = scrollers.begin(); j != scrollers.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerScroller* ctrl_scroller = controller->get_scroller(id);
Scroller* scroller = create_scroller(*j, ctrl_scroller);
if (scroller)
ctrl_scroller->add_scroller(scroller);
else
std::cout << "Manager: scroller: Couldn't create scroller " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "button"))
{
const std::vector<FileReader>& buttons = i->get_sections();
for(std::vector<FileReader>::const_iterator j = buttons.begin(); j != buttons.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerButton* ctrl_button = controller->get_button(id);
Button* button = create_button(*j, ctrl_button);
if (button)
ctrl_button->add_button(button);
else
std::cout << "Manager: button: Couldn't create button " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "axis"))
{
const std::vector<FileReader>& axes = i->get_sections();
for(std::vector<FileReader>::const_iterator j = axes.begin(); j != axes.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerAxis* ctrl_axis = controller->get_axis(id);
Axis* axis = create_axis(*j, ctrl_axis);
if (axis)
ctrl_axis->add_axis(axis);
else
std::cout << "Manager: axis: Couldn't create axis " << j->get_name() << std::endl;
}
}
else if (StringUtil::has_suffix(i->get_name(), "keyboard"))
{
const std::vector<FileReader>& keyboards = i->get_sections();
for(std::vector<FileReader>::const_iterator j = keyboards.begin(); j != keyboards.end(); ++j)
{
int id = desc.get_definition(i->get_name()).id;
ControllerKeyboard* ctrl_keyboard = controller->get_keyboard(id);
Keyboard* keyboard = create_keyboard(*j, ctrl_keyboard);
if (keyboard)
ctrl_keyboard->add_keyboard(keyboard);
else
std::cout << "Manager: keyboard: Couldn't create keyboard " << j->get_name() << std::endl;
}
}
else
{
throw std::runtime_error(std::string("Manager: Unkown Element in Controller Config: ")
+ i->get_name());
}
}
}
Controller* ctrl = controller.release();
controllers.push_back(ctrl);
return ctrl;
}
