void release_grab (GromitData *data,
GdkDevice *dev)
{
if(!dev) /* this means release all grabs */
{
GHashTableIter it;
gpointer value;
GromitDeviceData* devdata;
g_hash_table_iter_init (&it, data->devdatatable);
while (g_hash_table_iter_next (&it, NULL, &value))
{
devdata = value;
if(devdata->is_grabbed)
{
gdk_error_trap_push();
gdk_device_ungrab(devdata->device, GDK_CURRENT_TIME);
XSync(GDK_DISPLAY_XDISPLAY(data->display), False);
if(gdk_error_trap_pop())
g_printerr("WARNING: Ungrabbing device '%s' failed.\n", gdk_device_get_name(devdata->device));
devdata->is_grabbed = 0;
/* workaround buggy GTK3 ? */
devdata->motion_time = 0;
}
}
data->all_grabbed = 0;
if(data->debug)
g_printerr ("DEBUG: Ungrabbed all Devices.\n");
return;
}
/* get the data for this device */
GromitDeviceData *devdata = g_hash_table_lookup(data->devdatatable, dev);
if (devdata->is_grabbed)
{
gdk_device_ungrab(devdata->device, GDK_CURRENT_TIME);
devdata->is_grabbed = 0;
/* workaround buggy GTK3 ? */
devdata->motion_time = 0;
if(data->debug)
g_printerr ("DEBUG: Ungrabbed Device '%s'.\n", gdk_device_get_name(devdata->device));
}
if (!data->painted)
hide_window (data);
}
static void
device_added_cb (GdkDeviceManager *manager,
GdkDevice *device,
gpointer user_data)
{
GnomeIdleMonitor *monitor;
guint watch_id;
int device_id;
GError *error = NULL;
device_id = gdk_x11_device_get_id (device);
monitor = gnome_idle_monitor_new_for_device (device, &error);
if (!monitor) {
g_warning ("Per-device idletime monitor not available: %s", error->message);
g_error_free (error);
return;
}
watch_id = gnome_idle_monitor_add_idle_watch (monitor,
IDLE_TIME,
idle_watch_func,
NULL,
NULL);
g_message ("Added idle watch ID %d for device %s (%d)",
watch_id,
gdk_device_get_name (device),
device_id);
ensure_active_watch (monitor);
g_hash_table_insert (monitors,
GINT_TO_POINTER (device_id),
monitor);
}
gboolean on_buttonpress (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
gdouble pressure = 0.5;
/* get the data for this device */
GdkDevice *master = ev->device;
GromitDeviceData *masterdata =
g_hash_table_lookup(data->devdatatable, master);
GdkDevice *slave =
gdk_event_get_source_device ((GdkEvent *) ev);
GromitDeviceData *slavedata =
g_hash_table_lookup(data->devdatatable, slave);
if(data->debug)
g_printerr("DEBUG: Device '%s': Button %i Down at (x,y)=(%.2f : %.2f)\n",
gdk_device_get_name(slave), ev->button, ev->x, ev->y);
if (!masterdata->is_grabbed)
return FALSE;
/* See GdkModifierType. Am I fixing a Gtk misbehaviour??? */
ev->state |= 1 << (ev->button + 7);
if (ev->state != masterdata->state ||
ev->state != slavedata->state ||
masterdata->lastslave != slave)
select_tool (data, master, slave, ev->state);
slavedata->lastx = ev->x;
slavedata->lasty = ev->y;
slavedata->motion_time = ev->time;
snap_undo_state (data);
if (gdk_device_get_source(slave) == GDK_SOURCE_MOUSE)
{
data->maxwidth = slavedata->cur_context->width;
}
else
{
gdk_event_get_axis ((GdkEvent *) ev, GDK_AXIS_PRESSURE, &pressure);
data->maxwidth = (CLAMP (pressure + line_thickener, 0, 1) *
(double) (slavedata->cur_context->width -
slavedata->cur_context->minwidth) +
slavedata->cur_context->minwidth);
}
if (ev->button <= 5)
draw_line (data, slave, ev->x, ev->y, ev->x, ev->y);
coord_list_prepend (data, slave, ev->x, ev->y, data->maxwidth);
return TRUE;
}
/**
* Handles the 'activate' signal on the tray_icon,
* usually opening the popup_window and grabbing pointer and keyboard.
*
* @param status_icon the object which received the signal
* @param user_data user data set when the signal handler was connected
*/
void
tray_icon_on_click(G_GNUC_UNUSED GtkStatusIcon *status_icon,
G_GNUC_UNUSED gpointer user_data)
{
get_current_levels();
if (!gtk_widget_get_visible(GTK_WIDGET(popup_window))) {
gtk_widget_show_now(popup_window);
gtk_widget_grab_focus(vol_scale);
#ifdef WITH_GTK3
GdkDevice *pointer_dev = gtk_get_current_event_device();
if (pointer_dev != NULL) {
GdkDevice *keyboard_dev =
gdk_device_get_associated_device(pointer_dev);
if (gdk_device_grab(pointer_dev,
gtk_widget_get_window(GTK_WIDGET(popup_window)),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_BUTTON_PRESS_MASK,
NULL, GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
g_warning("Could not grab %s\n",
gdk_device_get_name(pointer_dev));
if (keyboard_dev != NULL) {
if (gdk_device_grab(keyboard_dev,
gtk_widget_get_window(GTK_WIDGET(popup_window)),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_KEY_PRESS_MASK,
NULL, GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
g_warning("Could not grab %s\n",
gdk_device_get_name(keyboard_dev));
}
}
#else
gdk_keyboard_grab(gtk_widget_get_window(popup_window),
TRUE, GDK_CURRENT_TIME);
gdk_pointer_grab(gtk_widget_get_window(popup_window), TRUE,
GDK_BUTTON_PRESS_MASK, NULL, NULL, GDK_CURRENT_TIME);
#endif
} else {
gtk_widget_hide(popup_window);
}
}
static void
device_removed_cb (GdkDeviceManager *manager,
GdkDevice *device,
gpointer user_data)
{
g_hash_table_remove (monitors,
GINT_TO_POINTER (gdk_x11_device_get_id (device)));
g_message ("Removed watch for device %s (%d)",
gdk_device_get_name (device),
gdk_x11_device_get_id (device));
}
gboolean gtk_xournal_button_release_event(GtkWidget* widget,
GdkEventButton* event)
{
#ifdef INPUT_DEBUG
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("ButtonRelease (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x, isCore %i",
gdk_device_get_name(event->device), event->x, event->y,
event->button, event->state, isCore);
#endif
XInputUtils::fixXInputCoords((GdkEvent*) event, widget);
if (event->button > 3) // scroll wheel events
{
return true;
}
current_view = NULL;
GtkXournal* xournal = GTK_XOURNAL(widget);
Cursor* cursor = xournal->view->getCursor();
ToolHandler* h = xournal->view->getControl()->getToolHandler();
cursor->setMouseDown(false);
xournal->inScrolling = false;
EditSelection* sel = xournal->view->getSelection();
if (sel)
{
sel->mouseUp();
}
bool res = false;
if (xournal->currentInputPage)
{
xournal->currentInputPage->translateEvent((GdkEvent*) event, xournal->x,
xournal->y);
res = xournal->currentInputPage->onButtonReleaseEvent(widget, event);
xournal->currentInputPage = NULL;
}
EditSelection* tmpSelection = xournal->selection;
xournal->selection = NULL;
h->restoreLastConfig();
// we need this workaround so it's possible to select something with the middle button
if (tmpSelection)
{
xournal->view->setSelection(tmpSelection);
}
return res;
}
static void
grab_devices(GtkWidget *window)
{
GdkDevice *pointer_dev;
GdkDevice *keyboard_dev;
GdkGrabStatus status;
/* Grab the mouse */
pointer_dev = gtk_get_current_event_device();
if (pointer_dev == NULL) {
WARN("Couldn't get current device");
return;
}
status = gdk_device_grab(pointer_dev,
gtk_widget_get_window(window),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_BUTTON_PRESS_MASK,
NULL,
GDK_CURRENT_TIME);
if (status != GDK_GRAB_SUCCESS)
WARN("Could not grab %s", gdk_device_get_name(pointer_dev));
/* Grab the keyboard */
keyboard_dev = gdk_device_get_associated_device(pointer_dev);
if (keyboard_dev == NULL) {
WARN("Couldn't get associated device");
return;
}
status = gdk_device_grab(keyboard_dev,
gtk_widget_get_window(window),
GDK_OWNERSHIP_NONE,
TRUE,
GDK_KEY_PRESS_MASK,
NULL, GDK_CURRENT_TIME);
if (status != GDK_GRAB_SUCCESS)
WARN("Could not grab %s", gdk_device_get_name(keyboard_dev));
}
/* On device removed. */
void on_device_added (GdkDeviceManager *device_manager,
GdkDevice *device,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
if(data->debug)
{
g_printerr ("DEBUG: device '%s' added\n", gdk_device_get_name (device));
}
add_input_device (device, data);
}
gboolean gtk_xournal_scroll_event(GtkWidget * widget, GdkEventScroll * event) {
#ifdef INPUT_DEBUG
// true: Core event, false: XInput event
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("Scroll (%s) (x,y)=(%.2f,%.2f), direction %d, modifier %x, isCore %i", gdk_device_get_name(event->device), event->x, event->y,
event->direction, event->state, isCore);
#endif
g_return_val_if_fail(GTK_XOURNAL(widget), FALSE);
g_return_val_if_fail(event != NULL, FALSE);
GtkXournal * xournal = GTK_XOURNAL(widget);
return xournal->layout->scrollEvent(event);
}
static void
active_watch_func (GnomeIdleMonitor *monitor,
guint id,
gpointer user_data)
{
GdkDevice *device;
int device_id;
g_object_get (monitor, "device", &device, NULL);
device_id = gdk_x11_device_get_id (device);
g_message ("Active watch func called for device %s (id: %d, watch id %d)",
gdk_device_get_name (device),
device_id,
id);
g_object_unref (device);
}
void on_device_added (GdkDeviceManager *device_manager,
GdkDevice *device,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
GdkInputSource hardware_type = gdk_device_get_source(device);
if( hardware_type == GDK_SOURCE_KEYBOARD ||
gdk_device_get_n_axes(device) < 2)
return;
if(data->debug)
g_printerr("DEBUG: device '%s' added\n", gdk_device_get_name(device));
setup_input_devices(data);
}
static void
ensure_active_watch (GnomeIdleMonitor *monitor)
{
GdkDevice *device;
guint watch_id;
int device_id;
g_object_get (monitor, "device", &device, NULL);
device_id = gdk_x11_device_get_id (device);
watch_id = gnome_idle_monitor_add_user_active_watch (monitor,
active_watch_func,
NULL,
NULL);
g_message ("Added active watch ID %d for device %s (%d)",
watch_id,
gdk_device_get_name (device),
device_id);
}
JS_EXPORT_API
void guide_disable_keyboard()
{
// gdk_keyboard_grab(gtk_widget_get_window(get_container()), FALSE, GDK_CURRENT_TIME);
GdkWindow* window = gtk_widget_get_window(get_container());
GdkDisplay* display = gdk_window_get_display(window);
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GList* devices = gdk_device_manager_list_devices(manager, GDK_DEVICE_TYPE_MASTER);
GdkDevice* device = NULL;
for (GList* dev = devices; dev != NULL; dev = dev->next) {
device = GDK_DEVICE(dev->data);
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD) {
continue;
}
GdkGrabStatus res = gdk_device_grab(device,
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
NULL,
GDK_CURRENT_TIME
);
switch (res) {
case GDK_GRAB_ALREADY_GRABBED:
g_warning("Grab falied, device %s is already grabbed.", gdk_device_get_name(device));
break;
case GDK_GRAB_INVALID_TIME:
g_warning("Grab failed, the resource is grabbed more recently than the specified time.");
break;
case GDK_GRAB_NOT_VIEWABLE:
g_warning("Grab falied, the window is not viewable.");
break;
case GDK_GRAB_FROZEN:
g_warning("Grab falied, the resources is frozen.");
break;
case GDK_GRAB_SUCCESS:
break;
}
}
g_list_free(devices);
}
/* Run a custom command on device presence events. Parameters passed into
* the custom command are:
* command -t [added|removed|present] -i <device ID> <device name>
* Type 'added' and 'removed' signal 'device added' and 'device removed',
* respectively. Type 'present' signals 'device present at
* gnome-settings-daemon init'.
*
* The script is expected to run synchronously, and an exit value
* of "1" means that no other settings will be applied to this
* particular device.
*
* More options may be added in the future.
*
* This function returns TRUE if we should not apply any more settings
* to the device.
*/
gboolean
run_custom_command (GdkDevice *device,
CustomCommand command)
{
GSettings *settings;
char *cmd;
char *argv[7];
int exit_status;
gboolean rc;
int id;
settings = g_settings_new (INPUT_DEVICES_SCHEMA);
cmd = g_settings_get_string (settings, KEY_HOTPLUG_COMMAND);
g_object_unref (settings);
if (!cmd || cmd[0] == '\0') {
g_free (cmd);
return FALSE;
}
/* Easter egg! */
g_object_get (device, "device-id", &id, NULL);
argv[0] = cmd;
argv[1] = "-t";
argv[2] = (char *) custom_command_to_string (command);
argv[3] = "-i";
argv[4] = g_strdup_printf ("%d", id);
argv[5] = g_strdup_printf ("%s", gdk_device_get_name (device));
argv[6] = NULL;
rc = g_spawn_sync (g_get_home_dir (), argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, NULL, NULL, &exit_status, NULL);
if (rc == FALSE)
g_warning ("Couldn't execute command '%s', verify that this is a valid command.", cmd);
g_free (argv[0]);
g_free (argv[4]);
g_free (argv[5]);
return (exit_status == 0);
}
gboolean on_buttonrelease (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
/* get the data for this device */
GdkDevice *master = ev->device;
GromitDeviceData *masterdata =
g_hash_table_lookup(data->devdatatable, master);
GdkDevice *slave =
gdk_event_get_source_device ((GdkEvent *) ev);
GromitDeviceData *slavedata =
g_hash_table_lookup(data->devdatatable, slave);
if(data->debug)
g_printerr("DEBUG: Device '%s': Button %i Up at (x,y)=(%.2f : %.2f)\n",
gdk_device_get_name(slave), ev->button, ev->x, ev->y);
gfloat direction = 0;
gint width = 0;
if(slavedata->cur_context)
width = slavedata->cur_context->arrowsize *
slavedata->cur_context->width / 2;
if ((ev->x != slavedata->lastx) ||
(ev->y != slavedata->lasty))
on_motion(win, (GdkEventMotion *) ev, user_data);
if (!masterdata->is_grabbed)
return FALSE;
if (slavedata->cur_context->arrowsize != 0 &&
coord_list_get_arrow_param (data, slave, width * 3,
&width, &direction))
draw_arrow (data, slave, ev->x, ev->y, width, direction);
coord_list_free (data, slave);
return TRUE;
}
static void
grab_devices(GtkWidget *window)
{
GdkGrabStatus status;
GdkDevice *device;
/* Grab the current event device */
device = gtk_get_current_event_device();
if (device == NULL) {
WARN("Couldn't get current device");
return;
}
/* Grab every seat capabilities */
status = gdk_seat_grab(gdk_device_get_seat(device),
gtk_widget_get_window(window),
GDK_SEAT_CAPABILITY_ALL, TRUE,
NULL, NULL, NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
WARN("Could not grab %s", gdk_device_get_name(device));
}
void toggle_grab (GromitData *data,
GdkDevice* dev)
{
if(dev == NULL) /* toggle all */
{
if (data->all_grabbed)
release_grab (data, NULL);
else
acquire_grab (data, NULL);
return;
}
GromitDeviceData *devdata =
g_hash_table_lookup(data->devdatatable, dev);
if(devdata)
{
if(devdata->is_grabbed)
release_grab (data, devdata->device);
else
acquire_grab (data, devdata->device);
}
else
g_printerr("ERROR: No such device '%s' in internal table.\n", gdk_device_get_name(dev));
}
// load preferences from file
void load_preferences (char *filepad) {
char txt[100];
GString *label = g_string_new_len("", 20);
int i, p, choice = -1;
GdkDevice *device, *nodevice;
GList *list;
TS keus;
if (settings == NULL) settings = g_key_file_new();
if (g_key_file_load_from_file(settings, filepad, G_KEY_FILE_NONE, NULL) == FALSE) { // set defaults
gchar *data;
gsize len;
// default settings when xpen.cfg not found
g_key_file_set_integer (settings, "display", "x", -1);
g_key_file_set_integer (settings, "display", "y", -1);
g_key_file_set_integer (settings, "display", "lx", -1);
g_key_file_set_integer (settings, "display", "ly", -1);
g_key_file_set_integer (settings, "display", "dx", 300);
g_key_file_set_integer (settings, "display", "dy", 400);
g_key_file_set_double (settings, "display", "opacity", 0.7);
g_key_file_set_string (settings, "display", "font", gtk_font_button_get_font_name(GTK_FONT_BUTTON(fontbutton)));
g_key_file_set_boolean (settings, "display", "tooltips", TRUE);
g_key_file_set_string (settings, "reader", "device", "stylus");
g_key_file_set_integer (settings, "reader", "speed", 6);
g_key_file_set_uint64 (settings, "reader", "lijnkleur", 0x514942);
g_key_file_set_uint64 (settings, "reader", "rasterkleur", 0xAB8C6D);
g_key_file_set_boolean (settings, "reader", "raster", TRUE);
g_key_file_set_boolean (settings, "reader", "speech", FALSE);
g_key_file_set_string (settings, "reader", "command", "aplay -q");
g_key_file_set_integer (settings, "reader", "voice", 0);
g_key_file_set_integer (settings, "keys", "paste0", 37);
g_key_file_set_integer (settings, "keys", "paste1", 55);
g_key_file_set_integer (settings, "keys", "backspace0", 0);
g_key_file_set_integer (settings, "keys", "backspace1", 22);
g_key_file_set_integer (settings, "GB1", "key", 0);
g_key_file_set_integer (settings, "GB1", "mode", 0);
g_key_file_set_integer (settings, "BIG5", "key", CTRL_R);
g_key_file_set_integer (settings, "BIG5", "mode", BIG5);
g_key_file_set_integer (settings, "DIGITS", "key", ALT_L);
g_key_file_set_integer (settings, "DIGITS", "mode", DIGITS);
g_key_file_set_integer (settings, "LOWERCASE", "key", ALT_L);
g_key_file_set_integer (settings, "LOWERCASE", "mode", LOWERCASE);
g_key_file_set_integer (settings, "UPPERCASE", "key", 0);
g_key_file_set_integer (settings, "UPPERCASE", "mode", 0);
g_key_file_set_integer (settings, "PUNC", "key", 0);
g_key_file_set_integer (settings, "PUNC", "mode", 0);
g_key_file_set_integer (settings, "DEFAULT", "key", ESC);
g_key_file_set_integer (settings, "DEFAULT", "mode", (GB1|GB2|DIGITS));
g_key_file_set_string (settings, "keydefs", "label1", "Control-Left");
g_key_file_set_integer (settings, "keydefs", "key1", CTRL_L);
g_key_file_set_string (settings, "keydefs", "label2", "Control-Right");
g_key_file_set_integer (settings, "keydefs", "key2", CTRL_R);
g_key_file_set_string (settings, "keydefs", "label3", "Shift-Left");
g_key_file_set_integer (settings, "keydefs", "key3", SHIFT_L);
g_key_file_set_string (settings, "keydefs", "label4", "Shift-Right");
g_key_file_set_integer (settings, "keydefs", "key4", SHIFT_R);
g_key_file_set_string (settings, "keydefs", "label5", "Alt-Left");
g_key_file_set_integer (settings, "keydefs", "key5", ALT_L);
g_key_file_set_string (settings, "keydefs", "label6", "Alt-Right");
g_key_file_set_integer (settings, "keydefs", "key6", ALT_R);
g_key_file_set_string (settings, "keydefs", "label7", "Escape");
g_key_file_set_integer (settings, "keydefs", "key7", ESC);
g_key_file_set_string (settings, "keydefs", "label8", "Caps-Lock");
g_key_file_set_integer (settings, "keydefs", "key8", CAPS);
g_key_file_set_string (settings, "keydefs", "label9", "Num-Lock");
g_key_file_set_integer (settings, "keydefs", "key9", NUMS);
g_key_file_set_string (settings, "keydefs", "label10", "Scroll-Lock");
g_key_file_set_integer (settings, "keydefs", "key10", SCROLLS);
g_key_file_set_string (settings, "keydefs", "label11", "Pause/Break");
g_key_file_set_integer (settings, "keydefs", "key11", PAUSE);
g_key_file_set_string (settings, "keydefs", "label12", "not set");
g_key_file_set_integer (settings, "keydefs", "key12", 0);
g_key_file_set_string (settings, "keydefs", "label13", "not set");
g_key_file_set_integer (settings, "keydefs", "key13", 0);
data = g_key_file_to_data (settings, &len, NULL); // save defaults
g_file_set_contents (filepad, data, len, NULL);
g_free(data);
}
// fill the preferences structure
conf.x = g_key_file_get_integer (settings, "display", "x", NULL);
conf.y = g_key_file_get_integer (settings, "display", "y", NULL);
conf.lx = g_key_file_get_integer (settings, "display", "lx", NULL);
conf.ly = g_key_file_get_integer (settings, "display", "ly", NULL);
conf.dx = g_key_file_get_integer (settings, "display", "dx", NULL);
conf.dy = g_key_file_get_integer (settings, "display", "dy", NULL);
conf.opacity = g_key_file_get_double (settings, "display", "opacity", NULL);
conf.tips = g_key_file_get_boolean (settings, "display", "tooltips", NULL);
conf.font = g_key_file_get_string (settings, "display", "font", NULL);
conf.device = g_key_file_get_string (settings, "reader", "device", NULL);
conf.speed = g_key_file_get_integer (settings, "reader", "speed", NULL);
conf.lijnkleur = g_key_file_get_uint64 (settings, "reader", "lijnkleur", NULL);
conf.rasterkleur = g_key_file_get_uint64 (settings, "reader", "rasterkleur", NULL);
conf.raster = g_key_file_get_boolean (settings, "reader", "raster", NULL);
conf.speech = g_key_file_get_boolean (settings, "reader", "speech", NULL);
conf.voice = g_key_file_get_integer (settings, "reader", "voice", NULL);
conf.paste[0] = g_key_file_get_integer (settings, "keys", "paste0", NULL);
conf.paste[1] = g_key_file_get_integer (settings, "keys", "paste1", NULL);
conf.backspace[0] = g_key_file_get_integer (settings, "keys", "backspace0", NULL);
conf.backspace[1] = g_key_file_get_integer (settings, "keys", "backspace1", NULL);
conf.keymode[0].key = g_key_file_get_integer (settings, "GB1", "key", NULL);
conf.keymode[0].mode = g_key_file_get_integer (settings, "GB1", "mode", NULL);
conf.keymode[1].key = g_key_file_get_integer (settings, "BIG5", "key", NULL);
conf.keymode[1].mode = g_key_file_get_integer (settings, "BIG5", "mode", NULL);
conf.keymode[2].key = g_key_file_get_integer (settings, "DIGITS", "key", NULL);
conf.keymode[2].mode = g_key_file_get_integer (settings, "DIGITS", "mode", NULL);
conf.keymode[3].key = g_key_file_get_integer (settings, "LOWERCASE", "key", NULL);
conf.keymode[3].mode = g_key_file_get_integer (settings, "LOWERCASE", "mode", NULL);
conf.keymode[4].key = g_key_file_get_integer (settings, "UPPERCASE", "key", NULL);
conf.keymode[4].mode = g_key_file_get_integer (settings, "UPPERCASE", "mode", NULL);
conf.keymode[5].key = g_key_file_get_integer (settings, "PUNC", "key", NULL);
conf.keymode[5].mode = g_key_file_get_integer (settings, "PUNC", "mode", NULL);
conf.keymode[6].key = g_key_file_get_integer (settings, "DEFAULT", "key", NULL);
conf.keymode[6].mode = g_key_file_get_integer (settings, "DEFAULT", "mode", NULL);
// set speech + command
GTK_TOGGLE_BUTTON(checkbutton9)->active = conf.speech;
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox1), conf.voice);
for (i=0; i<13; i++) {
g_string_sprintf(label, "key%d", i+1);
conf.defkey[i].key = g_key_file_get_integer (settings, "keydefs", label->str, NULL);
g_string_sprintf(label, "label%d", i+1);
conf.defkey[i].label = g_key_file_get_string (settings, "keydefs", label->str, NULL);
}
// start setting all widgets with the values from the configuration (conf)
// set tooltips
GTK_TOGGLE_BUTTON(checkbutton8)->active = conf.tips;
// set the 13 buttons/entries in preferences
for (i=0; i<13; i++) {
if (conf.defkey[i].key > 0) {
g_string_sprintf(label, "key = %d", conf.defkey[i].key);
gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), label->str);
gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), conf.defkey[i].label);
} else {
gtk_button_set_label(GTK_BUTTON(conf.defkey[i].button), "not set");
gtk_entry_set_text(GTK_ENTRY(conf.defkey[i].entry), "");
}
}
g_string_free(label, TRUE);
// set the default recognition mode
mode = conf.keymode[6].mode;
keus = (mode & BIG5) ? Traditional : Simplified;
selecteer(keus);
// set the labels of the hotkeys (preferences)
for (i=0; i<7; i++) {
bool found;
hotkey[conf.keymode[i].key] |= conf.keymode[i].mode; // set the hotkeys
found = FALSE;
for (p=0; p<13; p++) {
if (conf.defkey[p].key > 0) {
if (conf.keymode[i].key == conf.defkey[p].key) {
strcpy(txt, conf.defkey[p].label);
found = TRUE;
break;
}
}
}
if (found == FALSE) {
if (conf.keymode[i].key > 0)
sprintf(txt, "key = %d", conf.keymode[i].key);
else
strcpy(txt, "not set");
}
gtk_button_set_label(GTK_BUTTON(modebits[i].button), txt);
// set the default checkboxes (preferences)
if (conf.keymode[6].mode & GB1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[0].check), TRUE);
if (conf.keymode[6].mode & BIG5)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[1].check), TRUE);
if (conf.keymode[6].mode & DIGITS)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[2].check), TRUE);
if (conf.keymode[6].mode & LOWERCASE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[3].check), TRUE);
if (conf.keymode[6].mode & UPPERCASE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[4].check), TRUE);
if (conf.keymode[6].mode & PUNC)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(modebits[5].check), TRUE);
}
// fill combobox with input-devices
list = gdk_devices_list();
device = (GdkDevice *) list->data; // default device
nodevice = NULL;
for (p=0; list->next; p++) {
strcpy(txt, gdk_device_get_name((GdkDevice *)list->data));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), txt);
if (strstr(txt, conf.device)) {
device = (GdkDevice *) list->data;
choice = p;
}
nodevice = (GdkDevice *) list->data;
list = list->next;
}
if (choice == -1) { // prefered device not found
choice = p-1;
device = nodevice;
}
//g_list_free(list);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), choice);
gdk_device_set_source (device, GDK_SOURCE_PEN);
gdk_device_set_mode(device, GDK_MODE_SCREEN);
// set line color
lijnkleur.pixel = conf.lijnkleur;
sprintf(txt, "#%.6X", lijnkleur.pixel);
gdk_color_parse(txt, &lijnkleur);
gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton1), &lijnkleur);
// set raster color
rasterkleur.pixel = conf.rasterkleur;
sprintf(txt, "#%.6X", rasterkleur.pixel);
gdk_color_parse(txt, &rasterkleur);
gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton2), &rasterkleur);
// set raster on/off check button
GTK_TOGGLE_BUTTON(checkbutton1)->active = conf.raster;
// set main window opacity slider
gtk_adjustment_set_value(opacity, conf.opacity);
// set the 9 candidate buttons with a default font
for (i=0; i< 9; i++) {
PangoFontDescription *pfont;
pfont = pango_font_description_from_string(conf.font);
gtk_widget_modify_font (GTK_WIDGET(knop[i]), pfont );
pango_font_description_free(pfont);
}
// set the font selection button with the font title
gtk_font_button_set_font_name(GTK_FONT_BUTTON(fontbutton), conf.font);
// set the recognize speed slider
gtk_adjustment_set_value(speed, conf.speed);
WTSetSpeed(conf.speed);
// set the default paste and backspace entry fields
gtk_entry_set_text(GTK_ENTRY(entry1), key2string(conf.paste[1], conf.paste[0]));
gtk_entry_set_text(GTK_ENTRY(entry2), key2string(conf.backspace[1], conf.backspace[0]));
}
void setup_input_devices (GromitData *data)
{
/* ungrab all */
release_grab (data, NULL);
/* and clear our own device data list */
GHashTableIter it;
gpointer value;
g_hash_table_iter_init (&it, data->devdatatable);
while (g_hash_table_iter_next (&it, NULL, &value))
g_free(value);
g_hash_table_remove_all(data->devdatatable);
/* get devices */
GdkDeviceManager *device_manager = gdk_display_get_device_manager(data->display);
GList *devices, *d;
int i = 0;
devices = g_list_concat(gdk_device_manager_list_devices
(device_manager, GDK_DEVICE_TYPE_MASTER),
gdk_device_manager_list_devices
(device_manager, GDK_DEVICE_TYPE_SLAVE));
for(d = devices; d; d = d->next)
{
GdkDevice *device = (GdkDevice *) d->data;
/* only enable devices with 2 ore more axes */
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD && gdk_device_get_n_axes(device) >= 2)
{
gdk_device_set_mode (device, GDK_MODE_SCREEN);
GromitDeviceData *devdata;
devdata = g_malloc0(sizeof (GromitDeviceData));
devdata->device = device;
devdata->index = i;
/* get attached keyboard and grab the hotkey */
if (!data->hot_keycode)
{
g_printerr("ERROR: Grabbing hotkey from attached keyboard "
"of '%s' failed, no hotkey defined.\n",
gdk_device_get_name(device));
g_free(devdata);
continue;
}
/* if this is a slave device, we need the master */
GdkDevice *kdevice=device;
if(gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_SLAVE)
kdevice=gdk_device_get_associated_device (device);
gint dev_id = -1;
g_object_get(kdevice, "device-id", &dev_id, NULL);
gint kbd_dev_id = -1;
XIDeviceInfo* devinfo;
int devicecount = 0;
devinfo = XIQueryDevice(GDK_DISPLAY_XDISPLAY(data->display),
dev_id,
&devicecount);
if(devicecount)
kbd_dev_id = devinfo->attachment;
XIFreeDeviceInfo(devinfo);
if(kbd_dev_id != -1)
{
if(data->debug)
g_printerr("DEBUG: Grabbing hotkey from keyboard '%d' .\n", kbd_dev_id);
XIEventMask mask;
unsigned char bits[4] = {0,0,0,0};
mask.mask = bits;
mask.mask_len = sizeof(bits);
XISetMask(bits, XI_KeyPress);
XISetMask(bits, XI_KeyRelease);
XIGrabModifiers modifiers[] = {{XIAnyModifier, 0}};
int nmods = 1;
gdk_error_trap_push ();
XIGrabKeycode( GDK_DISPLAY_XDISPLAY(data->display),
kbd_dev_id,
data->hot_keycode,
GDK_WINDOW_XID(data->root),
GrabModeAsync,
GrabModeAsync,
True,
&mask,
nmods,
modifiers);
XSync(GDK_DISPLAY_XDISPLAY(data->display), False);
if(gdk_error_trap_pop())
{
g_printerr("ERROR: Grabbing hotkey from keyboard device %d failed.\n",
kbd_dev_id);
g_free(devdata);
continue;
}
}
g_hash_table_insert(data->devdatatable, device, devdata);
g_printerr ("Enabled Device %d: \"%s\", (Type: %d)\n",
i++, gdk_device_get_name(device), gdk_device_get_source(device));
}
}
g_printerr ("Now %d enabled devices.\n", g_hash_table_size(data->devdatatable));
}
gboolean gtk_xournal_button_press_event(GtkWidget* widget,
GdkEventButton* event)
{
/**
* true: Core event, false: XInput event
*/
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x, isCore %i",
gdk_device_get_name(event->device), event->x, event->y,
event->button, event->state, isCore);
GtkXournal* xournal = GTK_XOURNAL(widget);
Settings* settings = xournal->view->getControl()->getSettings();
if(isCore && settings->isXinputEnabled() && settings->isIgnoreCoreEvents())
{
INPUTDBG2("gtk_xournal_button_press_event return false (ignore core)");
return false;
}
XInputUtils::fixXInputCoords((GdkEvent*) event, widget);
if (event->type != GDK_BUTTON_PRESS)
{
INPUTDBG2("gtk_xournal_button_press_event return false (event->type != GDK_BUTTON_PRESS)");
return false; // this event is not handled here
}
if (event->button > 3) // scroll wheel events
{
XInputUtils::handleScrollEvent(event, widget);
INPUTDBG2("gtk_xournal_button_press_event return true handled scroll event");
return true;
}
gtk_widget_grab_focus(widget);
// none button release event was sent, send one now
if (xournal->currentInputPage)
{
INPUTDBG2("gtk_xournal_button_press_event (xournal->currentInputPage != NULL)");
GdkEventButton ev = *event;
xournal->currentInputPage->translateEvent((GdkEvent*) &ev, xournal->x,
xournal->y);
xournal->currentInputPage->onButtonReleaseEvent(widget, &ev);
}
ToolHandler* h = xournal->view->getControl()->getToolHandler();
// Change the tool depending on the key or device
if(change_tool(settings, event, xournal))
return true;
// hand tool don't change the selection, so you can scroll e.g.
// with your touchscreen without remove the selection
if (h->getToolType() == TOOL_HAND)
{
Cursor* cursor = xournal->view->getCursor();
cursor->setMouseDown(true);
xournal->lastMousePositionX = 0;
xournal->lastMousePositionY = 0;
xournal->inScrolling = true;
gtk_widget_get_pointer(widget, &xournal->lastMousePositionX,
&xournal->lastMousePositionY);
INPUTDBG2("gtk_xournal_button_press_event (h->getToolType() == TOOL_HAND) return true");
return true;
}
else if (xournal->selection)
{
EditSelection* selection = xournal->selection;
PageView* view = selection->getView();
GdkEventButton ev = *event;
view->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
CursorSelectionType selType = selection->getSelectionTypeForPos(ev.x, ev.y,
xournal->view->getZoom());
if (selType)
{
if(selType == CURSOR_SELECTION_MOVE && event->button == 3)
{
selection->copySelection();
}
xournal->view->getCursor()->setMouseDown(true);
xournal->selection->mouseDown(selType, ev.x, ev.y);
INPUTDBG2("gtk_xournal_button_press_event (selection) return true");
return true;
}
else
{
xournal->view->clearSelection();
if(change_tool(settings, event, xournal))
return true;
}
}
PageView* pv = gtk_xournal_get_page_view_for_pos_cached(xournal, event->x,
event->y);
current_view = pv;
if (pv)
{
xournal->currentInputPage = pv;
pv->translateEvent((GdkEvent*) event, xournal->x, xournal->y);
INPUTDBG2("gtk_xournal_button_press_event (pv->onButtonPressEvent) return");
xournal->view->getDocument()->indexOf(pv->getPage());
return pv->onButtonPressEvent(widget, event);
}
INPUTDBG2("gtk_xournal_button_press_event (not handled) return false");
return false; // not handled
}
gboolean gtk_xournal_button_press_event(GtkWidget * widget, GdkEventButton * event) {
/**
* true: Core event, false: XInput event
*/
gboolean isCore = (event->device == gdk_device_get_core_pointer());
INPUTDBG("ButtonPress (%s) (x,y)=(%.2f,%.2f), button %d, modifier %x, isCore %i", gdk_device_get_name(event->device), event->x, event->y,
event->button, event->state, isCore);
GtkXournal * xournal = GTK_XOURNAL(widget);
Settings * settings = xournal->view->getControl()->getSettings();
if(isCore && settings->isXinputEnabled() && settings->isIgnoreCoreEvents()) {
INPUTDBG2("gtk_xournal_button_press_event return false (ignore core)");
return false;
}
XInputUtils::fixXInputCoords((GdkEvent*) event, widget);
if (event->type != GDK_BUTTON_PRESS) {
INPUTDBG2("gtk_xournal_button_press_event return false (event->type != GDK_BUTTON_PRESS)");
return false; // this event is not handled here
}
if (event->button > 3) { // scroll wheel events
XInputUtils::handleScrollEvent(event, widget);
INPUTDBG2("gtk_xournal_button_press_event return true handled scroll event");
return true;
}
gtk_widget_grab_focus(widget);
ToolHandler * h = xournal->view->getControl()->getToolHandler();
// none button release event was sent, send one now
if (xournal->currentInputPage) {
INPUTDBG2("gtk_xournal_button_press_event (xournal->currentInputPage != NULL)");
GdkEventButton ev = *event;
xournal->currentInputPage->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
xournal->currentInputPage->onButtonReleaseEvent(widget, &ev);
}
// Change the tool depending on the key or device
ButtonConfig * cfg = NULL;
ButtonConfig * cfgTouch = settings->getTouchButtonConfig();
if (event->button == 2) { // Middle Button
cfg = settings->getMiddleButtonConfig();
} else if (event->button == 3) { // Right Button
cfg = settings->getRightButtonConfig();
} else if (event->device->source == GDK_SOURCE_ERASER) {
cfg = settings->getEraserButtonConfig();
} else if (cfgTouch->device == event->device->name) {
cfg = cfgTouch;
// If an action is defined we do it, even if it's a drawing action...
if (cfg->getDisableDrawing() && cfg->getAction() == TOOL_NONE) {
ToolType tool = h->getToolType();
if (tool == TOOL_PEN || tool == TOOL_ERASER || tool == TOOL_HILIGHTER) {
printf("ignore touchscreen for drawing!\n");
return true;
}
}
}
if (cfg && cfg->getAction() != TOOL_NONE) {
h->copyCurrentConfig();
cfg->acceptActions(h);
}
// hand tool don't change the selection, so you can scroll e.g.
// with your touchscreen without remove the selection
if (h->getToolType() == TOOL_HAND) {
Cursor * cursor = xournal->view->getCursor();
cursor->setMouseDown(true);
xournal->lastMousePositionX = 0;
xournal->lastMousePositionY = 0;
xournal->inScrolling = true;
gtk_widget_get_pointer(widget, &xournal->lastMousePositionX, &xournal->lastMousePositionY);
INPUTDBG2("gtk_xournal_button_press_event (h->getToolType() == TOOL_HAND) return true");
return true;
} else if (xournal->selection) {
EditSelection * selection = xournal->selection;
PageView * view = selection->getView();
GdkEventButton ev = *event;
view->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y);
CursorSelectionType selType = selection->getSelectionTypeForPos(ev.x, ev.y, xournal->view->getZoom());
if (selType) {
xournal->view->getCursor()->setMouseDown(true);
xournal->selection->mouseDown(selType, ev.x, ev.y);
INPUTDBG2("gtk_xournal_button_press_event (selection) return true");
return true;
} else {
xournal->view->clearSelection();
}
}
PageView * pv = gtk_xournal_get_page_view_for_pos_cached(xournal, event->x, event->y);
if (pv) {
xournal->currentInputPage = pv;
pv->translateEvent((GdkEvent*) event, xournal->x, xournal->y);
INPUTDBG2("gtk_xournal_button_press_event (pv->onButtonPressEvent) return");
xournal->view->getDocument()->indexOf(pv->getPage());
return pv->onButtonPressEvent(widget, event);
}
INPUTDBG2("gtk_xournal_button_press_event (not handled) return false");
return false; // not handled
}
void acquire_grab (GromitData *data,
GdkDevice *dev)
{
show_window (data);
if(!dev) /* this means grab all */
{
GHashTableIter it;
gpointer value;
GromitDeviceData* devdata = NULL;
g_hash_table_iter_init (&it, data->devdatatable);
while (g_hash_table_iter_next (&it, NULL, &value))
{
GdkCursor *cursor;
devdata = value;
if(devdata->is_grabbed || gdk_device_get_device_type(devdata->device) == GDK_DEVICE_TYPE_SLAVE)
continue;
if(devdata->cur_context && devdata->cur_context->type == GROMIT_ERASER)
cursor = data->erase_cursor;
else
cursor = data->paint_cursor;
if(gdk_device_grab(devdata->device,
gtk_widget_get_window(data->win),
GDK_OWNERSHIP_NONE,
FALSE,
GROMIT_MOUSE_EVENTS,
cursor,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
/* this probably means the device table is outdated,
e.g. this device doesn't exist anymore */
g_printerr("Error grabbing Device '%s' while grabbing all, ignoring.\n",
gdk_device_get_name(devdata->device));
continue;
}
devdata->is_grabbed = 1;
}
data->all_grabbed = 1;
if(data->debug)
g_printerr("DEBUG: Grabbed all Devices.\n");
return;
}
GromitDeviceData *devdata =
g_hash_table_lookup(data->devdatatable, dev);
if (!devdata->is_grabbed)
{
GdkCursor *cursor;
if(devdata->cur_context && devdata->cur_context->type == GROMIT_ERASER)
cursor = data->erase_cursor;
else
cursor = data->paint_cursor;
if(gdk_device_grab(devdata->device,
gtk_widget_get_window(data->win),
GDK_OWNERSHIP_NONE,
FALSE,
GROMIT_MOUSE_EVENTS,
cursor,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
/* this probably means the device table is outdated,
e.g. this device doesn't exist anymore */
g_printerr("Error grabbing device '%s', rescanning device list.\n",
gdk_device_get_name(devdata->device));
setup_input_devices(data);
return;
}
devdata->is_grabbed = 1;
if(data->debug)
g_printerr("DEBUG: Grabbed Device '%s'.\n", gdk_device_get_name(devdata->device));
}
}
/* This is called when the button is pushed. */
G_MODULE_EXPORT gboolean
on_button_press (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
GdkDevice *master = gdk_event_get_device ( (GdkEvent *) ev);
/* Get the data for this device. */
AnnotateDeviceData *masterdata = g_hash_table_lookup (data->devdatatable, master);
gdouble pressure = 1.0;
if (data->cur_context == data->default_filler)
{
return FALSE;
}
if (!data->is_grabbed)
{
return FALSE;
}
if (!ev)
{
g_printerr ("Device '%s': Invalid event; I ungrab all\n",
gdk_device_get_name (master));
annotate_release_grab ();
return FALSE;
}
if (data->debug)
{
g_printerr ("Device '%s': Button %i Down at (x,y)= (%f : %f)\n",
gdk_device_get_name (master),
ev->button,
ev->x,
ev->y);
}
#ifdef _WIN32
if (inside_bar_window (ev->x_root, ev->y_root))
{
/* The point is inside the ardesia bar then ungrab. */
annotate_release_grab ();
return FALSE;
}
#endif
pressure = get_pressure ( (GdkEvent *) ev);
if (pressure <= 0)
{
return FALSE;
}
annotate_unhide_cursor ();
initialize_annotation_cairo_context (data);
annotate_configure_pen_options (data);
annotate_coord_dev_list_free (masterdata);
annotate_draw_point (masterdata, ev->x, ev->y, pressure);
annotate_coord_list_prepend (masterdata,
ev->x,
ev->y,
annotate_get_thickness (),
pressure);
return TRUE;
}
/* This shots when the button is released. */
G_MODULE_EXPORT gboolean
on_button_release (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
GdkDevice *master = gdk_event_get_device ( (GdkEvent *) ev);
/* Get the data for this device. */
AnnotateDeviceData *masterdata= g_hash_table_lookup (data->devdatatable, master);
guint lenght = g_slist_length (masterdata->coord_list);
if (!data->is_grabbed)
{
return FALSE;
}
if (!ev)
{
g_printerr ("Device '%s': Invalid event; I ungrab all\n",
gdk_device_get_name (master));
annotate_release_grab ();
return FALSE;
}
if (data->debug)
{
g_printerr ("Device '%s': Button %i Up at (x,y)= (%.2f : %.2f)\n",
gdk_device_get_name (master),
ev->button, ev->x, ev->y);
}
#ifdef _WIN32
if (inside_bar_window (ev->x_root, ev->y_root))
/* Point is in the ardesia bar. */
{
/* The last point was outside the bar then ungrab. */
annotate_release_grab ();
return FALSE;
}
if (data->old_paint_type == ANNOTATE_PEN)
{
annotate_select_pen ();
}
#endif
if (data->cur_context == data->default_filler)
{
annotate_fill (masterdata, data, ev->x, ev->y);
return TRUE;
}
initialize_annotation_cairo_context (data);
if (lenght > 2)
{
AnnotatePoint *first_point = (AnnotatePoint *) g_slist_nth_data (masterdata->coord_list, lenght-1);
AnnotatePoint *last_point = (AnnotatePoint *) g_slist_nth_data (masterdata->coord_list, 0);
gdouble distance = get_distance (ev->x, ev->y, first_point->x, first_point->y);
/* This is the tolerance to force to close the path in a magnetic way. */
gint score = 3;
/* If is applied some handled drawing mode then the tool is more tollerant. */
if ((data->rectify || data->roundify))
{
score = 6;
}
gdouble tollerance = annotate_get_thickness () * score;
gdouble pressure = last_point->pressure;
annotate_modify_color (masterdata, data, pressure);
gboolean closed_path = FALSE;
/* If the distance between two point lesser than tolerance they are the same point for me. */
if (distance > tollerance)
{
/* Different point. */
annotate_draw_line (masterdata, ev->x, ev->y, TRUE);
annotate_coord_list_prepend (masterdata, ev->x, ev->y, annotate_get_thickness (), pressure);
}
else
{
/* Rounded to be the same point. */
closed_path = TRUE; // this seems to be a closed path
annotate_draw_line (masterdata, first_point->x, first_point->y, TRUE);
annotate_coord_list_prepend (masterdata, first_point->x, first_point->y, annotate_get_thickness (), pressure);
}
if (data->cur_context->type != ANNOTATE_ERASER)
{
annotate_shape_recognize (masterdata, closed_path);
/* If is selected an arrow type then I draw the arrow. */
if (data->arrow)
{
/* Print arrow at the end of the path. */
annotate_draw_arrow (masterdata, distance);
}
}
}
cairo_stroke (data->annotation_cairo_context);
annotate_add_savepoint ();
annotate_hide_cursor ();
return TRUE;
}
/* This shots when the pointer is moving. */
G_MODULE_EXPORT gboolean
on_motion_notify (GtkWidget *win,
GdkEventMotion *ev,
gpointer user_data)
{
AnnotateData *data = (AnnotateData *) user_data;
GdkDevice *master = gdk_event_get_device ( (GdkEvent *) ev);
GdkDevice *slave = gdk_event_get_source_device ( (GdkEvent *) ev);
/* Get the data for this device. */
AnnotateDeviceData *masterdata= g_hash_table_lookup (data->devdatatable, master);
AnnotateDeviceData *slavedata = g_hash_table_lookup (data->devdatatable, slave);
if (data->cur_context == data->default_filler)
{
return FALSE;
}
if (ev->state != masterdata->state ||
ev->state != slavedata->state ||
masterdata->lastslave != slave)
{
annotate_select_tool (data, master, slave, ev->state);
}
gdouble selected_width = 0.0;
gdouble pressure = 1.0;
if (!data->is_grabbed)
{
return FALSE;
}
if (!ev)
{
g_printerr ("Device '%s': Invalid event; I ungrab all\n",
gdk_device_get_name (master));
annotate_release_grab ();
return FALSE;
}
if (data->debug)
{
g_printerr ("Device '%s': Move at (x,y)= (%f : %f)\n",
gdk_device_get_name (master),
ev->x,
ev->y);
}
#ifdef _WIN32
if (inside_bar_window (ev->x_root, ev->y_root))
{
if (data->debug)
{
g_printerr ("Device '%s': Move on the bar then ungrab\n",
gdk_device_get_name (master));
}
/* The point is inside the ardesia bar then ungrab. */
annotate_release_grab ();
return FALSE;
}
#endif
annotate_unhide_cursor ();
/* Only the first 5 buttons allowed. */
if(!(ev->state & (GDK_BUTTON1_MASK|
GDK_BUTTON2_MASK|
GDK_BUTTON3_MASK|
GDK_BUTTON4_MASK|
GDK_BUTTON5_MASK)))
{
return TRUE;
}
initialize_annotation_cairo_context (data);
annotate_configure_pen_options (data);
if (data->cur_context->type != ANNOTATE_ERASER)
{
pressure = get_pressure ( (GdkEvent *) ev);
if (pressure <= 0)
{
return FALSE;
}
/* If the point is already selected and higher pressure then print else jump it. */
if (masterdata->coord_list)
{
AnnotatePoint *last_point = (AnnotatePoint *) g_slist_nth_data (masterdata->coord_list, 0);
gdouble tollerance = annotate_get_thickness ();
if (get_distance (last_point->x, last_point->y, ev->x, ev->y)<tollerance)
{
/* Seems that you are uprising the pen. */
if (pressure <= last_point->pressure)
{
/* Jump the point you are uprising the hand. */
return FALSE;
}
else // pressure >= last_point->pressure
{
/* Seems that you are pressing the pen more. */
annotate_modify_color (masterdata, data, pressure);
annotate_draw_line (masterdata, ev->x, ev->y, TRUE);
/* Store the new pressure without allocate a new coordinate. */
last_point->pressure = pressure;
return TRUE;
}
}
annotate_modify_color (masterdata, data, pressure);
}
}
annotate_draw_line (masterdata, ev->x, ev->y, TRUE);
annotate_coord_list_prepend (masterdata, ev->x, ev->y, selected_width, pressure);
return TRUE;
}
/**
* Change the tool according to the device and button
* @return true to ignore event
*/
bool InputSequence::changeTool()
{
XOJ_CHECK_TYPE(InputSequence);
Settings* settings = inputHandler->getSettings();
ButtonConfig* cfgTouch = settings->getTouchButtonConfig();
ToolHandler* h = inputHandler->getToolHandler();
GtkXournal* xournal = inputHandler->getXournal();
ButtonConfig* cfg = NULL;
if (gdk_device_get_source(device) == GDK_SOURCE_PEN)
{
penDevice = true;
if (button == 2)
{
cfg = settings->getStylusButton1Config();
}
else if (button == 3)
{
cfg = settings->getStylusButton2Config();
}
}
else if (button == 2 /* Middle Button */ && !xournal->selection)
{
cfg = settings->getMiddleButtonConfig();
}
else if (button == 3 /* Right Button */ && !xournal->selection)
{
cfg = settings->getRightButtonConfig();
}
else if (gdk_device_get_source(device) == GDK_SOURCE_ERASER)
{
penDevice = true;
cfg = settings->getEraserButtonConfig();
}
else if (cfgTouch->device == gdk_device_get_name(device))
{
cfg = cfgTouch;
// If an action is defined we do it, even if it's a drawing action...
if (cfg->getDisableDrawing() && cfg->getAction() == TOOL_NONE)
{
ToolType tool = h->getToolType();
if (tool == TOOL_PEN || tool == TOOL_ERASER || tool == TOOL_HILIGHTER)
{
g_message("ignore touchscreen for drawing!\n");
return true;
}
}
}
if (cfg && cfg->getAction() != TOOL_NONE)
{
h->copyCurrentConfig();
cfg->acceptActions(h);
}
else
{
h->restoreLastConfig();
}
return false;
}
