void whiteb_show(struct Question *data) { /* Reset question picture stored in whiteb_image */ whiteb_image = NULL; /* Layout */ GtkWidget *window; GtkWidget *table, *tool_table, *viewport; /* UI */ GtkWidget *clear_board = NULL, *freeh_tool = NULL, *line_tool = NULL, *rect_tool = NULL, *circ_tool = NULL, *erase_tool = NULL, *exit_but = NULL; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window),"Powermaths Whiteboard"); gtk_window_fullscreen(GTK_WINDOW(window)); viewport = gtk_viewport_new(NULL,NULL); table = gtk_table_new(3,8,0); white_board = gtk_drawing_area_new(); gtk_widget_set_size_request(white_board,768,576); draw_init_canvas(white_board); gtk_widget_modify_bg(white_board,GTK_STATE_NORMAL,misc_create_color(65535,65535,65535)); gtk_widget_add_events(white_board,GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK); gtk_container_add(GTK_CONTAINER(viewport),white_board); tool_table = gtk_table_new(1,8,1); clear_board = gtk_button_new(); gtk_container_add(GTK_CONTAINER(clear_board),gtk_image_new_from_file("pixmaps/clear.png")); freeh_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(freeh_tool),gtk_image_new_from_file("pixmaps/freeh.png")); line_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(line_tool),gtk_image_new_from_file("pixmaps/line.png")); rect_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(rect_tool),gtk_image_new_from_file("pixmaps/square.png")); circ_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(circ_tool),gtk_image_new_from_file("pixmaps/circle.png")); erase_tool = gtk_button_new(); gtk_container_add(GTK_CONTAINER(erase_tool),gtk_image_new_from_file("pixmaps/eraser.png")); exit_but = gtk_button_new_with_label("Exit"); /* Pack */ gtk_container_add(GTK_CONTAINER(window),table); gtk_table_attach(GTK_TABLE(table),misc_create_banner(data->caption,16000),0,3,0,1,GTK_FILL|GTK_EXPAND,0,0,0); gtk_table_attach(GTK_TABLE(table),viewport,0,1,1,8,0,0,0,0); gtk_table_attach(GTK_TABLE(table),tool_table,1,2,1,8,0,GTK_FILL,0,0); gtk_table_attach(GTK_TABLE(tool_table),clear_board,0,1,1,2,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),freeh_tool,0,1,2,3,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),line_tool,0,1,3,4,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),rect_tool,0,1,4,5,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),circ_tool,0,1,5,6,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),erase_tool,0,1,6,7,GTK_FILL,0,0,0); gtk_table_attach(GTK_TABLE(tool_table),exit_but,0,1,7,8,GTK_FILL,0,0,0); /* Hook up callbacks */ g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(whiteb_window_delete),NULL); g_signal_connect(G_OBJECT(white_board),"button-press-event",G_CALLBACK(whiteb_board_press),NULL); g_signal_connect(G_OBJECT(white_board),"motion-notify-event",G_CALLBACK(whiteb_board_motion),NULL); g_signal_connect(G_OBJECT(white_board),"button-release-event",G_CALLBACK(whiteb_board_release),NULL); g_signal_connect(G_OBJECT(white_board),"expose-event",G_CALLBACK(whiteb_expose_event),data); g_signal_connect(G_OBJECT(clear_board),"clicked",G_CALLBACK(whiteb_clear),NULL); g_signal_connect(G_OBJECT(freeh_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_FREEHAND); g_signal_connect(G_OBJECT(line_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_LINE); g_signal_connect(G_OBJECT(rect_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_RECT); g_signal_connect(G_OBJECT(circ_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_CIRCLE); g_signal_connect(G_OBJECT(erase_tool),"clicked",G_CALLBACK(whiteb_change_tool),(void*)WHITEB_ERASER); g_signal_connect_swapped(G_OBJECT(exit_but),"clicked",G_CALLBACK(whiteb_window_delete),window); gtk_widget_show_all(window); }
static void ihm_VideoFullScreen(GtkWidget *widget, gpointer data) { int w,h; if (fullscreen!=NULL) { printf(" Already fullscreen\n"); return; } printf(" Go Fullscreen\n"); /* Builds the image */ fullscreen_image = (GtkImage*) gtk_image_new(); fullscreen_eventbox = gtk_event_box_new(); //align = gtk_alignment_new(0.5f,0.5f,0.0f,0.0f); /* Add three buttons on the fullscreen window */ ihm_fullScreenHBox = gtk_hbox_new(FALSE,0); ihm_fullScreenButton[0] = gtk_button_new_with_label(ihm_ImageButtonCaption[RAW_CAPTURE_BUTTON]); g_signal_connect (G_OBJECT (ihm_fullScreenButton[0]), "clicked", (GCallback)ihm_RAWCapture, NULL); gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox),ihm_fullScreenButton[0]); ihm_fullScreenButton[1] = gtk_button_new_with_label(ihm_ImageButtonCaption[ZAPPER_BUTTON]); g_signal_connect (G_OBJECT (ihm_fullScreenButton[1]), "clicked", (GCallback)ihm_Zapper, NULL); gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox),ihm_fullScreenButton[1]); ihm_fullScreenButton[2] = gtk_button_new_with_label("Quit Fullscreen"); g_signal_connect (G_OBJECT (ihm_fullScreenButton[2]), "clicked", (GCallback)ihm_QuitFullscreenRequest, NULL); gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox),ihm_fullScreenButton[2]); //ihm_fullScreenButton[3] = gtk_button_new(); // Fake button //gtk_container_add(GTK_CONTAINER (align),ihm_fullScreenHBox); /* Create window (full screen) */ fullscreen_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* the screen */ fullscreen = gtk_window_get_screen(GTK_WINDOW(fullscreen_window)); w=gdk_screen_get_width(fullscreen); h=gdk_screen_get_height(fullscreen); gtk_widget_set_size_request(GTK_WIDGET(fullscreen_window),w,h); /* The fixed container */ ihm_fullScreenFixedContainer = gtk_fixed_new(); gtk_fixed_put((GtkFixed*)(ihm_fullScreenFixedContainer),GTK_WIDGET(fullscreen_image),0,0); gtk_fixed_put((GtkFixed*)(ihm_fullScreenFixedContainer),GTK_WIDGET(ihm_fullScreenHBox),0,0); /* Build the fullscreen window with the fixed container */ gtk_container_add(GTK_CONTAINER(fullscreen_eventbox),ihm_fullScreenFixedContainer); gtk_container_add(GTK_CONTAINER(fullscreen_window),fullscreen_eventbox); gtk_window_set_decorated(GTK_WINDOW(fullscreen_window), FALSE); gtk_window_set_resizable(GTK_WINDOW(fullscreen_window), FALSE); printf("Fullscreen size : %ix%i\n",w,h); g_signal_connect (G_OBJECT (fullscreen_window), "destroy", (GCallback)ihm_VideoFullScreenStop, NULL); g_signal_connect (fullscreen_eventbox, "motion_notify_event", (GCallback)ihm_VideoFullScreenMouseMove, NULL); gtk_widget_add_events(fullscreen_eventbox,GDK_POINTER_MOTION_MASK); gtk_window_fullscreen(GTK_WINDOW(fullscreen_window)); gtk_widget_show_all (GTK_WIDGET(fullscreen_window)); gtk_widget_hide(ihm_fullScreenHBox); //gtk_widget_get_size_request(ihm_fullScreenHBox,&w2,&h2); //printf("Fullscreen size2 : %ix%i %ix%i\n",w,h,w2,h2); //gtk_fixed_put(ihm_fullScreenFixedContainer,ihm_fullScreenHBox,0,h-30); if (!flag_timer_is_active){ g_timeout_add(1000, (GtkFunction)hide_fullscreen_buttons, NULL ); flag_timer_is_active=1; } }
static gboolean egg_tray_manager_manage_xscreen (EggTrayManager *manager, Screen *xscreen) { GtkWidget *invisible; char *selection_atom_name; guint32 timestamp; GdkScreen *screen; GdkWindow *window; g_return_val_if_fail (EGG_IS_TRAY_MANAGER (manager), FALSE); g_return_val_if_fail (manager->screen == NULL, FALSE); /* If there's already a manager running on the screen * we can't create another one. */ #if 0 if (egg_tray_manager_check_running_xscreen (xscreen)) return FALSE; #endif screen = gdk_display_get_screen (gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen)), XScreenNumberOfScreen (xscreen)); invisible = gtk_invisible_new_for_screen (screen); gtk_widget_realize (invisible); window = gtk_widget_get_window (GTK_WIDGET(invisible)); gtk_widget_add_events (invisible, GDK_PROPERTY_CHANGE_MASK | GDK_STRUCTURE_MASK); selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d", XScreenNumberOfScreen (xscreen)); manager->selection_atom = XInternAtom (DisplayOfScreen (xscreen), selection_atom_name, False); g_free (selection_atom_name); timestamp = gdk_x11_get_server_time (gtk_widget_get_window (invisible)); XSetSelectionOwner (DisplayOfScreen (xscreen), manager->selection_atom, GDK_WINDOW_XID (gtk_widget_get_window (invisible)), timestamp); /* Check if we were could set the selection owner successfully */ if (XGetSelectionOwner (DisplayOfScreen (xscreen), manager->selection_atom) == GDK_WINDOW_XID (gtk_widget_get_window (invisible))) { XClientMessageEvent xev; xev.type = ClientMessage; xev.window = RootWindowOfScreen (xscreen); xev.message_type = XInternAtom (DisplayOfScreen (xscreen), "MANAGER", False); xev.format = 32; xev.data.l[0] = timestamp; xev.data.l[1] = manager->selection_atom; xev.data.l[2] = GDK_WINDOW_XID (gtk_widget_get_window (invisible)); xev.data.l[3] = 0; /* manager specific data */ xev.data.l[4] = 0; /* manager specific data */ XSendEvent (DisplayOfScreen (xscreen), RootWindowOfScreen (xscreen), False, StructureNotifyMask, (XEvent *)&xev); manager->invisible = invisible; g_object_ref (G_OBJECT (manager->invisible)); manager->opcode_atom = XInternAtom (DisplayOfScreen (xscreen), "_NET_SYSTEM_TRAY_OPCODE", False); manager->message_data_atom = XInternAtom (DisplayOfScreen (xscreen), "_NET_SYSTEM_TRAY_MESSAGE_DATA", False); /* Add a window filter */ gdk_window_add_filter (gtk_widget_get_window (invisible), egg_tray_manager_window_filter, manager); return TRUE; } else { gtk_widget_destroy (invisible); return FALSE; } }
int main (int argc, char *argv[]) { set_log_handlers(); wf_debug = 0; memset(&app, 0, sizeof(app)); gtk_init(&argc, &argv); if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){ gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE; } GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); canvas = gtk_drawing_area_new(); #ifdef HAVE_GTK_2_18 gtk_widget_set_can_focus (canvas, true); #endif gtk_widget_set_size_request (canvas, 480, 64); gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE); gtk_widget_add_events (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas); g_signal_connect((gpointer)canvas, "realize", G_CALLBACK(on_canvas_realise), NULL); g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL); g_signal_connect((gpointer)canvas, "expose_event", G_CALLBACK(on_expose), NULL); gtk_widget_show_all(window); gboolean key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data) { switch(event->keyval){ case 61: start_zoom(zoom * 1.5); break; case 45: start_zoom(zoom / 1.5); break; case KEY_Left: case KEY_KP_Left: dbg(0, "left"); break; case KEY_Right: case KEY_KP_Right: dbg(0, "right"); break; case (char)'a': toggle_animate(); break; case GDK_KP_Enter: break; case 113: exit(EXIT_SUCCESS); break; case GDK_Delete: break; default: dbg(0, "%i", event->keyval); break; } return TRUE; } g_signal_connect(window, "key-press-event", G_CALLBACK(key_press), NULL); gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){ gtk_main_quit(); return false; }
static GObject * ephy_fullscreen_popup_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; EphyFullscreenPopup *popup; EphyFullscreenPopupPrivate *priv; GtkWindow *window; GtkWidget *hbox, *frame_hbox, *icon; object = G_OBJECT_CLASS (ephy_fullscreen_popup_parent_class)->constructor (type, n_construct_properties, construct_params); window = GTK_WINDOW (object); popup = EPHY_FULLSCREEN_POPUP (window); priv = popup->priv; gtk_window_set_resizable (window, FALSE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_widget_show (hbox); /* frame */ priv->frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (priv->frame), GTK_SHADOW_OUT); gtk_box_pack_start (GTK_BOX (hbox), priv->frame, FALSE, FALSE, 0); frame_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_container_add (GTK_CONTAINER (priv->frame), frame_hbox); gtk_widget_show (frame_hbox); /* lock */ priv->lock = gtk_image_new (); gtk_widget_show (priv->lock); priv->lock_ebox = gtk_event_box_new (); gtk_event_box_set_visible_window (GTK_EVENT_BOX (priv->lock_ebox), FALSE); gtk_widget_add_events (priv->lock_ebox, GDK_BUTTON_PRESS_MASK); g_signal_connect (priv->lock_ebox, "button-press-event", G_CALLBACK (lock_button_press_cb), popup); gtk_container_add (GTK_CONTAINER (priv->lock_ebox), priv->lock); gtk_box_pack_start (GTK_BOX (frame_hbox), priv->lock_ebox, FALSE, FALSE, 0); gtk_widget_show (priv->lock_ebox); /* exit button */ priv->button = gtk_button_new_with_label (_("Leave Fullscreen")); icon = gtk_image_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (priv->button), icon); /* don't show the image! see bug #307818 */ g_signal_connect (priv->button, "clicked", G_CALLBACK (exit_button_clicked_cb), popup); gtk_box_pack_start (GTK_BOX (hbox), priv->button, FALSE, FALSE, 0); gtk_widget_show (priv->button); ephy_fullscreen_popup_update_visibility (popup); return object; }
/** * Creates the windows and other objects required to do calibration * under GTK. When the window is closed (timed out, calibration finished * or user cancellation), callback will be called, where you should call * calib_area_finish(). */ CalibArea * calib_area_new (GdkScreen *screen, int monitor, int device_id, FinishCallback callback, gpointer user_data, XYinfo *old_axis, int threshold_doubleclick, int threshold_misclick) { CalibArea *calib_area; GdkRectangle rect; GdkWindow *window; GdkRGBA black; #ifndef FAKE_AREA GdkCursor *cursor; #endif /* FAKE_AREA */ g_return_val_if_fail (old_axis, NULL); g_return_val_if_fail (callback, NULL); g_debug ("Current calibration: %d, %d, %d, %d\n", old_axis->x_min, old_axis->y_min, old_axis->x_max, old_axis->y_max); calib_area = g_new0 (CalibArea, 1); calib_area->callback = callback; calib_area->user_data = user_data; calib_area->device_id = device_id; calib_area->calibrator.old_axis.x_min = old_axis->x_min; calib_area->calibrator.old_axis.x_max = old_axis->x_max; calib_area->calibrator.old_axis.y_min = old_axis->y_min; calib_area->calibrator.old_axis.y_max = old_axis->y_max; calib_area->calibrator.threshold_doubleclick = threshold_doubleclick; calib_area->calibrator.threshold_misclick = threshold_misclick; /* Set up the window */ calib_area->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_app_paintable (GTK_WIDGET (calib_area->window), TRUE); /* Black background */ gdk_rgba_parse (&black, "rgb(0,0,0)"); gtk_widget_set_opacity (GTK_WIDGET (calib_area->window), WINDOW_OPACITY); gtk_widget_realize (calib_area->window); window = gtk_widget_get_window (calib_area->window); gdk_window_set_background_rgba (window, &black); #ifndef FAKE_AREA /* No cursor (unless we're faking the area which might be convenient) */ cursor = gdk_cursor_new (GDK_BLANK_CURSOR); gdk_window_set_cursor (window, cursor); g_object_unref (cursor); #endif /* FAKE_AREA */ /* Listen for mouse events */ gtk_widget_add_events (calib_area->window, GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK); gtk_widget_set_can_focus (calib_area->window, TRUE); gtk_window_fullscreen (GTK_WINDOW (calib_area->window)); gtk_window_set_keep_above (GTK_WINDOW (calib_area->window), TRUE); /* Connect callbacks */ g_signal_connect (calib_area->window, "draw", G_CALLBACK(draw), calib_area); g_signal_connect (calib_area->window, "button-press-event", G_CALLBACK(on_button_press_event), calib_area); g_signal_connect (calib_area->window, "key-release-event", G_CALLBACK(on_key_release_event), calib_area); g_signal_connect (calib_area->window, "delete-event", G_CALLBACK(on_delete_event), calib_area); g_signal_connect (calib_area->window, "focus-out-event", G_CALLBACK(on_focus_out_event), calib_area); /* Setup timer for animation */ calib_area->anim_id = g_timeout_add(TIME_STEP, (GSourceFunc)on_timer_signal, calib_area); /* Move to correct screen */ if (screen == NULL) screen = gdk_screen_get_default (); gdk_screen_get_monitor_geometry (screen, monitor, &rect); gtk_window_move (GTK_WINDOW (calib_area->window), rect.x, rect.y); gtk_window_set_default_size (GTK_WINDOW (calib_area->window), rect.width, rect.height); calib_area->calibrator.geometry.x = rect.x; calib_area->calibrator.geometry.y = rect.y; calib_area->calibrator.geometry.width = rect.width; calib_area->calibrator.geometry.height = rect.height; gtk_widget_show_all (calib_area->window); return calib_area; }
void gui_init (dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_vbox_new(TRUE, 5); gtk_widget_set_size_request(self->widget,100,-1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL); g_signal_connect(G_OBJECT (d->current), "row-activated", G_CALLBACK (detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); dt_gui_key_accel_block_on_focus (w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT (w), "activate", G_CALLBACK (entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w,-1,100); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL); g_signal_connect(G_OBJECT (d->related), "row-activated", G_CALLBACK (attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (delete_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); set_keyword(self, d); }
static void ol_scroll_window_init (OlScrollWindow *self) { /*basic*/ self->percentage = 0.0; self->whole_lyrics = NULL; self->current_lyric_id = -1; /*privat data*/ OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (self); priv->line_count = DEFAULT_LINE_COUNT; priv->active_color = DEFAULT_ACTIVE_COLOR; priv->inactive_color = DEFAULT_INACTIVE_COLOR; priv->bg_color = DEFAULT_BG_COLOR; priv->font_name = g_strdup (DEFAULT_FONT_NAME); priv->line_margin = DEFAULT_LINE_MARGIN; priv->padding_x = DEFAULT_PADDING_X; priv->padding_y = DEFAULT_PADDING_Y; priv->corner_radius = DEFAULT_CORNER_RADIUS; priv->bg_opacity = DEFAULT_BG_OPACITY; priv->frame_width = DEFAULT_FRAME_WIDTH; priv->text = NULL; priv->scroll_mode = OL_SCROLL_WINDOW_ALWAYS; priv->can_seek = FALSE; priv->seeking = FALSE; /*set allocation*/ gtk_window_resize(GTK_WINDOW(self), DEFAULT_WIDTH, DEFAULT_HEIGHT); gtk_widget_add_events (GTK_WIDGET (self), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_DESTROY); /* Set RGBA Colormap */ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (self)); GdkColormap* colormap = gdk_screen_get_rgba_colormap (screen); if (colormap == NULL) colormap = gdk_screen_get_rgb_colormap (screen); gtk_widget_set_colormap (GTK_WIDGET (self), colormap); gtk_window_set_decorated (GTK_WINDOW(self), FALSE); gtk_widget_set_app_paintable (GTK_WIDGET (self), TRUE); /* We need an additional widget to paint on */ priv->window_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_widget_set_redraw_on_allocate(priv->window_container, TRUE); gtk_container_add (GTK_CONTAINER (self), priv->window_container); /* Set toolbar container */ priv->toolbar_container = GTK_CONTAINER (gtk_alignment_new (1.0, 0.0, 0.0, 0.0)); gtk_alignment_set_padding (GTK_ALIGNMENT (priv->toolbar_container), priv->padding_x, priv->padding_x, priv->padding_x, priv->padding_x); gtk_container_add (GTK_CONTAINER (priv->window_container), GTK_WIDGET (priv->toolbar_container)); gtk_widget_show_all (priv->window_container); /* Set tooltips */ ol_scroll_window_update_tooltip (self); /* Connect signals */ g_signal_connect (G_OBJECT (priv->window_container), "expose-event", G_CALLBACK (ol_scroll_window_expose), self); g_signal_connect (G_OBJECT (self), "button-press-event", G_CALLBACK (ol_scroll_window_button_press), self); g_signal_connect (G_OBJECT (self), "button-release-event", G_CALLBACK (ol_scroll_window_button_release), self); g_signal_connect (G_OBJECT (self), "motion-notify-event", G_CALLBACK (ol_scroll_window_motion_notify), self); }
/* Initialize the widgets in a newly allocated DiskOverview. */ static void anaconda_disk_overview_init(AnacondaDiskOverview *widget) { char *markup; widget->priv = G_TYPE_INSTANCE_GET_PRIVATE(widget, ANACONDA_TYPE_DISK_OVERVIEW, AnacondaDiskOverviewPrivate); gtk_widget_set_valign(GTK_WIDGET(widget), GTK_ALIGN_CENTER); /* Allow tabbing from one DiskOverview to the next. */ gtk_widget_set_can_focus(GTK_WIDGET(widget), TRUE); gtk_widget_add_events(GTK_WIDGET(widget), GDK_FOCUS_CHANGE_MASK|GDK_KEY_RELEASE_MASK); g_signal_connect(widget, "focus-in-event", G_CALLBACK(anaconda_disk_overview_focus_changed), NULL); g_signal_connect(widget, "focus-out-event", G_CALLBACK(anaconda_disk_overview_focus_changed), NULL); /* Set "hand" cursor shape when over the selector */ widget->priv->cursor = gdk_cursor_new(GDK_HAND2); g_signal_connect(widget, "realize", G_CALLBACK(anaconda_disk_overview_realize), NULL); /* Set some properties. */ widget->priv->chosen = FALSE; /* Create the grid. */ widget->priv->grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(widget->priv->grid), 6); gtk_grid_set_column_spacing(GTK_GRID(widget->priv->grid), 6); gtk_container_set_border_width(GTK_CONTAINER(widget->priv->grid), 6); /* Create the capacity label. */ widget->priv->capacity_label = gtk_label_new(NULL); markup = g_markup_printf_escaped("<span size='large'>%s</span>", _(DEFAULT_CAPACITY)); gtk_label_set_markup(GTK_LABEL(widget->priv->capacity_label), markup); g_free(markup); /* Create the spoke's icon. */ set_icon(widget, DEFAULT_KIND); /* Create the description label. */ widget->priv->description_label = gtk_label_new(NULL); markup = g_markup_printf_escaped("<span weight='bold' size='large'>%s</span>", _(DEFAULT_DESCRIPTION)); gtk_label_set_markup(GTK_LABEL(widget->priv->description_label), markup); g_free(markup); /* Create the name label. */ widget->priv->name_label = gtk_label_new(NULL); gtk_widget_set_halign(widget->priv->name_label, GTK_ALIGN_END); /* Create the free space label. */ widget->priv->free_label = gtk_label_new(NULL); gtk_widget_set_halign(widget->priv->free_label, GTK_ALIGN_START); markup = g_markup_printf_escaped("<span size='large'>%s</span>", _(DEFAULT_FREE)); gtk_label_set_markup(GTK_LABEL(widget->priv->capacity_label), markup); g_free(markup); /* Add everything to the grid, add the grid to the widget. */ gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->capacity_label, 0, 0, 3, 1); gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->kind_icon, 0, 1, 3, 1); gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->description_label, 0, 2, 3, 1); gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->name_label, 0, 3, 1, 1); gtk_grid_attach(GTK_GRID(widget->priv->grid), gtk_label_new("/"), 1, 3, 1, 1); gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->free_label, 2, 3, 1, 1); gtk_container_add(GTK_CONTAINER(widget), widget->priv->grid); /* We need to handle button-press-event in order to change the background color. */ g_signal_connect(widget, "button-press-event", G_CALLBACK(anaconda_disk_overview_clicked), NULL); /* And this one is to handle when you select a DiskOverview via keyboard. */ g_signal_connect(widget, "key-release-event", G_CALLBACK(anaconda_disk_overview_clicked), NULL); }
void gui_init (dt_lib_module_t *self) { dt_lib_collect_t *d = (dt_lib_collect_t *)malloc(sizeof(dt_lib_collect_t)); self->data = (void *)d; self->widget = gtk_vbox_new(FALSE, 5); gtk_widget_set_size_request(self->widget, 100, -1); d->active_rule = 0; d->params = (dt_lib_collect_params_t*)malloc(sizeof(dt_lib_collect_params_t)); dt_control_signal_connect(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED, G_CALLBACK(collection_updated), self); GtkBox *box; GtkWidget *w; GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); GtkTreeView *view = GTK_TREE_VIEW(gtk_tree_view_new()); d->view = view; GtkListStore *liststore; for(int i=0; i<MAX_RULES; i++) { d->rule[i].num = i; box = GTK_BOX(gtk_hbox_new(FALSE, 5)); d->rule[i].hbox = GTK_WIDGET(box); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_combo_box_new_text(); d->rule[i].combo = GTK_COMBO_BOX(w); for(int k=0; k<dt_lib_collect_string_cnt; k++) gtk_combo_box_append_text(GTK_COMBO_BOX(w), _(dt_lib_collect_string[k])); g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(combo_changed), d->rule + i); gtk_box_pack_start(box, w, FALSE, FALSE, 0); w = gtk_entry_new(); dt_gui_key_accel_block_on_focus(w); d->rule[i].text = w; gtk_widget_add_events(w, GDK_FOCUS_CHANGE_MASK); g_signal_connect(G_OBJECT(w), "focus-in-event", G_CALLBACK(entry_focus_in_callback), d->rule + i); /* xgettext:no-c-format */ g_object_set(G_OBJECT(w), "tooltip-text", _("type your query, use `%' as wildcard"), (char *)NULL); gtk_widget_add_events(w, GDK_KEY_PRESS_MASK); g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(changed_callback), d->rule + i); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), d->rule + i); gtk_box_pack_start(box, w, TRUE, TRUE, 0); w = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); d->rule[i].button = w; gtk_widget_set_events(w, GDK_BUTTON_PRESS_MASK); g_signal_connect(G_OBJECT(w), "button-press-event", G_CALLBACK(popup_button_callback), d->rule + i); gtk_box_pack_start(box, w, FALSE, FALSE, 0); gtk_widget_set_size_request(w, 13, 13); } d->scrolledwindow = GTK_SCROLLED_WINDOW(sw); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(view)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(sw), TRUE, TRUE, 0); gtk_tree_view_set_headers_visible(view, FALSE); liststore = gtk_list_store_new(DT_LIB_COLLECT_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(view, col); gtk_widget_set_size_request(GTK_WIDGET(view), -1, 300); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_COLLECT_COL_TEXT); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(view, GTK_TREE_MODEL(liststore)); g_signal_connect(G_OBJECT (view), "row-activated", G_CALLBACK (row_activated), d); /* setup proxy */ darktable.view_manager->proxy.module_collect.module = self; darktable.view_manager->proxy.module_collect.update = _lib_collect_gui_update; _lib_collect_gui_update(self); }
GtkWidget * task_item_new (WnckWindow *window) { GtkWidget *item = NULL; TaskItem *task; TaskItemPrivate *priv; WnckScreen *screen; g_return_val_if_fail (WNCK_IS_WINDOW (window), item); item = g_object_new (TASK_TYPE_ITEM, "has-tooltip", TRUE, "visible-window", FALSE, "above-child", TRUE, NULL); gtk_widget_add_events (item, GDK_ALL_EVENTS_MASK); gtk_container_set_border_width (GTK_CONTAINER (item), 0); task = TASK_ITEM (item); priv = task->priv; priv->window = window; screen = wnck_window_get_screen (window); priv->screen = screen; gtk_drag_dest_set (item, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets (item); gtk_drag_dest_add_text_targets (item); g_signal_connect (item, "drag-motion", G_CALLBACK (on_drag_motion), NULL); g_signal_connect (item, "drag-leave", G_CALLBACK (on_drag_leave), NULL); g_signal_connect (screen, "viewports-changed", G_CALLBACK (on_screen_active_viewport_changed), item); g_signal_connect (screen, "active-window-changed", G_CALLBACK (on_screen_active_window_changed), item); g_signal_connect (screen, "active-workspace-changed", G_CALLBACK (on_screen_active_workspace_changed), item); g_signal_connect (screen, "window-closed", G_CALLBACK (on_screen_window_closed), item); g_signal_connect (window, "workspace-changed", G_CALLBACK (on_window_workspace_changed), item); g_signal_connect (window, "state-changed", G_CALLBACK (on_window_state_changed), item); g_signal_connect (window, "icon-changed", G_CALLBACK (on_window_icon_changed), item); g_signal_connect (item, "button-release-event", G_CALLBACK (on_task_item_button_released), item); g_signal_connect (item, "button-press-event", G_CALLBACK (on_button_pressed), item); g_signal_connect (item, "size-allocate", G_CALLBACK (on_size_allocate), item); g_signal_connect (item, "query-tooltip", G_CALLBACK (on_query_tooltip), item); g_signal_connect (item, "enter-notify-event", G_CALLBACK (on_enter_notify), item); g_signal_connect (item, "leave-notify-event", G_CALLBACK (on_leave_notify), item); g_signal_connect (item, "drag-motion", G_CALLBACK (on_drag_motion), item); g_signal_connect (item, "drag-leave", G_CALLBACK (on_drag_leave), item); task_item_set_visibility (task); task_item_setup_atk (task); return item; }
bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& sizeOrig, long style, const wxString &name ) { // always create a frame of some reasonable, even if arbitrary, size (at // least for MSW compatibility) wxSize size = sizeOrig; size.x = WidthDefault(size.x); size.y = HeightDefault(size.y); wxTopLevelWindows.Append( this ); if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") ); return false; } m_title = title; // NB: m_widget may be !=NULL if it was created by derived class' Create, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 // we must create HildonWindow and not a normal GtkWindow as the latter // doesn't look correctly in Maemo environment and it must also be // registered with the main program object m_widget = hildon_window_new(); hildon_program_add_window(wxTheApp->GetHildonProgram(), HILDON_WINDOW(m_widget)); #else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { // Tell WM that this is a dialog window and make it center // on parent by default (this is what GtkDialog ctor does): gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(m_widget), GTK_WIN_POS_CENTER_ON_PARENT); } else { if (style & wxFRAME_TOOL_WINDOW) { gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_UTILITY); // On some WMs, like KDE, a TOOL_WINDOW will still show // on the taskbar, but on Gnome a TOOL_WINDOW will not. // For consistency between WMs and with Windows, we // should set the NO_TASKBAR flag which will apply // the set_skip_taskbar_hint if it is available, // ensuring no taskbar entry will appear. style |= wxFRAME_NO_TASKBAR; } } #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2 g_object_ref(m_widget); } wxWindow *topParent = wxGetTopLevelParent(m_parent); if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || (style & wxFRAME_FLOAT_ON_PARENT))) { gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(topParent->m_widget) ); } if (style & wxFRAME_NO_TASKBAR) { gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } if (style & wxSTAY_ON_TOP) { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } if (style & wxMAXIMIZE) gtk_window_maximize(GTK_WINDOW(m_widget)); #if 0 if (!name.empty()) gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) ); #endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); gtk_widget_set_can_focus(m_widget, false); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) m_mainWidget = gtk_vbox_new(false, 0); gtk_widget_show( m_mainWidget ); gtk_widget_set_can_focus(m_mainWidget, false); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); // m_wxwindow is the client area m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow ); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes gtk_widget_set_can_focus(m_wxwindow, false); if (m_parent) m_parent->AddChild( this ); g_signal_connect(m_wxwindow, "size_allocate", G_CALLBACK(size_allocate), this); PostCreation(); #ifndef __WXGTK3__ if ((m_x != -1) || (m_y != -1)) gtk_widget_set_uposition( m_widget, m_x, m_y ); #endif // for some reported size corrections g_signal_connect (m_widget, "map_event", G_CALLBACK (gtk_frame_map_callback), this); // for iconized state g_signal_connect (m_widget, "window_state_event", G_CALLBACK (gtk_frame_window_state_callback), this); // for wxMoveEvent g_signal_connect (m_widget, "configure_event", G_CALLBACK (gtk_frame_configure_callback), this); // activation g_signal_connect_after (m_widget, "focus_in_event", G_CALLBACK (gtk_frame_focus_in_callback), this); g_signal_connect_after (m_widget, "focus_out_event", G_CALLBACK (gtk_frame_focus_out_callback), this); gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); g_signal_connect(m_widget, "property_notify_event", G_CALLBACK(property_notify_event), this); // translate wx decorations styles into Motif WM hints (they are recognized // by other WMs as well) // always enable moving the window as we have no separate flag for enabling // it m_gdkFunc = GDK_FUNC_MOVE; if ( style & wxCLOSE_BOX ) m_gdkFunc |= GDK_FUNC_CLOSE; if ( style & wxMINIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MAXIMIZE; if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) ) { m_gdkDecor = 0; } else // have border { m_gdkDecor = GDK_DECOR_BORDER; if ( style & wxCAPTION ) m_gdkDecor |= GDK_DECOR_TITLE; if ( style & wxSYSTEM_MENU ) m_gdkDecor |= GDK_DECOR_MENU; if ( style & wxMINIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MAXIMIZE; if ( style & wxRESIZE_BORDER ) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } // GTK sometimes chooses very small size if max size hint is not explicitly set DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight); m_decorSize = GetCachedDecorSize(); int w, h; GTKDoGetSize(&w, &h); gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); return true; }
CoglOnscreen* ImGui_ImplGtk3Cogl_Init(GtkWidget* widget, void (*callback)(CoglOnscreen *onscreen, void *data), void *data) { g_clear_pointer(&g_GtkWidget, g_object_unref); g_clear_pointer(&g_GdkWindow, g_object_unref); g_clear_pointer(&g_Framebuffer, cogl_object_unref); g_clear_pointer(&g_Context, cogl_object_unref); g_GtkWidget = GTK_WIDGET(g_object_ref(widget)); gtk_widget_realize(widget); GdkWindow *parent_window = gtk_widget_get_window(widget); GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); g_Callbacks = get_backend_callbacks(parent_window); GdkWindowAttr attributes; memset(&attributes, 0, sizeof(attributes)); attributes.x = 0; attributes.y = 0; attributes.width = allocation.width; attributes.height = allocation.height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.window_type = g_Callbacks->winsys == COGL_WINSYS_ID_EGL_WAYLAND ? GDK_WINDOW_SUBSURFACE : GDK_WINDOW_CHILD; GdkDisplay *display = gdk_window_get_display(parent_window); attributes.visual = gtk_widget_get_visual(widget); g_GdkWindow = gdk_window_new(parent_window, &attributes, GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL); gdk_window_set_transient_for(g_GdkWindow, parent_window); gdk_window_set_pass_through(g_GdkWindow, TRUE); cairo_rectangle_int_t empty_rect; memset(&empty_rect, 0, sizeof(empty_rect)); cairo_region_t *input_region = cairo_region_create_rectangle(&empty_rect); gdk_window_input_shape_combine_region(g_GdkWindow, input_region, 0, 0); cairo_region_destroy(input_region); cairo_region_t *region = get_window_region(g_GdkWindow); gdk_window_set_opaque_region(g_GdkWindow, region); cairo_region_destroy(region); CoglRenderer *renderer = cogl_renderer_new(); cogl_renderer_set_winsys_id(renderer, g_Callbacks->winsys); g_Callbacks->init(renderer, display, g_GdkWindow); gdk_window_ensure_native(g_GdkWindow); g_Context = cogl_context_new(cogl_display_new(renderer, NULL), NULL); CoglOnscreen *onscreen = cogl_onscreen_new(g_Context, 1, 1); cogl_object_unref(renderer); g_Callbacks->resize(g_GdkWindow, onscreen, allocation.width, allocation.height, allocation.x, allocation.y); gtk_widget_add_events(widget, EVENT_MASK); g_signal_connect(widget, "event", G_CALLBACK(handle_gdk_event), NULL); g_signal_connect(widget, "size-allocate", G_CALLBACK(handle_allocate), NULL); g_Callbacks->set_window(onscreen, g_GdkWindow); if (!cogl_framebuffer_allocate(COGL_FRAMEBUFFER(onscreen), NULL)) g_warning("Unable to allocate framebuffer"); g_Framebuffer = COGL_FRAMEBUFFER(onscreen); ImGuiIO& io = ImGui::GetIO(); for (int i = 0; i < ImGuiKey_COUNT; i++) { io.KeyMap[i] = i; } io.SetClipboardTextFn = ImGui_ImplGtk3Cogl_SetClipboardText; io.GetClipboardTextFn = ImGui_ImplGtk3Cogl_GetClipboardText; io.ClipboardUserData = gtk_widget_get_clipboard(g_GtkWidget, GDK_SELECTION_CLIPBOARD); g_Callback = callback; g_CallbackData = data; GdkFrameClock *clock = gdk_window_get_frame_clock(g_GdkWindow); g_signal_connect(clock, "paint", G_CALLBACK(handle_repaint), NULL); gdk_frame_clock_request_phase(clock, GDK_FRAME_CLOCK_PHASE_PAINT); gdk_window_show(g_GdkWindow); return COGL_ONSCREEN(g_Framebuffer); }
static void colorsel_water_init (ColorselWater *water) { GtkWidget *hbox; GtkWidget *area; GtkWidget *frame; GtkObject *adj; GtkWidget *scale; water->pressure_adjust = 1.0; hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (water), hbox, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); area = gtk_drawing_area_new (); gtk_container_add (GTK_CONTAINER (frame), area); g_signal_connect (area, "expose-event", G_CALLBACK (select_area_expose), NULL); /* Event signals */ g_signal_connect (area, "motion-notify-event", G_CALLBACK (motion_notify_event), water); g_signal_connect (area, "button-press-event", G_CALLBACK (button_press_event), water); g_signal_connect (area, "proximity-out-event", G_CALLBACK (proximity_out_event), water); gtk_widget_add_events (area, 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 (area, GDK_EXTENSION_EVENTS_ALL); gtk_widget_grab_focus (area); adj = gtk_adjustment_new (200.0 - water->pressure_adjust * 100.0, 0.0, 200.0, 1.0, 1.0, 0.0); g_signal_connect (adj, "value-changed", G_CALLBACK (pressure_adjust_update), water); scale = gtk_vscale_new (GTK_ADJUSTMENT (adj)); gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gimp_help_set_help_data (scale, _("Pressure"), NULL); gtk_box_pack_start (GTK_BOX (hbox), scale, FALSE, FALSE, 0); gtk_widget_show_all (hbox); }
int main(int argc, char **argv){ GtkBuilder *builder = NULL; GError *error = NULL; GtkWidget *main_window = NULL; GtkWidget *main_screen = NULL; GtkWidget *button_list[MAX_BUTTON]; GtkWidget *led_list[MAX_LEDS]; #ifndef TRUE_COLOR guint32 virtual_color[256]; #endif // init_sighandler(); //init gtk context gtk_init(&argc, &argv); gdk_rgb_init(); //init color palette #ifndef TRUE_COLOR virtual_palette_set((unsigned int *)virtual_color); V_CPU.cmap = gdk_rgb_cmap_new(virtual_color, 256); #endif builder = gtk_builder_new(); //load UI from file. If error occurs, report it and quit application. if(!gtk_builder_add_from_file(builder, UI_FILE, &error)) { g_warning("%s", error->message); g_free(error); return -1; } // gtk_builder_connect_signals(builder,NULL); //create main_window and configure it main_screen an buttonq main_window = GTK_WIDGET(gtk_builder_get_object(builder,"main_window")); gtk_signal_connect(GTK_OBJECT (main_window), "delete_event", GTK_SIGNAL_FUNC(destroy),NULL); //create main screen and configure it main_screen = GTK_WIDGET(gtk_builder_get_object(builder,"main_screen")); //gtk_drawing_area_size(GTK_DRAWING_AREA(main_screen), SCREEN_XRES, SCREEN_YRES); gtk_signal_connect(GTK_OBJECT (main_screen), "expose_event", GTK_SIGNAL_FUNC(on_darea_expose),NULL); //refresh screen rate 75 ms gtk_timeout_add(75, Repaint,(gpointer)main_screen); //read kb layout provide by user interface virtual_kb_create_button(builder,button_list,MAX_BUTTON,kb_layout,read_kb); //create radio button provide by user interface virtual_leds_create_radio_button(builder,led_list,MAX_LEDS); //add stdin in watch descriptor V_CPU.gui_event = gio_watch; V_CPU.gui_event[0].watch = (void*)g_io_channel_unix_new(0); g_io_add_watch((GIOChannel *)V_CPU.gui_event[0].watch,G_IO_IN, (GIOFunc)gio_watch[0].func,0); gtk_widget_add_events(main_screen, GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK); gtk_widget_show(main_window); //destroy builder, since we don't need it anymore g_object_unref(G_OBJECT(builder)); //init hardware init_hardware((void *)&V_CPU); //wait for pipe ready if(load_pipe()<0) { return -1; } //main gtk loop gtk_main(); return 0; }
/************************************************************************** Creates a new dialog. It will be a tab or a window depending on the current user setting of 'gui_gtk2_enable_tabs'. Sets pdlg to point to the dialog once it is create, Zeroes pdlg on dialog destruction. user_data will be passed through response function check_top indicates if the layout deision should depend on the parent. **************************************************************************/ void gui_dialog_new(struct gui_dialog **pdlg, GtkNotebook *notebook, gpointer user_data, bool check_top) { struct gui_dialog *dlg; GtkWidget *vbox, *action_area; static int dialog_id_counter; dlg = fc_malloc(sizeof(*dlg)); dialog_list = g_list_prepend(dialog_list, dlg); dlg->source = pdlg; *pdlg = dlg; dlg->user_data = user_data; dlg->title = NULL; dlg->default_width = 200; dlg->default_height = 300; if (gui_gtk2_enable_tabs) { dlg->type = GUI_DIALOG_TAB; } else { dlg->type = GUI_DIALOG_WINDOW; } if (!gui_action) { gui_action = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL); } dlg->gui_button = gtk_size_group_new(GTK_SIZE_GROUP_BOTH); if (gui_gtk2_enable_tabs && (check_top && notebook != GTK_NOTEBOOK(top_notebook)) && !gui_gtk2_small_display_layout) { /* We expect this to be short (as opposed to tall); maximise usable * height by putting buttons down the right hand side */ vbox = gtk_hbox_new(FALSE, 0); action_area = gtk_vbox_new(FALSE, 2); } else { /* We expect this to be reasonably tall; maximise usable width by * putting buttons along the bottom */ vbox = gtk_vbox_new(FALSE, 0); action_area = gtk_hbox_new(FALSE, 2); } gtk_widget_show(vbox); gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0); gtk_widget_show(action_area); gtk_container_set_border_width(GTK_CONTAINER(vbox), 2); gtk_box_set_spacing(GTK_BOX(action_area), 4); gtk_container_set_border_width(GTK_CONTAINER(action_area), 2); switch (dlg->type) { case GUI_DIALOG_WINDOW: { GtkWidget *window; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(window, "Freeciv"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE); setup_dialog(window, toplevel); gtk_container_add(GTK_CONTAINER(window), vbox); dlg->v.window = window; g_signal_connect(window, "delete_event", G_CALLBACK(gui_dialog_delete_handler), dlg); } break; case GUI_DIALOG_TAB: { GtkWidget *hbox, *label, *image, *button, *event_box; gint w, h; char buf[256]; gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &w, &h); hbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_misc_set_padding(GTK_MISC(label), 4, 0); gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gui_dialog_delete_tab_handler), dlg); fc_snprintf(buf, sizeof(buf), _("Close Tab:\n%s"), _("Ctrl+W")); gtk_tooltips_set_tip(main_tips, button, buf, ""); image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_widget_set_size_request(button, w, h); gtk_container_add(GTK_CONTAINER(button), image); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_show_all(hbox); event_box = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(event_box), hbox); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, event_box); dlg->v.tab.handler_id = g_signal_connect(notebook, "switch_page", G_CALLBACK(gui_dialog_switch_page_handler), dlg); dlg->v.tab.child = vbox; dlg->v.tab.label = label; dlg->v.tab.notebook = GTK_WIDGET(notebook); gtk_widget_add_events(event_box, GDK_BUTTON2_MOTION_MASK); g_signal_connect(event_box, "button-press-event", G_CALLBACK(click_on_tab_callback), dlg); } break; } dlg->vbox = vbox; dlg->action_area = action_area; dlg->response_callback = gui_dialog_destroyed; dlg->id = dialog_id_counter; dialog_id_counter++; dlg->return_dialog_id = -1; g_signal_connect(vbox, "destroy", G_CALLBACK(gui_dialog_destroy_handler), dlg); g_signal_connect(vbox, "key_press_event", G_CALLBACK(gui_dialog_key_press_handler), dlg); g_object_set_data(G_OBJECT(vbox), "gui-dialog-data", dlg); }
int GCcreatewidget(Gwidget_t * parent, Gwidget_t * widget, int attrn, Gwattr_t * attrp) { PIXsize_t ps; int width, height; int ai, i; GdkGCValues gcv; int r, g, b, color; GdkColor *cp; if (!parent) { Gerr(POS, G_ERRNOPARENTWIDGET); return -1; } canvas = widget; WCU->func = NULL; WCU->needredraw = FALSE; WCU->buttonsdown = 0; WCU->bstate[0] = WCU->bstate[1] = WCU->bstate[2] = 0; ps.x = ps.y = MINCWSIZE; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRSIZE: GETSIZE(attrp[ai].u.s, ps, MINCWSIZE); break; case G_ATTRBORDERWIDTH: break; #ifdef FEATURE_GMAP case G_ATTRMODE: if (Strcmp("gmap", attrp[ai].u.t) == 0) { gmapmode = TRUE; } else { Gerr(POS, G_ERRBADATTRVALUE, attrp[ai].u.t); return -1; } break; #endif case G_ATTRCURSOR: break; case G_ATTRCOLOR: break; case G_ATTRVIEWPORT: break; case G_ATTRWINDOW: break; case G_ATTRWINDOWID: Gerr(POS, G_ERRCANNOTSETATTR2, "windowid"); return -1; case G_ATTREVENTCB: WCU->func = (Gcanvascb) attrp[ai].u.func; break; case G_ATTRUSERDATA: widget->udata = attrp[ai].u.u; break; default: Gerr(POS, G_ERRBADATTRID, attrp[ai].id); return -1; } } /* XtSetValues (widget->w, argp, argn); */ widget->w = gtk_drawing_area_new(); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(parent->w), widget->w); gtk_drawing_area_size(GTK_DRAWING_AREA(widget->w), ps.x, ps.y); gtk_widget_add_events(widget->w, GDK_ALL_EVENTS_MASK); gtk_signal_connect(GTK_OBJECT(widget->w), "key_release_event", GTK_SIGNAL_FUNC(Gcwkeyaction), NULL); gtk_signal_connect(GTK_OBJECT(widget->w), "key_press_event", GTK_SIGNAL_FUNC(Gcwkeyaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "button_press_event", GTK_SIGNAL_FUNC(Gcwbutaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "button_release_event", GTK_SIGNAL_FUNC(Gcwbutaction), NULL); gtk_signal_connect(G_OBJECT(widget->w), "visibility_notify_event", GTK_SIGNAL_FUNC(cweventhandler), NULL); gtk_signal_connect(G_OBJECT(widget->w), "expose_event", GTK_SIGNAL_FUNC(exposeeventhandler), NULL); gtk_signal_connect(G_OBJECT(widget->w), "motion_notify_event", GTK_SIGNAL_FUNC(cweventhandler), NULL); gtk_widget_show(widget->w); gtk_widget_show(parent->w); GC = gdk_gc_new(widget->w->window); WCU->cmap = gdk_colormap_get_system(); WCU->colors[0].color.pixel = WCU->colors[1].color.pixel = 1000000; if (WCU->colors[0].color.pixel == 1000000) { gdk_gc_get_values(GC, &gcv); WCU->colors[0].color = gcv.background; } if (WCU->colors[1].color.pixel == 1000000) { gdk_gc_get_values(GC, &gcv); WCU->colors[1].color = gcv.foreground; } WCU->colors[0].color.red = 65535; WCU->colors[0].color.green = 65535; WCU->colors[0].color.blue = 65535; WCU->colors[1].color.red = 0; WCU->colors[1].color.green = 0; WCU->colors[1].color.blue = 0; gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[0].color, FALSE, TRUE); WCU->colors[0].inuse = TRUE; gdk_colormap_alloc_color(WCU->cmap, &WCU->colors[1].color, FALSE, TRUE); WCU->colors[1].inuse = TRUE; WCU->allocedcolor[0] = WCU->allocedcolor[1] = FALSE; for (i = 2; i < G_MAXCOLORS; i++) WCU->colors[i].inuse = FALSE; WCU->gattr.color = 1; /* gdk_gc_set_background(GC, widget->w->style->white_gc); gdk_gc_set_foreground(GC, widget->w->style->black_gc); */ WCU->gattr.width = 0; WCU->gattr.mode = 0; WCU->gattr.fill = 0; WCU->gattr.style = 0; WCU->defgattr = WCU->gattr; WCU->font = NULL; WCU->wrect.o.x = 0.0, WCU->wrect.o.y = 0.0; WCU->wrect.c.x = 1.0, WCU->wrect.c.y = 1.0; WCU->vsize.x = ps.x, WCU->vsize.y = ps.y; for (ai = 0; ai < attrn; ai++) { switch (attrp[ai].id) { case G_ATTRCURSOR: if (Strcmp(attrp[ai].u.t, "default") == 0) { curcursori = -1; } break; case G_ATTRCOLOR: color = attrp[ai].u.c.index; if (color < 0 || color > G_MAXCOLORS) { Gerr(POS, G_ERRBADCOLORINDEX, color); return -1; } r = attrp[ai].u.c.r * 257; g = attrp[ai].u.c.g * 257; b = attrp[ai].u.c.b * 257; cp = &WCU->colors[color].color; if (WCU->colors[color].inuse) if (cp->red != r || cp->green != g || cp->blue != b) if (color > 1 || WCU->allocedcolor[color]) gdk_colormap_free_colors(WCU->cmap, cp, 1); cp->red = r, cp->green = g, cp->blue = b; if (gdk_colormap_alloc_color(WCU->cmap, cp, TRUE, TRUE)) { WCU->colors[color].inuse = TRUE; if (color <= 1) WCU->allocedcolor[color] = TRUE; } cp->red = r, cp->green = g, cp->blue = b; if (color == WCU->gattr.color) WCU->gattr.color = -1; break; case G_ATTRVIEWPORT: WCU->vsize.x = (int) (attrp[ai].u.s.x + 0.5); WCU->vsize.y = (int) (attrp[ai].u.s.y + 0.5); break; case G_ATTRWINDOW: WCU->wrect = attrp[ai].u.r; break; } } adjustclip(widget); return 0; }
static void _lib_geotagging_show_offset_window(GtkWidget *widget, dt_lib_module_t *self) { dt_lib_geotagging_t *d = self->data; gint x, y; gint px, py, center_w, center_h, window_w, window_h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); center_w = gdk_window_get_width(gtk_widget_get_window(center)); center_h = gdk_window_get_height(gtk_widget_get_window(center)); d->floating_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_can_focus(d->floating_window, TRUE); gtk_window_set_decorated(GTK_WINDOW(d->floating_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_window), GTK_WINDOW(window)); gtk_widget_set_opacity(d->floating_window, 0.8); gtk_window_set_modal(GTK_WINDOW(d->floating_window), TRUE); GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_widget_set_margin_top(vbox, DT_PIXEL_APPLY_DPI(2)); gtk_widget_set_margin_bottom(vbox, DT_PIXEL_APPLY_DPI(5)); gtk_widget_set_margin_start(vbox, DT_PIXEL_APPLY_DPI(5)); gtk_widget_set_margin_end(vbox, DT_PIXEL_APPLY_DPI(5)); gtk_container_add(GTK_CONTAINER(d->floating_window), vbox); d->floating_window_entry = gtk_entry_new(); gtk_widget_add_events(d->floating_window_entry, GDK_FOCUS_CHANGE_MASK); g_signal_connect_swapped(d->floating_window, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_object_set(G_OBJECT(d->floating_window_entry), "tooltip-text", _("enter the time shown on the selected picture\nformat: hh:mm:ss"), (char *)NULL); gtk_editable_select_region(GTK_EDITABLE(d->floating_window_entry), 0, -1); gtk_box_pack_start(GTK_BOX(vbox), d->floating_window_entry, TRUE, TRUE, 0); g_signal_connect(d->floating_window_entry, "key-press-event", G_CALLBACK(_lib_geotagging_floating_key_press), self); GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *cancel_button = gtk_button_new_with_label(_("cancel")); GtkWidget *ok_button = gtk_button_new_with_label(_("ok")); gtk_box_pack_start(GTK_BOX(hbox), cancel_button, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), ok_button, TRUE, TRUE, 0); g_signal_connect_swapped(G_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), d->floating_window); g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(_lib_geotagging_calculate_offset_callback), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_widget_show_all(d->floating_window); gtk_widget_grab_focus(d->floating_window_entry); window_w = gdk_window_get_width(gtk_widget_get_window(d->floating_window)); window_h = gdk_window_get_height(gtk_widget_get_window(d->floating_window)); x = px + 0.5 * (center_w - window_w); y = py + center_h - 20 - window_h; gtk_window_move(GTK_WINDOW(d->floating_window), x, y); gtk_window_present(GTK_WINDOW(d->floating_window)); }
bool wxMiniFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &pos, const wxSize &size, long style, const wxString &name ) { m_miniTitle = 0; if (style & wxCAPTION) m_miniTitle = 16; if (style & wxRESIZE_BORDER) m_miniEdge = 4; else m_miniEdge = 3; m_isDragging = false; m_oldX = -1; m_oldY = -1; m_diffX = 0; m_diffY = 0; wxFrame::Create( parent, id, title, pos, size, style, name ); // Use a GtkEventBox for the title and borders. Using m_widget for this // almost works, except that setting the resize cursor has no effect. GtkWidget* eventbox = gtk_event_box_new(); gtk_widget_add_events(eventbox, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); gtk_widget_show(eventbox); // Use a GtkAlignment to position m_mainWidget inside the decorations GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), m_miniTitle + m_miniEdge, m_miniEdge, m_miniEdge, m_miniEdge); gtk_widget_show(alignment); // The GtkEventBox and GtkAlignment go between m_widget and m_mainWidget gtk_widget_reparent(m_mainWidget, alignment); gtk_container_add(GTK_CONTAINER(eventbox), alignment); gtk_container_add(GTK_CONTAINER(m_widget), eventbox); m_gdkDecor = 0; m_gdkFunc = 0; if (style & wxRESIZE_BORDER) m_gdkFunc = GDK_FUNC_RESIZE; gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height); m_decorSize.Set(0, 0); m_deferShow = false; // don't allow sizing smaller than decorations GdkGeometry geom; geom.min_width = 2 * m_miniEdge; geom.min_height = 2 * m_miniEdge + m_miniTitle; gtk_window_set_geometry_hints(GTK_WINDOW(m_widget), NULL, &geom, GDK_HINT_MIN_SIZE); if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget))) { gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) ); } if (m_miniTitle && (style & wxCLOSE_BOX)) { wxImage img = wxBitmap((const char*)close_bits, 16, 16).ConvertToImage(); img.Replace(0,0,0,123,123,123); img.SetMaskColour(123,123,123); m_closeButton = wxBitmap( img ); } /* these are called when the borders are drawn */ g_signal_connect_after(eventbox, "expose_event", G_CALLBACK (gtk_window_own_expose_callback), this ); /* these are required for dragging the mini frame around */ g_signal_connect (eventbox, "button_press_event", G_CALLBACK (gtk_window_button_press_callback), this); g_signal_connect (eventbox, "button_release_event", G_CALLBACK (gtk_window_button_release_callback), this); g_signal_connect (eventbox, "motion_notify_event", G_CALLBACK (gtk_window_motion_notify_callback), this); g_signal_connect (eventbox, "leave_notify_event", G_CALLBACK (gtk_window_leave_callback), this); return true; }
static int gtkCanvasMapMethod(Ihandle* ih) { GtkScrolledWindow* scrolled_window; void* visual; if (!ih->parent) return IUP_ERROR; ih->data->sb = iupBaseGetScrollbar(ih); visual = (void*)IupGetAttribute(ih, "VISUAL"); /* defined by the OpenGL Canvas in X11 or NULL */ if (visual) iupgtkPushVisualAndColormap(visual, (void*)iupAttribGet(ih, "COLORMAP")); ih->handle = gtk_drawing_area_new(); if (visual) gtk_widget_pop_colormap(); if (!ih->handle) return IUP_ERROR; #if GTK_CHECK_VERSION(2, 18, 0) /* CD will NOT work properly without this, must use always the CD-GDK driver */ gtk_widget_set_has_window(ih->handle, TRUE); #endif scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL); if (!scrolled_window) return IUP_ERROR; { /* to avoid the "cannot add non scrollable widget" warning */ #if GTK_CHECK_VERSION(2, 6, 0) GLogFunc def_func = g_log_set_default_handler(gtkCanvasDummyLogFunc, NULL); #endif gtk_container_add((GtkContainer*)scrolled_window, ih->handle); #if GTK_CHECK_VERSION(2, 6, 0) g_log_set_default_handler(def_func, NULL); #endif } gtk_widget_show((GtkWidget*)scrolled_window); iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window); /* add to the parent, all GTK controls must call this. */ iupgtkBaseAddToParent(ih); g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(iupgtkKeyReleaseEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(ih->handle), "expose-event", G_CALLBACK(gtkCanvasExposeEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkCanvasButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkCanvasButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "scroll-event",G_CALLBACK(gtkCanvasScrollEvent), ih); #if GTK_CHECK_VERSION(2, 8, 0) g_signal_connect(G_OBJECT(gtk_scrolled_window_get_hscrollbar(scrolled_window)), "change-value",G_CALLBACK(gtkCanvasHChangeValue), ih); g_signal_connect(G_OBJECT(gtk_scrolled_window_get_vscrollbar(scrolled_window)), "change-value",G_CALLBACK(gtkCanvasVChangeValue), ih); #endif /* To receive mouse events on a drawing area, you will need to enable them. */ gtk_widget_add_events(ih->handle, GDK_EXPOSURE_MASK| GDK_POINTER_MOTION_MASK|GDK_POINTER_MOTION_HINT_MASK| GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK| GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK| GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK| GDK_FOCUS_CHANGE_MASK|GDK_STRUCTURE_MASK); /* To receive keyboard events, you will need to set the GTK_CAN_FOCUS flag on the drawing area. */ if (ih->iclass->is_interactive) { if (iupAttribGetBoolean(ih, "CANFOCUS")) iupgtkSetCanFocus(ih->handle, 1); } if (iupAttribGetBoolean(ih, "BORDER")) gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN); else gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_NONE); gtk_widget_realize((GtkWidget*)scrolled_window); gtk_widget_realize(ih->handle); /* must be connected after realize or a RESIZE_CB will happen before MAP_CB works only for the GtkDrawingArea. */ g_signal_connect(G_OBJECT(ih->handle), "configure-event", G_CALLBACK(gtkCanvasConfigureEvent), ih); iupAttribSetStr(ih, "_IUP_GTK_FIRST_RESIZE", "1"); /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DRAGDROP", "YES"); /* update a mnemonic in a label if necessary */ iupgtkUpdateMnemonic(ih); /* configure scrollbar */ if (ih->data->sb) { GtkPolicyType hscrollbar_policy = GTK_POLICY_NEVER, vscrollbar_policy = GTK_POLICY_NEVER; if (ih->data->sb & IUP_SB_HORIZ) hscrollbar_policy = GTK_POLICY_AUTOMATIC; if (ih->data->sb & IUP_SB_VERT) vscrollbar_policy = GTK_POLICY_AUTOMATIC; gtk_scrolled_window_set_policy(scrolled_window, hscrollbar_policy, vscrollbar_policy); } else gtk_scrolled_window_set_policy(scrolled_window, GTK_POLICY_NEVER, GTK_POLICY_NEVER); /* force the update of BGCOLOR here, to let derived classes ignore it if ACTION is defined */ gtkCanvasSetBgColorAttrib(ih, iupAttribGetStr(ih, "BGCOLOR")); return IUP_NOERROR; }
static gboolean _lib_tagging_tag_show(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, dt_lib_module_t* self) { int mouse_over_id = -1; int zoom = dt_conf_get_int("plugins/lighttable/images_in_row"); // the order is: // if(zoom == 1) => currently shown image // else if(selection not empty) => slected images // else if(cursor over image) => hovered image // else => return if(zoom == 1 || dt_collection_get_selected_count(darktable.collection) == 0) { DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id); if(mouse_over_id < 0) return TRUE; } dt_lib_tagging_t *d = (dt_lib_tagging_t*)self->data; d->floating_tag_imgid = mouse_over_id; gint x, y; gint px, py, w, h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); gdk_window_get_size(gtk_widget_get_window(center),&w,&h); x = px + 0.5*(w-FLOATING_ENTRY_WIDTH); y = py + h - 50; /* put the floating box at the mouse pointer */ // gint pointerx, pointery; // gtk_widget_get_pointer(center, &pointerx, &pointery); // x = px + pointerx + 1; // y = py + pointery + 1; d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */ GTK_WIDGET_SET_FLAGS(d->floating_tag_window, GTK_CAN_FOCUS); gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE); gtk_window_set_has_frame(GTK_WINDOW(d->floating_tag_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window)); gtk_window_set_opacity(GTK_WINDOW(d->floating_tag_window), 0.8); gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y); GtkWidget *entry = gtk_entry_new(); gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1); gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK); GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(entry), completion); gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1); gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry); g_signal_connect_swapped(entry, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_tag_window); g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self); gtk_widget_show_all(d->floating_tag_window); gtk_widget_grab_focus(entry); gtk_window_present(GTK_WINDOW(d->floating_tag_window)); return TRUE; }
bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& sizeOrig, long style, const wxString &name ) { wxSize size(sizeOrig); if (!size.IsFullySpecified()) size.SetDefaults(GetDefaultSize()); wxTopLevelWindows.Append( this ); if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") ); return false; } m_title = title; // NB: m_widget may be !=NULL if it was created by derived class' Create, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { // Tell WM that this is a dialog window and make it center // on parent by default (this is what GtkDialog ctor does): gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(m_widget), GTK_WIN_POS_CENTER_ON_PARENT); } else { if (style & wxFRAME_TOOL_WINDOW) { gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_UTILITY); // On some WMs, like KDE, a TOOL_WINDOW will still show // on the taskbar, but on Gnome a TOOL_WINDOW will not. // For consistency between WMs and with Windows, we // should set the NO_TASKBAR flag which will apply // the set_skip_taskbar_hint if it is available, // ensuring no taskbar entry will appear. style |= wxFRAME_NO_TASKBAR; } } g_object_ref(m_widget); } wxWindow *topParent = wxGetTopLevelParent(m_parent); if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || (style & wxFRAME_FLOAT_ON_PARENT))) { gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(topParent->m_widget) ); } if (style & wxFRAME_NO_TASKBAR) { gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } if (style & wxSTAY_ON_TOP) { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } if (style & wxMAXIMIZE) gtk_window_maximize(GTK_WINDOW(m_widget)); #if 0 if (!name.empty()) gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) ); #endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); gtk_widget_set_can_focus(m_widget, false); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show( m_mainWidget ); gtk_widget_set_can_focus(m_mainWidget, false); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); // m_wxwindow is the client area m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes gtk_widget_set_can_focus(m_wxwindow, false); if (m_parent) m_parent->AddChild( this ); g_signal_connect(m_wxwindow, "size_allocate", G_CALLBACK(size_allocate), this); PostCreation(); #ifndef __WXGTK3__ if (pos != wxDefaultPosition) gtk_widget_set_uposition( m_widget, m_x, m_y ); #endif // for some reported size corrections g_signal_connect (m_widget, "map_event", G_CALLBACK (gtk_frame_map_callback), this); // for iconized state g_signal_connect (m_widget, "window_state_event", G_CALLBACK (gtk_frame_window_state_callback), this); // for wxMoveEvent g_signal_connect (m_widget, "configure_event", G_CALLBACK (gtk_frame_configure_callback), this); // activation g_signal_connect_after (m_widget, "focus_in_event", G_CALLBACK (gtk_frame_focus_in_callback), this); g_signal_connect_after (m_widget, "focus_out_event", G_CALLBACK (gtk_frame_focus_out_callback), this); // We need to customize the default GTK+ logic for key processing to make // it conforming to wxWidgets event processing order. g_signal_connect (m_widget, "key_press_event", G_CALLBACK (wxgtk_tlw_key_press_event), NULL); #ifdef GDK_WINDOWING_X11 #ifdef __WXGTK3__ if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget)))) #endif { gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); g_signal_connect(m_widget, "property_notify_event", G_CALLBACK(property_notify_event), this); } #endif // GDK_WINDOWING_X11 // translate wx decorations styles into Motif WM hints (they are recognized // by other WMs as well) // always enable moving the window as we have no separate flag for enabling // it m_gdkFunc = GDK_FUNC_MOVE; if ( style & wxCLOSE_BOX ) m_gdkFunc |= GDK_FUNC_CLOSE; if ( style & wxMINIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MAXIMIZE; if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) ) { m_gdkDecor = 0; gtk_window_set_decorated(GTK_WINDOW(m_widget), false); } else // have border { m_gdkDecor = GDK_DECOR_BORDER; if ( style & wxCAPTION ) m_gdkDecor |= GDK_DECOR_TITLE; #if defined(GDK_WINDOWING_WAYLAND) && GTK_CHECK_VERSION(3,10,0) else if ( GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(m_widget)) && gtk_check_version(3,10,0) == NULL) { gtk_window_set_titlebar(GTK_WINDOW(m_widget), gtk_header_bar_new()); } #endif if ( style & wxSYSTEM_MENU ) m_gdkDecor |= GDK_DECOR_MENU; if ( style & wxMINIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MAXIMIZE; if ( style & wxRESIZE_BORDER ) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } m_decorSize = GetCachedDecorSize(); int w, h; GTKDoGetSize(&w, &h); if (style & wxRESIZE_BORDER) { gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); #ifndef __WXGTK3__ gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif } else { gtk_window_set_resizable(GTK_WINDOW(m_widget), false); // gtk_window_set_default_size() does not work for un-resizable windows, // unless you set the size hints, but that causes Ubuntu's WM to make // the window resizable even though GDK_FUNC_RESIZE is not set. gtk_widget_set_size_request(m_widget, w, h); } return true; }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t)); dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data; c->mouse_x = c->mouse_y = -1.0; c->dragging = 0; c->activeToggleButton = NULL; c->current_pick = NONE; c->last_picked_color = -1; for (int i=0; i<3; i++) for (int j=0; j<2; j++) c->pick_xy_positions[i][j] = -1; self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 5)); c->area = GTK_DRAWING_AREA(gtk_drawing_area_new()); GtkWidget *asp = gtk_aspect_frame_new(NULL, 0.5, 0.5, 1.0, TRUE); gtk_box_pack_start(GTK_BOX(self->widget), asp, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(asp), GTK_WIDGET(c->area)); gtk_drawing_area_size(c->area, 258, 150); g_object_set (GTK_OBJECT(c->area), "tooltip-text", _("drag handles to set black, grey, and white points. operates on L channel."), (char *)NULL); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect (G_OBJECT (c->area), "expose-event", G_CALLBACK (dt_iop_levels_expose), self); g_signal_connect (G_OBJECT (c->area), "button-press-event", G_CALLBACK (dt_iop_levels_button_press), self); g_signal_connect (G_OBJECT (c->area), "button-release-event", G_CALLBACK (dt_iop_levels_button_release), self); g_signal_connect (G_OBJECT (c->area), "motion-notify-event", G_CALLBACK (dt_iop_levels_motion_notify), self); g_signal_connect (G_OBJECT (c->area), "leave-notify-event", G_CALLBACK (dt_iop_levels_leave_notify), self); g_signal_connect (G_OBJECT (c->area), "scroll-event", G_CALLBACK (dt_iop_levels_scroll), self); GtkWidget *autobutton = dtgtk_button_new_with_label(_("auto"), NULL, CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER); g_object_set(G_OBJECT(autobutton), "tooltip-text", _("apply auto levels"), (char *)NULL); gtk_widget_set_size_request(autobutton, 70, 24); GtkWidget *blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(blackpick), "tooltip-text", _("pick blackpoint from image"), (char *)NULL); gtk_widget_set_size_request(blackpick, 24, 24); GtkWidget *greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(greypick), "tooltip-text", _("pick medium greypoint from image"), (char *)NULL); gtk_widget_set_size_request(greypick, 24, 24); GtkWidget *whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT); g_object_set(G_OBJECT(whitepick), "tooltip-text", _("pick whitepoint from image"), (char *)NULL); gtk_widget_set_size_request(whitepick, 24, 24); GdkColor col; col.red = col.green = col.blue = 0; gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(blackpick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 32767; gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(greypick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 65535; gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_NORMAL, &col); gtk_widget_modify_fg(GTK_WIDGET(whitepick), GTK_STATE_SELECTED, &col); col.red = col.green = col.blue = 4096; gtk_widget_modify_bg(GTK_WIDGET(blackpick), GTK_STATE_ACTIVE, &col); gtk_widget_modify_bg(GTK_WIDGET(greypick), GTK_STATE_ACTIVE, &col); gtk_widget_modify_bg(GTK_WIDGET(whitepick), GTK_STATE_ACTIVE, &col); GtkWidget *box = gtk_hbox_new(TRUE,0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(blackpick), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(greypick), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(whitepick), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); g_signal_connect (G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback), (gpointer)self); g_signal_connect (G_OBJECT(blackpick), "toggled", G_CALLBACK (dt_iop_levels_pick_black_callback), self); g_signal_connect (G_OBJECT(greypick), "toggled", G_CALLBACK (dt_iop_levels_pick_grey_callback), self); g_signal_connect (G_OBJECT(whitepick), "toggled", G_CALLBACK (dt_iop_levels_pick_white_callback), self); }
int main (int argc, char** argv) { GtkWidget* window; GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0}; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); if (!window) return 0; gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DOCK); gtk_widget_add_events (window, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); // hook up input/event handlers to window g_signal_connect (G_OBJECT (window), "screen-changed", G_CALLBACK (screen_changed_handler), NULL); g_signal_connect (G_OBJECT (window), "composited-changed", G_CALLBACK (composited_changed_handler), NULL); gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y); // make sure the window opens with a RGBA-visual screen_changed_handler (window, NULL, NULL); gtk_widget_realize (window); gdk_window_set_background_rgba (gtk_widget_get_window (window), &transparent); // hook up window-event handlers to window g_signal_connect (G_OBJECT (window), "draw", G_CALLBACK (expose_handler), NULL); // FIXME: read out current mouse-pointer position every 1/25 second g_timeout_add (1000/40, (GSourceFunc) pointer_update, (gpointer) window); g_timeout_add (10000, (GSourceFunc) quit, NULL); g_timeout_add (1000/40, (GSourceFunc) grow, (gpointer) window); // "clear" input-mask, set title/icon/attributes gtk_widget_set_app_paintable (window, TRUE); gtk_window_set_decorated (GTK_WINDOW (window), FALSE); gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE); gtk_window_set_opacity (GTK_WINDOW (window), 1.0f); gtk_widget_set_size_request (window, (gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE), (gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE)); gtk_widget_show (window); g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window)); update_input_shape (window, 1, 1); update_shape (window, (gint) CORNER_RADIUS, (gint) BUBBLE_SHADOW_SIZE); set_bg_blur (window, TRUE); setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE), (gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE)); g_print ("This test will run for 10 seconds and then quit.\n"); gtk_main (); tile_destroy (g_tile); return 0; }
CV_IMPL int cvNamedWindow( const char* name, int flags ) { int result = 0; CV_FUNCNAME( "cvNamedWindow" ); __BEGIN__; CvWindow* window; int len; cvInitSystem(1,(char**)&name); if( !name ) CV_ERROR( CV_StsNullPtr, "NULL name string" ); // Check the name in the storage if( icvFindWindowByName( name ) != 0 ) { result = 1; EXIT; } len = strlen(name); CV_CALL( window = (CvWindow*)cvAlloc(sizeof(CvWindow) + len + 1)); memset( window, 0, sizeof(*window)); window->name = (char*)(window + 1); memcpy( window->name, name, len + 1 ); window->flags = flags; window->signature = CV_WINDOW_MAGIC_VAL; window->last_key = 0; window->on_mouse = 0; window->on_mouse_param = 0; memset( &window->toolbar, 0, sizeof(window->toolbar)); window->next = hg_windows; window->prev = 0; window->status = CV_WINDOW_NORMAL;//YV CV_LOCK_MUTEX(); window->frame = gtk_window_new( GTK_WINDOW_TOPLEVEL ); window->paned = gtk_vbox_new( FALSE, 0 ); window->widget = cvImageWidgetNew( flags ); gtk_box_pack_end( GTK_BOX(window->paned), window->widget, TRUE, TRUE, 0 ); gtk_widget_show( window->widget ); gtk_container_add( GTK_CONTAINER(window->frame), window->paned ); gtk_widget_show( window->paned ); #ifndef HAVE_OPENGL if (flags & CV_WINDOW_OPENGL) CV_ERROR( CV_OpenGlNotSupported, "Library was built without OpenGL support" ); #else if (flags & CV_WINDOW_OPENGL) createGlContext(window); window->glDrawCallback = 0; window->glDrawData = 0; #endif // // configure event handlers // TODO -- move this to CvImageWidget ? g_signal_connect( window->frame, "key-press-event", G_CALLBACK(icvOnKeyPress), window ); g_signal_connect( window->widget, "button-press-event", G_CALLBACK(icvOnMouse), window ); g_signal_connect( window->widget, "button-release-event", G_CALLBACK(icvOnMouse), window ); g_signal_connect( window->widget, "motion-notify-event", G_CALLBACK(icvOnMouse), window ); g_signal_connect( window->frame, "delete-event", G_CALLBACK(icvOnClose), window ); g_signal_connect( window->widget, "expose-event", G_CALLBACK(cvImageWidget_expose), window ); gtk_widget_add_events (window->widget, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK) ; gtk_widget_show( window->frame ); gtk_window_set_title( GTK_WINDOW(window->frame), name ); if( hg_windows ) hg_windows->prev = window; hg_windows = window; gtk_window_set_resizable( GTK_WINDOW(window->frame), (flags & CV_WINDOW_AUTOSIZE) == 0 ); // allow window to be resized if( (flags & CV_WINDOW_AUTOSIZE)==0 ){ GdkGeometry geometry; geometry.min_width = 50; geometry.min_height = 50; gtk_window_set_geometry_hints( GTK_WINDOW( window->frame ), GTK_WIDGET( window->widget ), &geometry, (GdkWindowHints) (GDK_HINT_MIN_SIZE)); } CV_UNLOCK_MUTEX(); #ifdef HAVE_OPENGL if (window->useGl) cvSetOpenGlContext(name); #endif result = 1; __END__; return result; }
static void gtk_source_map_init (GtkSourceMap *map) { GtkSourceMapPrivate *priv; GtkSourceCompletion *completion; GtkStyleContext *context; priv = gtk_source_map_get_instance_private (map); priv->css_provider = gtk_css_provider_new (); context = gtk_widget_get_style_context (GTK_WIDGET (map)); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (priv->css_provider), CSS_PRIORITY); priv->child_view = g_object_new (GTK_SOURCE_TYPE_VIEW, "auto-indent", FALSE, "can-focus", FALSE, "draw-spaces", 0, "editable", FALSE, "expand", FALSE, "monospace", TRUE, "show-line-numbers", FALSE, "show-line-marks", FALSE, "show-right-margin", FALSE, "visible", TRUE, NULL); context = gtk_widget_get_style_context (GTK_WIDGET (priv->child_view)); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (priv->css_provider), CSS_PRIORITY); g_signal_connect_object (priv->child_view, "button-press-event", G_CALLBACK (child_view_button_press_event), map, G_CONNECT_SWAPPED); gtk_widget_add_events (GTK_WIDGET (priv->child_view), GDK_SCROLL_MASK); g_signal_connect_object (priv->child_view, "scroll-event", G_CALLBACK (child_view_scroll_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "state-flags-changed", G_CALLBACK (child_view_state_flags_changed), map, G_CONNECT_SWAPPED | G_CONNECT_AFTER); g_signal_connect_object (priv->child_view, "realize", G_CALLBACK (child_view_realize_after), map, G_CONNECT_SWAPPED | G_CONNECT_AFTER); g_signal_connect_object (priv->child_view, "button-press-event", G_CALLBACK (child_view_button_press_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "button-release-event", G_CALLBACK (child_view_button_release_event), map, G_CONNECT_SWAPPED); g_signal_connect_object (priv->child_view, "motion-notify-event", G_CALLBACK (child_view_motion_notify_event), map, G_CONNECT_SWAPPED); gtk_container_add (GTK_CONTAINER (map), GTK_WIDGET (priv->child_view)); completion = gtk_source_view_get_completion (priv->child_view); gtk_source_completion_block_interactive (completion); gtk_source_map_set_font_name (map, "Monospace 1"); }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_colorchecker_gui_data_t)); dt_iop_colorchecker_gui_data_t *g = (dt_iop_colorchecker_gui_data_t *)self->gui_data; dt_iop_colorchecker_params_t *p = (dt_iop_colorchecker_params_t *)self->params; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE); // custom 24-patch widget in addition to combo box g->area = dtgtk_drawing_area_new_with_aspect_ratio(4.0/6.0); gtk_box_pack_start(GTK_BOX(self->widget), g->area, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(g->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_SCROLL_MASK); g_signal_connect(G_OBJECT(g->area), "draw", G_CALLBACK(checker_draw), self); g_signal_connect(G_OBJECT(g->area), "button-press-event", G_CALLBACK(checker_button_press), self); g_signal_connect(G_OBJECT(g->area), "motion-notify-event", G_CALLBACK(checker_motion_notify), self); g_signal_connect(G_OBJECT(g->area), "leave-notify-event", G_CALLBACK(checker_leave_notify), self); g->patch = 0; g->drawn_patch = -1; g->combobox_patch = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->combobox_patch, NULL, _("patch")); gtk_widget_set_tooltip_text(g->combobox_patch, _("color checker patch")); char cboxentry[1024]; for(int k=0;k<p->num_patches;k++) { snprintf(cboxentry, sizeof(cboxentry), _("patch #%d"), k); dt_bauhaus_combobox_add(g->combobox_patch, cboxentry); } self->request_color_pick = DT_REQUEST_COLORPICK_OFF; dt_bauhaus_widget_set_quad_paint(g->combobox_patch, dtgtk_cairo_paint_colorpicker, CPF_ACTIVE); g->scale_L = dt_bauhaus_slider_new_with_range(self, -100.0, 100.0, 1.0, 0.0f, 2); gtk_widget_set_tooltip_text(g->scale_L, _("lightness offset")); dt_bauhaus_widget_set_label(g->scale_L, NULL, _("lightness")); g->scale_a = dt_bauhaus_slider_new_with_range(self, -256.0, 256.0, 1.0, 0.0f, 2); gtk_widget_set_tooltip_text(g->scale_a, _("chroma offset green/red")); dt_bauhaus_widget_set_label(g->scale_a, NULL, _("green/red")); dt_bauhaus_slider_set_stop(g->scale_a, 0.0, 0.0, 1.0, 0.2); dt_bauhaus_slider_set_stop(g->scale_a, 0.5, 1.0, 1.0, 1.0); dt_bauhaus_slider_set_stop(g->scale_a, 1.0, 1.0, 0.0, 0.2); g->scale_b = dt_bauhaus_slider_new_with_range(self, -256.0, 256.0, 1.0, 0.0f, 2); gtk_widget_set_tooltip_text(g->scale_b, _("chroma offset blue/yellow")); dt_bauhaus_widget_set_label(g->scale_b, NULL, _("blue/yellow")); dt_bauhaus_slider_set_stop(g->scale_b, 0.0, 0.0, 0.0, 1.0); dt_bauhaus_slider_set_stop(g->scale_b, 0.5, 1.0, 1.0, 1.0); dt_bauhaus_slider_set_stop(g->scale_b, 1.0, 1.0, 1.0, 0.0); g->scale_C = dt_bauhaus_slider_new_with_range(self, -128.0, 128.0, 1.0f, 0.0f, 2); gtk_widget_set_tooltip_text(g->scale_C, _("saturation offset")); dt_bauhaus_widget_set_label(g->scale_C, NULL, _("saturation")); gtk_box_pack_start(GTK_BOX(self->widget), g->combobox_patch, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->scale_L, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->scale_a, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->scale_b, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), g->scale_C, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(g->combobox_patch), "value-changed", G_CALLBACK(patch_callback), self); g_signal_connect(G_OBJECT(g->combobox_patch), "quad-pressed", G_CALLBACK(picker_callback), self); g_signal_connect(G_OBJECT(g->scale_L), "value-changed", G_CALLBACK(target_L_callback), self); g_signal_connect(G_OBJECT(g->scale_a), "value-changed", G_CALLBACK(target_a_callback), self); g_signal_connect(G_OBJECT(g->scale_b), "value-changed", G_CALLBACK(target_b_callback), self); g_signal_connect(G_OBJECT(g->scale_C), "value-changed", G_CALLBACK(target_C_callback), self); cmsHPROFILE hsRGB = dt_colorspaces_get_profile(DT_COLORSPACE_SRGB, "", DT_PROFILE_DIRECTION_IN)->profile; cmsHPROFILE hLab = dt_colorspaces_get_profile(DT_COLORSPACE_LAB, "", DT_PROFILE_DIRECTION_ANY)->profile; g->xform = cmsCreateTransform(hLab, TYPE_Lab_DBL, hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL, 0); // cmsFLAGS_NOTPRECALC); }
static void connect_view (GtkSourceMap *map, GtkSourceView *view) { GtkSourceMapPrivate *priv; GtkAdjustment *vadj; priv = gtk_source_map_get_instance_private (map); priv->view = view; g_object_add_weak_pointer (G_OBJECT (view), (gpointer *)&priv->view); vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (view)); priv->buffer_binding = g_object_bind_property (view, "buffer", priv->child_view, "buffer", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->buffer_binding), (gpointer *)&priv->buffer_binding); priv->indent_width_binding = g_object_bind_property (view, "indent-width", priv->child_view, "indent-width", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->indent_width_binding), (gpointer *)&priv->indent_width_binding); priv->tab_width_binding = g_object_bind_property (view, "tab-width", priv->child_view, "tab-width", G_BINDING_SYNC_CREATE); g_object_add_weak_pointer (G_OBJECT (priv->tab_width_binding), (gpointer *)&priv->tab_width_binding); priv->view_notify_buffer_handler = g_signal_connect_object (view, "notify::buffer", G_CALLBACK (view_notify_buffer), map, G_CONNECT_SWAPPED); view_notify_buffer (map, NULL, view); priv->view_vadj_value_changed_handler = g_signal_connect_object (vadj, "value-changed", G_CALLBACK (view_vadj_value_changed), map, G_CONNECT_SWAPPED); priv->view_vadj_notify_upper_handler = g_signal_connect_object (vadj, "notify::upper", G_CALLBACK (view_vadj_notify_upper), map, G_CONNECT_SWAPPED); if ((gtk_widget_get_events (GTK_WIDGET (priv->view)) & GDK_ENTER_NOTIFY_MASK) == 0) { gtk_widget_add_events (GTK_WIDGET (priv->view), GDK_ENTER_NOTIFY_MASK); } if ((gtk_widget_get_events (GTK_WIDGET (priv->view)) & GDK_LEAVE_NOTIFY_MASK) == 0) { gtk_widget_add_events (GTK_WIDGET (priv->view), GDK_LEAVE_NOTIFY_MASK); } gtk_source_map_rebuild_css (map); }
static gboolean nsgtk_window_draw_event(GtkWidget *widget, cairo_t *cr, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; double x1; double y1; double x2; double y2; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = cr; cairo_clip_extents(cr, &x1, &y1, &x2, &y2); clip.x0 = x1; clip.y0 = y1; clip.x1 = x2; clip.y1 = y2; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } current_widget = NULL; return FALSE; } #else static gboolean nsgtk_window_draw_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = gdk_cairo_create(nsgtk_layout_get_bin_window(gw->layout)); clip.x0 = event->area.x; clip.y0 = event->area.y; clip.x1 = event->area.x + event->area.width; clip.y1 = event->area.y + event->area.height; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } cairo_destroy(current_cr); current_widget = NULL; return FALSE; } #endif static gboolean nsgtk_window_motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; if ((abs(event->x - g->last_x) < 5) && (abs(event->y - g->last_y) < 5)) { /* Mouse hasn't moved far enough from press coordinate for this * to be considered a drag. */ return FALSE; } else { /* This is a drag, ensure it's always treated as such, even if * we drag back over the press location */ g->last_x = INT_MIN; g->last_y = INT_MIN; } if (g->mouse.state & BROWSER_MOUSE_PRESS_1) { /* Start button 1 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_1, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_HOLDING_1); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) { /* Start button 2 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_2, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_HOLDING_2); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; browser_window_mouse_track(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); return TRUE; } static gboolean nsgtk_window_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; gtk_widget_grab_focus(GTK_WIDGET(g->layout)); gtk_widget_hide(GTK_WIDGET(nsgtk_scaffolding_history_window( g->scaffold)->window)); g->mouse.pressed_x = event->x / g->bw->scale; g->mouse.pressed_y = event->y / g->bw->scale; switch (event->button) { case 1: /* Left button, usually. Pass to core as BUTTON 1. */ g->mouse.state = BROWSER_MOUSE_PRESS_1; break; case 2: /* Middle button, usually. Pass to core as BUTTON 2 */ g->mouse.state = BROWSER_MOUSE_PRESS_2; break; case 3: /* Right button, usually. Action button, context menu. */ browser_window_remove_caret(g->bw, true); nsgtk_scaffolding_popup_menu(g->scaffold, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; default: return FALSE; } /* Modify for double & triple clicks */ if (event->type == GDK_3BUTTON_PRESS) g->mouse.state |= BROWSER_MOUSE_TRIPLE_CLICK; else if (event->type == GDK_2BUTTON_PRESS) g->mouse.state |= BROWSER_MOUSE_DOUBLE_CLICK; /* Handle the modifiers too */ if (event->state & GDK_SHIFT_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_1; if (event->state & GDK_CONTROL_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_2; /* Record where we pressed, for use when determining whether to start * a drag in motion notify events. */ g->last_x = event->x; g->last_y = event->y; browser_window_mouse_click(g->bw, g->mouse.state, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; } static gboolean nsgtk_window_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; /* If the mouse state is PRESS then we are waiting for a release to emit * a click event, otherwise just reset the state to nothing */ if (g->mouse.state & BROWSER_MOUSE_PRESS_1) g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_CLICK_1); else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_CLICK_2); /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; if (g->mouse.state & (BROWSER_MOUSE_CLICK_1 | BROWSER_MOUSE_CLICK_2)) { browser_window_mouse_click(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); } else { browser_window_mouse_track(g->bw, 0, event->x / g->bw->scale, event->y / g->bw->scale); } g->mouse.state = 0; return TRUE; } static gboolean nsgtk_window_scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data) { struct gui_window *g = data; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; LOG(("%d", event->direction)); switch (event->direction) { case GDK_SCROLL_LEFT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, -100, 0) != true) { /* core did not handle event do horizontal scroll */ value = gtk_adjustment_get_value(hscroll) - (nsgtk_adjustment_get_step_increment(hscroll) *2); if (value < nsgtk_adjustment_get_lower(hscroll)) { value = nsgtk_adjustment_get_lower(hscroll); } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_UP: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, -100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) - (nsgtk_adjustment_get_step_increment(vscroll) * 2); if (value < nsgtk_adjustment_get_lower(vscroll)) { value = nsgtk_adjustment_get_lower(vscroll); } gtk_adjustment_set_value(vscroll, value); } break; case GDK_SCROLL_RIGHT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 100, 0) != true) { /* core did not handle event change horizontal * adjustment. */ value = gtk_adjustment_get_value(hscroll) + (nsgtk_adjustment_get_step_increment(hscroll) * 2); /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) { value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_DOWN: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, 100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) + (nsgtk_adjustment_get_step_increment(vscroll) * 2); /* @todo consider gtk_widget_get_allocated_height */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) { value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; } gtk_adjustment_set_value(vscroll, value); } break; default: break; } return TRUE; } static gboolean nsgtk_window_keypress_event(GtkWidget *widget, GdkEventKey *event, gpointer data) { struct gui_window *g = data; uint32_t nskey = gtk_gui_gdkkey_to_nskey(event); if (browser_window_key_press(g->bw, nskey)) return TRUE; if ((event->state & 0x7) != 0) return TRUE; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); switch (event->keyval) { case GDK_KEY(Home): case GDK_KEY(KP_Home): value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(End): case GDK_KEY(KP_End): value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Left): case GDK_KEY(KP_Left): value = gtk_adjustment_get_value(hscroll) - nsgtk_adjustment_get_step_increment(hscroll); if (value < nsgtk_adjustment_get_lower(hscroll)) value = nsgtk_adjustment_get_lower(hscroll); gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Up): case GDK_KEY(KP_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_step_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Right): case GDK_KEY(KP_Right): value = gtk_adjustment_get_value(hscroll) + nsgtk_adjustment_get_step_increment(hscroll); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Down): case GDK_KEY(KP_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_step_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Up): case GDK_KEY(KP_Page_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_page_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Down): case GDK_KEY(KP_Page_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_page_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; default: break; } return TRUE; } static gboolean nsgtk_window_size_allocate_event(GtkWidget *widget, GtkAllocation *allocation, gpointer data) { struct gui_window *g = data; g->bw->reformat_pending = true; browser_reformat_pending = true; if (g->paned != NULL) { /* Set status bar / scroll bar proportion according to * option_toolbar_status_width */ /* TODO: Probably want to detect when the user adjusts the * status bar width, remember that proportion for the * window, and use that here. */ gtk_paned_set_position(g->paned, (nsoption_int(toolbar_status_width) * allocation->width) / 10000); } return TRUE; } /* Core interface docuemnted in desktop/gui.h to create a gui_window */ struct gui_window *gui_create_browser_window(struct browser_window *bw, struct browser_window *clone, bool new_tab) { struct gui_window *g; /**< what we're creating to return */ g = calloc(1, sizeof(*g)); if (!g) { warn_user("NoMemory", 0); return 0; } LOG(("Creating gui window %p for browser window %p", g, bw)); g->bw = bw; g->paned = NULL; g->mouse.state = 0; g->current_pointer = GUI_POINTER_DEFAULT; if (clone != NULL) { bw->scale = clone->scale; } else { bw->scale = (float) nsoption_int(scale) / 100.0; } g->careth = 0; if (new_tab) { assert(clone != NULL); g->scaffold = clone->window->scaffold; } else { /* Now construct and attach a scaffold */ g->scaffold = nsgtk_new_scaffolding(g); } if (g->scaffold == NULL) { warn_user("NoMemory", 0); free(g); return NULL; } /* Construct our primary elements */ /* top-level document (not a frame) => create a new tab */ GError* error = NULL; GtkBuilder* xml = gtk_builder_new(); if (!gtk_builder_add_from_file(xml, glade_file_location->tabcontents, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free(error); return 0; } g->layout = GTK_LAYOUT(gtk_builder_get_object(xml, "layout")); g->status_bar = GTK_LABEL(gtk_builder_get_object(xml, "status_bar")); g->paned = GTK_PANED(gtk_builder_get_object(xml, "hpaned1")); /* connect the scrollbars to the layout widget */ nsgtk_layout_set_hadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "hscrollbar")))); nsgtk_layout_set_vadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "vscrollbar")))); /* add the tab to the scaffold */ bool tempback = true; switch (temp_open_background) { case -1: tempback = !(nsoption_bool(focus_new)); break; case 0: tempback = false; break; case 1: tempback = true; break; } GtkWidget *tab_contents = GTK_WIDGET(gtk_builder_get_object(xml, "tabContents")); g_object_set_data(G_OBJECT(tab_contents), "gui_window", g); nsgtk_tab_add(g, tab_contents, tempback); g_object_unref(xml); /* Attach ourselves to the list (push_top) */ if (window_list) window_list->prev = g; g->next = window_list; g->prev = NULL; window_list = g; /* set the events we're interested in receiving from the browser's * drawing area. */ gtk_widget_add_events(GTK_WIDGET(g->layout), GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_SCROLL_MASK); nsgtk_widget_set_can_focus(GTK_WIDGET(g->layout), TRUE); /* set the default background colour of the drawing area to white. */ nsgtk_widget_override_background_color(GTK_WIDGET(g->layout), GTK_STATE_NORMAL, 0, 0xffff, 0xffff, 0xffff); nsgtk_connect_draw_event(GTK_WIDGET(g->layout), G_CALLBACK(nsgtk_window_draw_event), g); #define CONNECT(obj, sig, callback, ptr) \ g_signal_connect(G_OBJECT(obj), (sig), G_CALLBACK(callback), (ptr)) CONNECT(g->layout, "motion_notify_event", nsgtk_window_motion_notify_event, g); g->signalhandler[NSGTK_WINDOW_SIGNAL_CLICK] = CONNECT(g->layout, "button_press_event", nsgtk_window_button_press_event, g); CONNECT(g->layout, "button_release_event", nsgtk_window_button_release_event, g); CONNECT(g->layout, "key_press_event", nsgtk_window_keypress_event, g); CONNECT(g->layout, "size_allocate", nsgtk_window_size_allocate_event, g); CONNECT(g->layout, "scroll_event", nsgtk_window_scroll_event, g); return g; } void nsgtk_reflow_all_windows(void) { for (struct gui_window *g = window_list; g; g = g->next) { nsgtk_tab_options_changed( nsgtk_scaffolding_notebook(g->scaffold)); g->bw->reformat_pending = true; } browser_reformat_pending = true; } /** * Process pending reformats */ void nsgtk_window_process_reformats(void) { struct gui_window *g; GtkAllocation alloc; browser_reformat_pending = false; for (g = window_list; g; g = g->next) { if (!g->bw->reformat_pending) continue; g->bw->reformat_pending = false; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); browser_window_reformat(g->bw, false, alloc.width, alloc.height); } } void nsgtk_window_destroy_browser(struct gui_window *g) { browser_window_destroy(g->bw); } void gui_window_destroy(struct gui_window *g) { if (g->prev) g->prev->next = g->next; else window_list = g->next; if (g->next) g->next->prev = g->prev; LOG(("Destroying gui_window %p", g)); assert(g != NULL); assert(g->bw != NULL); LOG((" Scaffolding: %p", g->scaffold)); LOG((" Window name: %s", g->bw->name)); /* tab => remove tab */ gtk_widget_destroy(gtk_widget_get_parent(GTK_WIDGET(g->layout))); } /** * set favicon */ void gui_window_set_icon(struct gui_window *gw, hlcache_handle *icon) { struct bitmap *icon_bitmap = NULL; /* free any existing icon */ if (gw->icon != NULL) { g_object_unref(gw->icon); gw->icon = NULL; } if (icon != NULL) { icon_bitmap = content_get_bitmap(icon); if (icon_bitmap != NULL) { LOG(("Using %p bitmap", icon_bitmap)); gw->icon = nsgdk_pixbuf_get_from_surface(icon_bitmap->surface, 16, 16); } } if (gw->icon == NULL) { LOG(("Using default favicon")); g_object_ref(favicon_pixbuf); gw->icon = favicon_pixbuf; } nsgtk_scaffolding_set_icon(gw); } static void nsgtk_redraw_caret(struct gui_window *g) { int sx, sy; if (g->careth == 0) return; gui_window_get_scroll(g, &sx, &sy); gtk_widget_queue_draw_area(GTK_WIDGET(g->layout), g->caretx - sx, g->carety - sy, 1, g->careth + 1); }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_zonesystem_gui_data_t)); dt_iop_zonesystem_gui_data_t *g = (dt_iop_zonesystem_gui_data_t *)self->gui_data; g->in_preview_buffer = g->out_preview_buffer = NULL; g->is_dragging = FALSE; g->hilite_zone = FALSE; g->preview_width=g->preview_height = 0; g->mouse_over_output_zones = FALSE; dt_pthread_mutex_init(&g->lock, NULL); self->widget = gtk_vbox_new (FALSE,DT_GUI_IOP_MODULE_CONTROL_SPACING); /* create the zone preview widget */ const int panel_width = dt_conf_get_int("panel_width") * 0.8; g->preview = gtk_drawing_area_new(); g_signal_connect (G_OBJECT (g->preview), "expose-event", G_CALLBACK (dt_iop_zonesystem_preview_expose), self); gtk_widget_add_events (GTK_WIDGET (g->preview), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); gtk_widget_set_size_request(g->preview, panel_width, panel_width); /* create the zonesystem bar widget */ g->zones = gtk_drawing_area_new(); g_object_set (GTK_OBJECT(g->zones), "tooltip-text", _("lightness zones\nuse mouse scrollwheel to change the number of zones\nleft-click on a border to create a marker\nright-click on a marker to delete it"), (char *)NULL); g_signal_connect (G_OBJECT (g->zones), "expose-event", G_CALLBACK (dt_iop_zonesystem_bar_expose), self); g_signal_connect (G_OBJECT (g->zones), "motion-notify-event", G_CALLBACK (dt_iop_zonesystem_bar_motion_notify), self); g_signal_connect (G_OBJECT (g->zones), "leave-notify-event", G_CALLBACK (dt_iop_zonesystem_bar_leave_notify), self); g_signal_connect (G_OBJECT (g->zones), "button-press-event", G_CALLBACK (dt_iop_zonesystem_bar_button_press), self); g_signal_connect (G_OBJECT (g->zones), "button-release-event", G_CALLBACK (dt_iop_zonesystem_bar_button_release), self); g_signal_connect (G_OBJECT (g->zones), "scroll-event", G_CALLBACK (dt_iop_zonesystem_bar_scrolled), self); gtk_widget_add_events (GTK_WIDGET (g->zones), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK); gtk_widget_set_size_request(g->zones, -1, DT_PIXEL_APPLY_DPI(40)); gtk_box_pack_start (GTK_BOX (self->widget),g->preview,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX (self->widget),g->zones,TRUE,TRUE,0); /* add signal handler for preview pipe finish to redraw the preview */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED, G_CALLBACK(_iop_zonesystem_redraw_preview_callback), self); /* load the dt logo as a brackground */ g->image = NULL; g->image_buffer = NULL; g->image_width = 0; g->image_height = 0; char filename[PATH_MAX]; char datadir[PATH_MAX]; const char *logo = is_it_xmas()?"%s/pixmaps/idbutton-2.svg":"%s/pixmaps/idbutton.svg"; dt_loc_get_datadir(datadir, sizeof(datadir)); snprintf(filename, sizeof(filename), logo, datadir); RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL); if(svg) { cairo_surface_t *surface; cairo_t *cr; RsvgDimensionData dimension; rsvg_handle_get_dimensions(svg, &dimension); float svg_size = MAX(dimension.width, dimension.height); float final_size = panel_width * 0.75; float factor = final_size / svg_size; float final_width = dimension.width * factor, final_height = dimension.height * factor; int stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, final_width); g->image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8)); surface = cairo_image_surface_create_for_data(g->image_buffer, CAIRO_FORMAT_ARGB32, final_width, final_height, stride); if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { free(g->image_buffer); g->image_buffer = NULL; } else { cr = cairo_create(surface); cairo_scale(cr, factor, factor); rsvg_handle_render_cairo(svg, cr); cairo_surface_flush(surface); g->image = surface; g->image_width = final_width; g->image_height = final_height; } g_object_unref(svg); } }