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; } }
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; } }
gboolean XInputUtils::onMouseLeaveNotifyEvent(GtkWidget* widget, GdkEventCrossing* event) { if(!XInputUtils::enableLeafEnterWorkaround) { return FALSE; } INPUTDBG("leave notify (mode=%d, details=%d)\n", event->mode, event->detail); /* emergency disable XInput to avoid segfaults (GTK+ 2.17) or interface non-responsiveness (GTK+ 2.18) */ if (!gtk_check_version(2, 17, 0)) { gdk_flush(); gdk_error_trap_push(); for (GList* dev_list = gdk_devices_list(); dev_list != NULL; dev_list = dev_list->next) { GdkDevice* dev = GDK_DEVICE(dev_list->data); gdk_device_set_mode(dev, GDK_MODE_DISABLED); } gdk_flush(); gdk_error_trap_pop(); } return FALSE; }
gboolean XInputUtils::onMouseEnterNotifyEvent(GtkWidget* widget, GdkEventCrossing* event) { if(!XInputUtils::enableLeafEnterWorkaround) { return FALSE; } INPUTDBG("enter notify\n"); /* re-enable input devices after they've been emergency-disabled by leave_notify */ if (!gtk_check_version(2, 17, 0)) { gdk_flush(); gdk_error_trap_push(); for (GList* dev_list = gdk_devices_list(); dev_list != NULL; dev_list = dev_list->next) { GdkDevice* dev = GDK_DEVICE(dev_list->data); gdk_device_set_mode(dev, GDK_MODE_SCREEN); } gdk_flush(); gdk_error_trap_pop(); } return FALSE; }
void ButtonConfigGui::saveSettings() { XOJ_CHECK_TYPE(ButtonConfigGui); ButtonConfig* cfg = settings->getButtonConfig(button); ToolType action = TOOL_NONE; GtkTreeIter iter; gtk_combo_box_get_active_iter(GTK_COMBO_BOX(cbTool), &iter); GValue value = {0}; GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbTool)); gtk_tree_model_get_value(model, &iter, 2, &value); action = (ToolType) g_value_get_int(&value); cfg->action = action; int thickness = gtk_combo_box_get_active(GTK_COMBO_BOX(cbThickness)); if (thickness == 1) { cfg->size = TOOL_SIZE_FINE; } else if (thickness == 2) { cfg->size = TOOL_SIZE_MEDIUM; } else if (thickness == 3) { cfg->size = TOOL_SIZE_THICK; } else { cfg->size = TOOL_SIZE_NONE; } GdkColor color = {0, 0, 0, 0}; gtk_color_button_get_color(GTK_COLOR_BUTTON(colorButton), &color); cfg->color = (color.red / 256) << 16 | (color.green / 256) << 8 | (color.blue / 256); cfg->drawingType = (DrawingType) gtk_combo_box_get_active(GTK_COMBO_BOX(this->cbDrawingType)); int eraserMode = gtk_combo_box_get_active(GTK_COMBO_BOX(this->cbEraserType)); if (eraserMode == 1) { cfg->eraserMode = ERASER_TYPE_DEFAULT; } else if (eraserMode == 2) { cfg->eraserMode = ERASER_TYPE_WHITEOUT; } else if (eraserMode == 3) { cfg->eraserMode = ERASER_TYPE_DELETE_STROKE; } else { cfg->eraserMode = ERASER_TYPE_NONE; } if (this->withDevice) { GList* devices = gdk_devices_list(); int dev = gtk_combo_box_get_active(GTK_COMBO_BOX(cbDevice)); GList* selected = g_list_nth(devices, dev - 1); if (selected == 0) { cfg->device = ""; } else { cfg->device = ((GdkDevice*) selected->data)->name; } cfg->disableDrawing = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbDisableDrawing)); } settings->customSettingsChanged(); }
void ButtonConfigGui::loadSettings() { XOJ_CHECK_TYPE(ButtonConfigGui); ButtonConfig* cfg = settings->getButtonConfig(button); GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(cbTool)); GtkTreeIter iter; if (!gtk_tree_model_get_iter_first(model, &iter)) { return; } GValue value = {0}; int i = 0; gtk_combo_box_set_active(GTK_COMBO_BOX(cbTool), 0); do { gtk_tree_model_get_value(model, &iter, 2, &value); int action = g_value_get_int(&value); if (action == cfg->action) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbTool), i); break; } i++; g_value_unset(&value); } while (gtk_tree_model_iter_next(model, &iter)); if (cfg->size == TOOL_SIZE_FINE) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 1); } else if (cfg->size == TOOL_SIZE_MEDIUM) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 2); } else if (cfg->size == TOOL_SIZE_THICK) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 3); } else { gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 0); } GdkColor color = {0, 0, 0, 0}; color.red = (cfg->color >> 8) & 0xff00; color.green = (cfg->color >> 0) & 0xff00; color.blue = (cfg->color << 8) & 0xff00; gtk_color_button_set_color(GTK_COLOR_BUTTON(colorButton), &color); gtk_combo_box_set_active(GTK_COMBO_BOX(this->cbDrawingType), cfg->drawingType); if (cfg->eraserMode == ERASER_TYPE_DEFAULT) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbEraserType), 1); } else if (cfg->eraserMode == ERASER_TYPE_WHITEOUT) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbEraserType), 2); } else if (cfg->eraserMode == ERASER_TYPE_DELETE_STROKE) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbEraserType), 3); } else { gtk_combo_box_set_active(GTK_COMBO_BOX(cbEraserType), 0); } if (withDevice) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbDevice), 0); int i = 0; GList* devices = gdk_devices_list(); for (GList* l = devices; l != NULL; l = l->next, i++) { GdkDevice* dev = (GdkDevice*) l->data; if (cfg->device == dev->name) { gtk_combo_box_set_active(GTK_COMBO_BOX(cbDevice), i + 1); break; } } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbDisableDrawing), cfg->disableDrawing); } }
ButtonConfigGui::ButtonConfigGui(SettingsDialog* dlg, GtkWidget* w, Settings* settings, int button, bool withDevice) { XOJ_INIT_TYPE(ButtonConfigGui); this->settings = settings; this->button = button; this->withDevice = withDevice; GtkWidget* table = gtk_table_new(8, 2, false); if (withDevice) { this->cbDevice = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDevice), _C("No device")); GList* devices = gdk_devices_list(); for (GList* l = devices; l != NULL; l = l->next) { GdkDevice* dev = (GdkDevice*) l->data; string devType = ""; if (dev->source == GDK_SOURCE_MOUSE) { devType = _("mouse"); } else if (dev->source == GDK_SOURCE_PEN) { devType = _("pen"); } else if (dev->source == GDK_SOURCE_ERASER) { devType = _("eraser"); } else if (dev->source == GDK_SOURCE_CURSOR) { devType = _("cursor"); } char* txt = g_strdup_printf("%s (%s)", dev->name, devType.c_str()); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDevice), txt); g_free(txt); } gtk_table_attach(GTK_TABLE(table), newLabel(_C("Device")), 0, 1, 0, 1, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), this->cbDevice, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); cbDisableDrawing = gtk_check_button_new_with_label(_C("Disable drawing for this device")); gtk_table_attach(GTK_TABLE(table), cbDisableDrawing, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); } else { this->cbDevice = NULL; this->cbDisableDrawing = NULL; } GtkListStore* typeModel = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter iter; ADD_TYPE_CB("empty.svg", _C("Don't change"), TOOL_NONE); ADD_TYPE_CB("tool_pencil.svg", _C("Pen"), TOOL_PEN); ADD_TYPE_CB("tool_eraser.svg", _C("Eraser"), TOOL_ERASER); ADD_TYPE_CB("tool_highlighter.png", _C("Hilighter"), TOOL_HILIGHTER); ADD_TYPE_CB("tool_text.svg", _C("Text"), TOOL_TEXT); ADD_TYPE_CB("tool_image.svg", _C("Insert image"), TOOL_IMAGE); ADD_TYPE_CB("stretch.svg", _C("Vertical space"), TOOL_VERTICAL_SPACE); ADD_TYPE_CB("lasso.svg", _C("Select region"), TOOL_SELECT_REGION); ADD_TYPE_CB("rect-select.svg", _C("Select rectangle"), TOOL_SELECT_RECT); //ADD_TYPE_CB("rect-draw.svg", _C("Draw rectangle"), TOOL_DRAW_RECT); //ADD_TYPE_CB("circle-draw.svg", _C("Draw circle"), TOOL_DRAW_CIRCLE); ADD_TYPE_CB("hand.svg", _C("Hand"), TOOL_HAND); GtkCellRenderer* renderer = NULL; this->cbTool = gtk_combo_box_new_with_model(GTK_TREE_MODEL(typeModel)); g_signal_connect(cbTool, "changed", G_CALLBACK(&cbSelectCallback), this); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(this->cbTool), renderer, false); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(this->cbTool), renderer, "pixbuf", 0, NULL); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(this->cbTool), renderer, true); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(this->cbTool), renderer, "text", 1, NULL); gtk_table_attach(GTK_TABLE(table), newLabel(_C("Tool")), 0, 1, 2, 3, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), cbTool, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); this->cbThickness = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Don't change")); gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Thin")); gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Medium")); gtk_combo_box_append_text(GTK_COMBO_BOX(cbThickness), _C("Thick")); gtk_combo_box_set_active(GTK_COMBO_BOX(cbThickness), 0); gtk_table_attach(GTK_TABLE(table), newLabel(_C("Thickness")), 0, 1, 3, 4, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), this->cbThickness, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); this->colorButton = gtk_color_button_new(); gtk_table_attach(GTK_TABLE(table), newLabel(_C("Color")), 0, 1, 4, 5, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), colorButton, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); this->cbDrawingType = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Don't change")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Enable Ruler")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Enable Stroke Recognizer")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbDrawingType), _C("Disable Ruler & Stroke Recognizer")); gtk_table_attach(GTK_TABLE(table), newLabel(_C("Ruler & Stroke Reco.")), 0, 1, 5, 6, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), this->cbDrawingType, 1, 2, 5, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); this->cbEraserType = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Don't change")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Standard")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Whiteout")); gtk_combo_box_append_text(GTK_COMBO_BOX(this->cbEraserType), _C("Delete stroke")); gtk_table_attach(GTK_TABLE(table), newLabel(_C("Eraser type")), 0, 1, 8, 9, GTK_FILL, GTK_FILL, 20, 0); gtk_table_attach(GTK_TABLE(table), this->cbEraserType, 1, 2, 8, 9, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_container_add(GTK_CONTAINER(w), table); gtk_widget_show_all(table); loadSettings(); }
/* Methods */ static VALUE device_s_list(VALUE self) { /* Owned by GDK */ return GLIST2ARY(gdk_devices_list()); }
// 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 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); } }
void init_tablet() // Set up variables { int i; char *devname, txt[32]; gboolean use_tablet; GList *dlist; #if GTK_MAJOR_VERSION == 1 GdkDeviceInfo *device = NULL; gint use; #endif #if GTK_MAJOR_VERSION == 2 GdkDevice *device = NULL; GdkAxisUse use; #endif use_tablet = inifile_get_gboolean( "tablet_USE", FALSE ); if ( use_tablet ) // User has got tablet working in past so try to initialize it { devname = inifile_get( tablet_ini3[0], "?" ); // Device name last used #if GTK_MAJOR_VERSION == 1 dlist = gdk_input_list_devices(); #endif #if GTK_MAJOR_VERSION == 2 dlist = gdk_devices_list(); #endif while ( dlist != NULL ) { device = dlist->data; if ( strcmp(device->name, devname ) == 0 ) { // Previously used device was found #if GTK_MAJOR_VERSION == 1 gdk_input_set_mode(device->deviceid, inifile_get_gint32( tablet_ini3[1], 0 ) ); #endif #if GTK_MAJOR_VERSION == 2 gdk_device_set_mode(device, inifile_get_gint32( tablet_ini3[1], 0 ) ); #endif for ( i=0; i<device->num_axes; i++ ) { sprintf(txt, "%s%i", tablet_ini3[2], i); use = inifile_get_gint32( txt, GDK_AXIS_IGNORE ); #if GTK_MAJOR_VERSION == 1 device->axes[i] = use; gdk_input_set_axes(device->deviceid, device->axes); #endif #if GTK_MAJOR_VERSION == 2 gdk_device_set_axis_use(device, i, use); #endif } tablet_device = device; tablet_working = TRUE; // Success! break; } dlist = dlist->next; // Not right device so look for next one } } for ( i=0; i<3; i++ ) { tablet_tool_use[i] = inifile_get_gboolean( tablet_ini2[i], FALSE ); tablet_tool_factor[i] = ((float) inifile_get_gint32( tablet_ini[i], 100 )) / 100; } }