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);
}
}