void initdevice( int* stylus ) { GList* dev_list; GdkDevice* device; dev_list = gdk_devices_list(); (*stylus) = 0; while (dev_list != NULL) { printf ("one device\n"); device = (GdkDevice *)dev_list->data; printf(" %d : %s \n", device, device->name ); if (device != gdk_device_get_core_pointer()) { // #ifdef ENABLE_XINPUT_BUGFIX gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); // #endif gdk_device_set_mode(device, GDK_MODE_SCREEN); printf(" yeah this is xinput device %s \n", device -> name); if( !strcmp (device->name, "stylus") ) (*stylus) = (int) device; } dev_list = dev_list->next; } }
void Settings::checkCanXInput() { XOJ_CHECK_TYPE(Settings); this->canXIput = FALSE; GList* devList = gdk_devices_list(); while (devList != NULL) { GdkDevice* device = (GdkDevice*) devList->data; if (device != gdk_device_get_core_pointer()) { // get around a GDK bug: map the valuator range CORRECTLY to [0,1] if(this->getfixXinput()) { gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); } gdk_device_set_mode(device, GDK_MODE_SCREEN); if (g_str_has_suffix(device->name, "eraser")) { gdk_device_set_source(device, GDK_SOURCE_ERASER); } canXIput = TRUE; } devList = devList->next; } }
bool prepareMouseButtonEvent(GdkEvent* event, int button) { WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame); if (!view) return false; memset(event, 0, sizeof(event)); event->button.button = button; event->button.x = lastMousePositionX; event->button.y = lastMousePositionY; event->button.window = GTK_WIDGET(view)->window; event->button.device = gdk_device_get_core_pointer(); event->button.state = getStateFlags(); // Mouse up & down events dispatched via g_signal_emit_by_name must offset // their time value, so that WebKit can detect where sequences of mouse // clicks begin and end. This should not interfere with GDK or GTK+ event // processing, because the event is only seen by the widget. event->button.time = GDK_CURRENT_TIME + timeOffset; int xRoot, yRoot; #if GTK_CHECK_VERSION(2, 17, 3) gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &xRoot, &yRoot); #else getRootCoords(GTK_WIDGET(view), &xRoot, &yRoot); #endif event->button.x_root = xRoot; event->button.y_root = yRoot; return true; }
bool InputHandler::getPressureMultiplier(GdkEvent * event, double & presure) { XOJ_CHECK_TYPE(InputHandler); double * axes = NULL; GdkDevice * device = NULL; if (event->type == GDK_MOTION_NOTIFY) { axes = event->motion.axes; device = event->motion.device; } else { axes = event->button.axes; device = event->button.device; } if (device == gdk_device_get_core_pointer() || device->num_axes <= 2) { presure = 1.0; return false; } double rawpressure = axes[2] / (device->axes[2].max - device->axes[2].min); if (!finite(rawpressure)) { presure = 1.0; return false; } Settings * settings = xournal->getControl()->getSettings(); presure = ((1 - rawpressure) * settings->getWidthMinimumMultiplier() + rawpressure * settings->getWidthMaximumMultiplier()); return true; }
static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame); if (!view) return JSValueMakeUndefined(context); down = true; GdkEvent event; memset(&event, 0, sizeof(event)); event.type = GDK_BUTTON_PRESS; event.button.button = 1; if (argumentCount == 1) { event.button.button = (int)JSValueToNumber(context, arguments[0], exception) + 1; g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context)); } currentEventButton = event.button.button; event.button.x = lastMousePositionX; event.button.y = lastMousePositionY; event.button.window = GTK_WIDGET(view)->window; event.button.time = GDK_CURRENT_TIME; event.button.device = gdk_device_get_core_pointer(); int x_root, y_root; #if GTK_CHECK_VERSION(2,17,3) gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &x_root, &y_root); #else getRootCoords(GTK_WIDGET(view), &x_root, &y_root); #endif event.button.x_root = x_root; event.button.y_root = y_root; updateClickCount(event.button.button); if (!msgQueue[endOfQueue].delay) { webkit_web_frame_layout(mainFrame); gboolean return_val; g_signal_emit_by_name(view, "button_press_event", &event, &return_val); if (clickCount == 2) { event.type = GDK_2BUTTON_PRESS; g_signal_emit_by_name(view, "button_press_event", &event, &return_val); } } else { // replaySavedEvents should have the required logic to make leapForward delays work msgQueue[endOfQueue++].event = event; replaySavedEvents(); } return JSValueMakeUndefined(context); }
static JSValueRef mouseUpCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame); if (!view) return JSValueMakeUndefined(context); GdkEvent event; memset(&event, 0, sizeof(event)); event.type = GDK_BUTTON_RELEASE; event.button.button = 1; if (argumentCount == 1) { event.button.button = (int)JSValueToNumber(context, arguments[0], exception) + 1; g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context)); } currentEventButton = event.button.button; event.button.x = lastMousePositionX; event.button.y = lastMousePositionY; event.button.window = GTK_WIDGET(view)->window; event.button.time = GDK_CURRENT_TIME; event.button.device = gdk_device_get_core_pointer(); event.button.state = getStateFlags(); down = false; int x_root, y_root; #if GTK_CHECK_VERSION(2,17,3) gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &x_root, &y_root); #else getRootCoords(GTK_WIDGET(view), &x_root, &y_root); #endif event.button.x_root = x_root; event.button.y_root = y_root; if ((dragMode && !replayingSavedEvents) || msgQueue[endOfQueue].delay) { msgQueue[endOfQueue].event = event; msgQueue[endOfQueue++].isDragEvent = true; replaySavedEvents(); } else { webkit_web_frame_layout(mainFrame); gboolean return_val; g_signal_emit_by_name(view, "button_release_event", &event, &return_val); } lastClickPositionX = lastMousePositionX; lastClickPositionY = lastMousePositionY; return JSValueMakeUndefined(context); }
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; }
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); }
gboolean cairo_dock_emit_motion_signal (CairoDock *pDock, int iMouseX, int iMouseY) { static gboolean bReturn; static GdkEventMotion motion; motion.state = 0; motion.x = iMouseX; motion.y = iMouseY; motion.x_root = pDock->iWindowPositionX + pDock->iMouseX; motion.y_root = pDock->iWindowPositionY + pDock->iMouseY; motion.time = 0; motion.window = pDock->pWidget->window; motion.device = gdk_device_get_core_pointer (); g_signal_emit_by_name (pDock->pWidget, "motion-notify-event", &motion, &bReturn); return FALSE; }
gboolean gtk_xournal_motion_notify_event(GtkWidget * widget, GdkEventMotion * event) { #ifdef INPUT_DEBUG bool is_core = (event->device == gdk_device_get_core_pointer()); INPUTDBG("MotionNotify (%s) (x,y)=(%.2f,%.2f), modifier %x", is_core ? "core" : "xinput", event->x, event->y, event->state); #endif XInputUtils::fixXInputCoords((GdkEvent*) event, widget); GtkXournal * xournal = GTK_XOURNAL(widget); ToolHandler * h = xournal->view->getControl()->getToolHandler(); if (h->getToolType() == TOOL_HAND) { if (xournal->inScrolling) { gtk_xournal_scroll_mouse_event(xournal, event); return true; } return false; } else if (xournal->selection) { EditSelection * selection = xournal->selection; PageView * view = selection->getView(); GdkEventMotion ev = *event; view->translateEvent((GdkEvent*) &ev, xournal->x, xournal->y); if (xournal->selection->isMoving()) { selection->mouseMove(ev.x, ev.y); } else { CursorSelectionType selType = selection->getSelectionTypeForPos(ev.x, ev.y, xournal->view->getZoom()); xournal->view->getCursor()->setMouseSelectionType(selType); } return true; } PageView * pv = gtk_xournal_get_page_view_for_pos_cached(xournal, event->x, event->y); xournal->view->getCursor()->setInsidePage(pv != NULL); if (pv) { // allow events only to a single page! if (xournal->currentInputPage == NULL || pv == xournal->currentInputPage) { pv->translateEvent((GdkEvent*) event, xournal->x, xournal->y); return pv->onMotionNotifyEvent(widget, event);; } } return false; }
static JSValueRef mouseMoveToCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame); if (!view) return JSValueMakeUndefined(context); if (argumentCount < 2) return JSValueMakeUndefined(context); lastMousePositionX = (int)JSValueToNumber(context, arguments[0], exception); g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context)); lastMousePositionY = (int)JSValueToNumber(context, arguments[1], exception); g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context)); GdkEvent event; memset(&event, 0, sizeof(event)); event.type = GDK_MOTION_NOTIFY; event.motion.x = lastMousePositionX; event.motion.y = lastMousePositionY; event.motion.time = GDK_CURRENT_TIME; event.motion.window = GTK_WIDGET(view)->window; event.motion.device = gdk_device_get_core_pointer(); event.motion.state = getStateFlags(); int xRoot, yRoot; #if GTK_CHECK_VERSION(2,17,3) gdk_window_get_root_coords(GTK_WIDGET(view)->window, lastMousePositionX, lastMousePositionY, &xRoot, &yRoot); #else getRootCoords(GTK_WIDGET(view), &xRoot, &yRoot); #endif event.motion.x_root = xRoot; event.motion.y_root = yRoot; sendOrQueueEvent(event); return JSValueMakeUndefined(context); }
static VALUE device_s_get_core_pointer(VALUE self) { return GOBJ2RVAL(gdk_device_get_core_pointer()); }
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 }
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 on_title_pressed(GtkWidget *title, GdkEventButton *event, WindowckPlugin *wckp) { if (!wckp->win->controlwindow) return FALSE; if (event->button == 1 && (wnck_window_get_window_type (wckp->win->controlwindow) != WNCK_WINDOW_DESKTOP)) { /* double/tripple click */ if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS) { toggle_maximize(wckp->win->controlwindow); } else /* left-click */ { wnck_window_activate(wckp->win->controlwindow, gtk_get_current_event_time()); // WnckScreen *screen = wnck_screen_get_default (); // wnck_screen_force_update (screen); WnckWindow *active_window = wckp->win->controlwindow; if (!wnck_window_is_maximized(active_window)) return TRUE; GdkDisplay *gdkdisp = gdk_display_get_default (); // Gdk 3 // GdkDevice *mouse = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdkdisp)); GdkDevice *mouse = gdk_device_get_core_pointer(); Display *d = gdk_x11_display_get_xdisplay(gdkdisp); XEvent xev; Atom netMoveResize = XInternAtom(d, "_NET_WM_MOVERESIZE", FALSE); xev.xclient.type = ClientMessage; xev.xclient.message_type = netMoveResize; xev.xclient.display = d; xev.xclient.window = wnck_window_get_xid(active_window); xev.xclient.format = 32; // Gdk 3 // int x, y; // gdk_device_get_position(mouse, NULL, &x, &y); // TODO: Provide a second argument to gdk_device_get_state gdouble xy[2]; gdk_device_get_state(mouse, NULL, xy, NULL); xev.xclient.data.l[0] = xy[0]; xev.xclient.data.l[1] = xy[1]; xev.xclient.data.l[2] = 8; // _NET_WM_MOVERESIZE_MOVE xev.xclient.data.l[3] = Button1; xev.xclient.data.l[4] = 0; XUngrabPointer(d, CurrentTime); XSendEvent(d, RootWindow(d, 0), FALSE, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } return TRUE; } if (event->button == 3) { /* right-click */ wnck_window_activate(wckp->win->controlwindow, gtk_get_current_event_time()); /* let the panel show the menu */ return TRUE; } return FALSE; }
void init_stuff (int argc, char *argv[]) { GtkWidget *w; GList *dev_list; GdkDevice *device; GdkScreen *screen; int i, j; struct Brush *b; gboolean can_xinput, success; gchar *tmppath, *tmpfn; // create some data structures needed to populate the preferences ui.default_page.bg = g_new(struct Background, 1); // initialize config file names tmppath = g_build_filename(g_get_home_dir(), CONFIG_DIR, NULL); mkdir(tmppath, 0700); // safer (MRU data may be confidential) ui.mrufile = g_build_filename(tmppath, MRU_FILE, NULL); ui.configfile = g_build_filename(tmppath, CONFIG_FILE, NULL); g_free(tmppath); // initialize preferences init_config_default(); load_config_from_file(); ui.font_name = g_strdup(ui.default_font_name); ui.font_size = ui.default_font_size; ui.hiliter_alpha_mask = 0xffffff00 + (guint)(255*ui.hiliter_opacity); // we need an empty canvas prior to creating the journal structures canvas = GNOME_CANVAS (gnome_canvas_new_aa ()); // initialize data ui.default_page.bg->canvas_item = NULL; ui.layerbox_length = 0; if (argc > 2 || (argc == 2 && argv[1][0] == '-')) { printf(_("Invalid command line parameters.\n" "Usage: %s [filename.xoj]\n"), argv[0]); gtk_exit(0); } undo = NULL; redo = NULL; journal.pages = NULL; bgpdf.status = STATUS_NOT_INIT; new_journal(); ui.cur_item_type = ITEM_NONE; ui.cur_item = NULL; ui.cur_path.coords = NULL; ui.cur_path_storage_alloc = 0; ui.cur_path.ref_count = 1; ui.cur_widths = NULL; ui.cur_widths_storage_alloc = 0; ui.selection = NULL; ui.cursor = NULL; ui.pen_cursor_pix = ui.hiliter_cursor_pix = NULL; ui.cur_brush = &(ui.brushes[0][ui.toolno[0]]); for (j=0; j<=NUM_BUTTONS; j++) for (i=0; i < NUM_STROKE_TOOLS; i++) { b = &(ui.brushes[j][i]); b->tool_type = i; if (b->color_no>=0) { b->color_rgba = predef_colors_rgba[b->color_no]; if (i == TOOL_HIGHLIGHTER) { b->color_rgba &= ui.hiliter_alpha_mask; } } b->thickness = predef_thickness[i][b->thickness_no]; } for (i=0; i<NUM_STROKE_TOOLS; i++) g_memmove(ui.default_brushes+i, &(ui.brushes[0][i]), sizeof(struct Brush)); ui.cur_mapping = 0; ui.which_unswitch_button = 0; ui.in_proximity = FALSE; ui.warned_generate_fontconfig = FALSE; reset_recognizer(); // initialize various interface elements gtk_window_set_default_size(GTK_WINDOW (winMain), ui.window_default_width, ui.window_default_height); if (ui.maximize_at_start) gtk_window_maximize(GTK_WINDOW (winMain)); update_toolbar_and_menu(); update_font_button(); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalApplyAllPages")), ui.bg_apply_all_pages); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("journalNewPageKeepsBG")), ui.new_page_bg_from_pdf); if (ui.fullscreen) { gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("viewFullscreen")), TRUE); gtk_toggle_tool_button_set_active( GTK_TOGGLE_TOOL_BUTTON(GET_COMPONENT("buttonFullscreen")), TRUE); gtk_window_fullscreen(GTK_WINDOW(winMain)); } gtk_button_set_relief(GTK_BUTTON(GET_COMPONENT("buttonColorChooser")), GTK_RELIEF_NONE); allow_all_accels(); add_scroll_bindings(); // prevent interface items from stealing focus // glade doesn't properly handle can_focus, so manually set it gtk_combo_box_set_focus_on_click(GTK_COMBO_BOX(GET_COMPONENT("comboLayer")), FALSE); g_signal_connect(GET_COMPONENT("spinPageNo"), "activate", G_CALLBACK(handle_activate_signal), NULL); gtk_container_forall(GTK_CONTAINER(winMain), unset_flags, (gpointer)GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(canvas), GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(GTK_WIDGET(GET_COMPONENT("spinPageNo")), GTK_CAN_FOCUS); // install hooks on button/key/activation events to make the spinPageNo lose focus gtk_container_forall(GTK_CONTAINER(winMain), install_focus_hooks, NULL); // set up and initialize the canvas gtk_widget_show (GTK_WIDGET (canvas)); w = GET_COMPONENT("scrolledwindowMain"); gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (canvas)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_events (GTK_WIDGET (canvas), GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_PROXIMITY_IN_MASK | GDK_PROXIMITY_OUT_MASK); gnome_canvas_set_pixels_per_unit (canvas, ui.zoom); gnome_canvas_set_center_scroll_region (canvas, TRUE); gtk_layout_get_hadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; gtk_layout_get_vadjustment(GTK_LAYOUT (canvas))->step_increment = ui.scrollbar_step_increment; // set up the page size and canvas size update_page_stuff(); g_signal_connect ((gpointer) canvas, "button_press_event", G_CALLBACK (on_canvas_button_press_event), NULL); g_signal_connect ((gpointer) canvas, "button_release_event", G_CALLBACK (on_canvas_button_release_event), NULL); g_signal_connect ((gpointer) canvas, "enter_notify_event", G_CALLBACK (on_canvas_enter_notify_event), NULL); g_signal_connect ((gpointer) canvas, "leave_notify_event", G_CALLBACK (on_canvas_leave_notify_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_in_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "proximity_out_event", G_CALLBACK (on_canvas_proximity_event), NULL); g_signal_connect ((gpointer) canvas, "expose_event", G_CALLBACK (on_canvas_expose_event), NULL); g_signal_connect ((gpointer) canvas, "key_press_event", G_CALLBACK (on_canvas_key_press_event), NULL); g_signal_connect ((gpointer) canvas, "motion_notify_event", G_CALLBACK (on_canvas_motion_notify_event), NULL); g_signal_connect ((gpointer) gtk_layout_get_vadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_vscroll_changed), NULL); g_signal_connect ((gpointer) gtk_layout_get_hadjustment(GTK_LAYOUT(canvas)), "value-changed", G_CALLBACK (on_hscroll_changed), NULL); g_object_set_data (G_OBJECT (winMain), "canvas", canvas); screen = gtk_widget_get_screen(winMain); ui.screen_width = gdk_screen_get_width(screen); ui.screen_height = gdk_screen_get_height(screen); can_xinput = FALSE; dev_list = gdk_devices_list(); while (dev_list != NULL) { device = (GdkDevice *)dev_list->data; if (device != gdk_device_get_core_pointer() && device->num_axes >= 2) { /* get around a GDK bug: map the valuator range CORRECTLY to [0,1] */ #ifdef ENABLE_XINPUT_BUGFIX gdk_device_set_axis_use(device, 0, GDK_AXIS_IGNORE); gdk_device_set_axis_use(device, 1, GDK_AXIS_IGNORE); #endif gdk_device_set_mode(device, GDK_MODE_SCREEN); if (g_strrstr(device->name, "raser")) gdk_device_set_source(device, GDK_SOURCE_ERASER); can_xinput = TRUE; } dev_list = dev_list->next; } if (!can_xinput) gtk_widget_set_sensitive(GET_COMPONENT("optionsUseXInput"), FALSE); ui.use_xinput = ui.allow_xinput && can_xinput; gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsProgressiveBG")), ui.progressive_bg); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPrintRuling")), ui.print_ruling); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoloadPdfXoj")), ui.autoload_pdf_xoj); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutosaveXoj")), ui.autosave_enabled); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLeftHanded")), ui.left_handed); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsShortenMenus")), ui.shorten_menus); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsAutoSavePrefs")), ui.auto_save_prefs); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsButtonSwitchMapping")), ui.button_switch_mapping); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsLargePenCursor")), ui.large_pencursor); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsPenCursor")), ui.pen_cursor); hide_unimplemented(); update_undo_redo_enabled(); update_copy_paste_enabled(); update_vbox_order(ui.vertical_order[ui.fullscreen?1:0]); gtk_widget_grab_focus(GTK_WIDGET(canvas)); // show everything... gtk_widget_show (winMain); update_cursor(); /* this will cause extension events to get enabled/disabled, but we need the windows to be mapped first */ gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(GET_COMPONENT("optionsUseXInput")), ui.use_xinput); /* fix a bug in GTK+ 2.16 and 2.17: scrollbars shouldn't get extended input events from pointer motion when cursor moves into main window */ if (!gtk_check_version(2, 16, 0)) { g_signal_connect ( GET_COMPONENT("menubar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarMain"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("toolbarPen"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( GET_COMPONENT("statusbar"), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); g_signal_connect ( (gpointer)(gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(w))), "event", G_CALLBACK (filter_extended_events), NULL); } // load the MRU init_mru(); // and finally, open a file specified on the command line // (moved here because display parameters weren't initialized yet...) if (argc == 1) return; set_cursor_busy(TRUE); if (g_path_is_absolute(argv[1])) tmpfn = g_strdup(argv[1]); else { tmppath = g_get_current_dir(); tmpfn = g_build_filename(tmppath, argv[1], NULL); g_free(tmppath); } success = open_journal(tmpfn); g_free(tmpfn); set_cursor_busy(FALSE); if (!success) { w = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening file '%s'"), argv[1]); gtk_dialog_run(GTK_DIALOG(w)); gtk_widget_destroy(w); } }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *drawing_area; GtkWidget *vbox; GtkWidget *button; gtk_init (&argc, &argv); current_device = gdk_device_get_core_pointer (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (window, "Test Input"); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); g_signal_connect (window, "destroy", G_CALLBACK (quit), NULL); /* Create the drawing area */ drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (drawing_area, 200, 200); gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); /* Signals used to handle backing pixmap */ g_signal_connect (drawing_area, "expose_event", G_CALLBACK (expose_event), NULL); g_signal_connect (drawing_area, "configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (drawing_area, "motion_notify_event", G_CALLBACK (motion_notify_event), NULL); g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press_event), NULL); g_signal_connect (drawing_area, "key_press_event", G_CALLBACK (key_press_event), NULL); g_signal_connect (drawing_area, "leave_notify_event", G_CALLBACK (leave_notify_event), NULL); g_signal_connect (drawing_area, "proximity_out_event", G_CALLBACK (proximity_out_event), NULL); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_PROXIMITY_OUT_MASK); /* The following call enables tracking and processing of extension events for the drawing area */ gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_ALL); GTK_WIDGET_SET_FLAGS (drawing_area, GTK_CAN_FOCUS); gtk_widget_grab_focus (drawing_area); /* .. And create some buttons */ button = gtk_button_new_with_label ("Input Dialog"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (create_input_dialog), NULL); gtk_widget_show (button); button = gtk_button_new_with_label ("Quit"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window); gtk_widget_show (button); gtk_widget_show (window); gtk_main (); return 0; }