static void
gtk_radio_menu_item_activate (GtkMenuItem *menu_item)
{
GtkRadioMenuItem *radio_menu_item;
GtkCheckMenuItem *check_menu_item;
GtkCheckMenuItem *tmp_menu_item;
GSList *tmp_list;
gint toggled;
g_return_if_fail (GTK_IS_RADIO_MENU_ITEM (menu_item));
radio_menu_item = GTK_RADIO_MENU_ITEM (menu_item);
check_menu_item = GTK_CHECK_MENU_ITEM (menu_item);
toggled = FALSE;
if (check_menu_item->active)
{
tmp_menu_item = NULL;
tmp_list = radio_menu_item->group;
while (tmp_list)
{
tmp_menu_item = tmp_list->data;
tmp_list = tmp_list->next;
if (tmp_menu_item->active && (tmp_menu_item != check_menu_item))
break;
tmp_menu_item = NULL;
}
if (tmp_menu_item)
{
toggled = TRUE;
check_menu_item->active = !check_menu_item->active;
}
}
else
{
toggled = TRUE;
check_menu_item->active = !check_menu_item->active;
tmp_list = radio_menu_item->group;
while (tmp_list)
{
tmp_menu_item = tmp_list->data;
tmp_list = tmp_list->next;
if (tmp_menu_item->active && (tmp_menu_item != check_menu_item))
{
gtk_menu_item_activate (GTK_MENU_ITEM (tmp_menu_item));
break;
}
}
}
if (toggled)
gtk_check_menu_item_toggled (check_menu_item);
gtk_widget_queue_draw (GTK_WIDGET (radio_menu_item));
}
/**
* undo_redo:
* @w: not used
* @data: not used
*
* executes a redo request on the current document
**/
void undo_redo(UndoMain *undostruct)
{
UndoInfo *redoinfo;
GtkTextView *textview;
GtkTextBuffer *buffer;
GtkTextIter iter, start_iter, end_iter;
GtkTextMark *mark;
g_return_if_fail(undostruct != NULL);
if (undostruct->redo == NULL) return;
redoinfo = (UndoInfo *)undostruct->redo->data;
g_return_if_fail (redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
textview = undostruct->textview;
buffer = gtk_text_view_get_buffer(textview);
undo_block(undostruct);
/* Check if there is a selection active */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(buffer, &iter);
/* Move the view to the right position. */
gtk_adjustment_set_value(textview->vadjustment,
redoinfo->window_position);
switch (redoinfo->action) {
case UNDO_ACTION_INSERT:
gtk_text_buffer_get_iter_at_offset
(buffer, &iter, redoinfo->start_pos);
gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
debug_print("redo: UNDO_ACTION_DELETE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
break;
case UNDO_ACTION_DELETE:
gtk_text_buffer_get_iter_at_offset
(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset
(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
debug_print("redo: UNDO_ACTION_INSERT: %d: delete %d chars\n",
redoinfo->start_pos,
redoinfo->end_pos - redoinfo->start_pos);
break;
case UNDO_ACTION_REPLACE_DELETE:
gtk_text_buffer_get_iter_at_offset
(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset
(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
debug_print("redo: UNDO_ACTION_REPLACE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
/* "pull" another data structure from the list */
redoinfo = (UndoInfo *)undostruct->redo->data;
g_return_if_fail(redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
g_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT);
gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1);
debug_print("redo: UNDO_ACTION_REPLACE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
break;
case UNDO_ACTION_REPLACE_INSERT:
g_warning("redo: this should not happen: UNDO_REPLACE_INSERT");
break;
default:
g_assert_not_reached();
break;
}
gtk_widget_queue_draw(GTK_WIDGET(textview));
undostruct->change_state_func(undostruct,
UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
undostruct->change_state_data);
if (undostruct->redo == NULL)
undostruct->change_state_func(undostruct,
UNDO_STATE_UNCHANGED,
UNDO_STATE_FALSE,
undostruct->change_state_data);
undo_unblock(undostruct);
}
int dt_control_key_pressed(guint key, guint state)
{
int handled = dt_view_manager_key_pressed(darktable.view_manager, key, state);
if(handled) gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return handled;
}
void gui_update(struct dt_iop_module_t *self)
{
// nothing to do, gui curve is read directly from params during expose event.
gtk_widget_queue_draw(self->widget);
}
static void _lib_modulelist_gui_update(struct dt_lib_module_t *module)
{
gtk_widget_queue_draw(GTK_WIDGET(((dt_lib_modulelist_t *)module->data)->tree));
}
static gboolean _gtk_widget_queue_draw(gpointer user_data)
{
gtk_widget_queue_draw(GTK_WIDGET(user_data));
return FALSE;
}
static gboolean
gimp_tag_popup_list_event (GtkWidget *widget,
GdkEvent *event,
GimpTagPopup *popup)
{
if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *button_event = (GdkEventButton *) event;
gint x;
gint y;
gint i;
popup->single_select_disabled = TRUE;
x = button_event->x;
y = button_event->y + popup->scroll_y;
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
if (gimp_tag_popup_is_in_tag (tag_data, x, y))
{
gimp_tag_popup_toggle_tag (popup, tag_data);
gtk_widget_queue_draw (widget);
break;
}
}
}
else if (event->type == GDK_MOTION_NOTIFY)
{
GdkEventMotion *motion_event = (GdkEventMotion *) event;
PopupTagData *prelight = NULL;
gint x;
gint y;
gint i;
x = motion_event->x;
y = motion_event->y + popup->scroll_y;
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
if (gimp_tag_popup_is_in_tag (tag_data, x, y))
{
prelight = tag_data;
break;
}
}
if (prelight != popup->prelight)
{
if (popup->prelight)
gimp_tag_popup_queue_draw_tag (popup, popup->prelight);
popup->prelight = prelight;
if (popup->prelight)
gimp_tag_popup_queue_draw_tag (popup, popup->prelight);
}
}
else if (event->type == GDK_BUTTON_RELEASE &&
! popup->single_select_disabled)
{
GdkEventButton *button_event = (GdkEventButton *) event;
gint x;
gint y;
gint i;
popup->single_select_disabled = TRUE;
x = button_event->x;
y = button_event->y + popup->scroll_y;
for (i = 0; i < popup->tag_count; i++)
{
PopupTagData *tag_data = &popup->tag_data[i];
if (gimp_tag_popup_is_in_tag (tag_data, x, y))
{
gimp_tag_popup_toggle_tag (popup, tag_data);
gtk_widget_destroy (GTK_WIDGET (popup));
break;
}
}
}
return FALSE;
}
gint histo_update_time_window_hook(void *hook_data, void *call_data)
{
HistoControlFlowData *histocontrol_flow_data = (HistoControlFlowData*) hook_data;
histoDrawing_t *drawing = histocontrol_flow_data->drawing;
const TimeWindowNotifyData *histo_time_window_nofify_data =
((const TimeWindowNotifyData *)call_data);
TimeWindow *histo_old_time_window =
histo_time_window_nofify_data->old_time_window;
TimeWindow *histo_new_time_window =
histo_time_window_nofify_data->new_time_window;
// Update the ruler
histo_drawing_update_ruler(drawing,
histo_new_time_window);
/* Two cases : zoom in/out or scrolling */
/* In order to make sure we can reuse the old drawing, the scale must
* be the same and the new time interval being partly located in the
* currently shown time interval. (reuse is only for scrolling)
*/
g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
histo_old_time_window->start_time.tv_sec,
histo_old_time_window->start_time.tv_nsec,
histo_old_time_window->time_width.tv_sec,
histo_old_time_window->time_width.tv_nsec);
g_info("New time window HOOK : %lu, %lu to %lu, %lu",
histo_new_time_window->start_time.tv_sec,
histo_new_time_window->start_time.tv_nsec,
histo_new_time_window->time_width.tv_sec,
histo_new_time_window->time_width.tv_nsec);
//For Histo,redraw always except if zoom fit is pushed 2 times consequently
if( histo_new_time_window->start_time.tv_sec == histo_old_time_window->start_time.tv_sec
&& histo_new_time_window->start_time.tv_nsec == histo_old_time_window->start_time.tv_nsec
&& histo_new_time_window->time_width.tv_sec == histo_old_time_window->time_width.tv_sec
&& histo_new_time_window->time_width.tv_nsec == histo_old_time_window->time_width.tv_nsec)
{
return 0;
}
histo_rectangle_pixmap (drawing->drawing_area->style->black_gc,
TRUE,
0, 0,
drawing->width,//+SAFETY, // do not overlap
-1,drawing);
drawing->damage_begin = 0;
drawing->damage_end = drawing->width;
gtk_widget_queue_draw(drawing->drawing_area);
histo_request_event(histocontrol_flow_data,drawing->damage_begin,
drawing->damage_end- drawing->damage_begin);
gdk_window_process_updates(drawing->drawing_area->window,TRUE);
//show number of event at current time
histo_drawing_update_vertical_ruler(drawing);
return 0;
}
gint histo_update_current_time_hook(void *hook_data, void *call_data)
{
HistoControlFlowData *histocontrol_flow_data = (HistoControlFlowData*)hook_data;
histoDrawing_t *drawing = histocontrol_flow_data->drawing;
LttTime current_time = *((LttTime*)call_data);
TimeWindow time_window =
lttvwindow_get_time_window(histocontrol_flow_data->tab);
LttTime time_begin = time_window.start_time;
LttTime width = time_window.time_width;
LttTime half_width;
{
guint64 time_ll = ltt_time_to_uint64(width);
time_ll = time_ll >> 1; /* divide by two */
half_width = ltt_time_from_uint64(time_ll);
}
LttTime time_end = ltt_time_add(time_begin, width);
LttvTraceset *traceset =
lttvwindow_get_traceset(histocontrol_flow_data->tab);
TimeInterval time_span = lttv_traceset_get_time_span_real(traceset);
LttTime trace_start = time_span.start_time;
LttTime trace_end = time_span.end_time;
g_info("Histogram: New current time HOOK : %lu, %lu", current_time.tv_sec,
current_time.tv_nsec);
/* If current time is inside time interval, just move the highlight
* bar */
/* Else, we have to change the time interval. We have to tell it
* to the main window. */
/* The time interval change will take care of placing the current
* time at the center of the visible area, or nearest possible if we are
* at one end of the trace. */
if(ltt_time_compare(current_time, time_begin) < 0)
{
TimeWindow histo_new_time_window;
if(ltt_time_compare(current_time,
ltt_time_add(trace_start,half_width)) < 0)
time_begin = trace_start;
else
time_begin = ltt_time_sub(current_time,half_width);
histo_new_time_window.start_time = time_begin;
histo_new_time_window.time_width = width;
histo_new_time_window.time_width_double = ltt_time_to_double(width);
histo_new_time_window.end_time = ltt_time_add(time_begin, width);
lttvwindow_report_time_window(histocontrol_flow_data->tab, histo_new_time_window);
}
else if(ltt_time_compare(current_time, time_end) > 0)
{
TimeWindow histo_new_time_window;
if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
time_begin = ltt_time_sub(trace_end,width);
else
time_begin = ltt_time_sub(current_time,half_width);
histo_new_time_window.start_time = time_begin;
histo_new_time_window.time_width = width;
histo_new_time_window.time_width_double = ltt_time_to_double(width);
histo_new_time_window.end_time = ltt_time_add(time_begin, width);
lttvwindow_report_time_window(histocontrol_flow_data->tab, histo_new_time_window);
}
gtk_widget_queue_draw(drawing->drawing_area);
/* Update directly when scrolling */
gdk_window_process_updates(drawing->drawing_area->window,
TRUE);
histo_drawing_update_vertical_ruler(drawing);
return 0;
}
static void
_lib_filmstrip_dnd_begin_callback(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
const int ts = 64;
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data;
int imgid = strip->mouse_over_id;
// imgid part of selection -> do nothing
// otherwise -> select the current image
strip->select = DT_LIB_FILMSTRIP_SELECT_NONE;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from selected_images where imgid=?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
dt_selection_select_single(darktable.selection, imgid);
/* redraw filmstrip */
if(darktable.view_manager->proxy.filmstrip.module)
gtk_widget_queue_draw(darktable.view_manager->proxy.filmstrip.module->widget);
}
sqlite3_finalize(stmt);
// if we are dragging a single image -> use the thumbnail of that image
// otherwise use the generic d&d icon
// TODO: have something pretty in the 2nd case, too.
if(dt_collection_get_selected_count(NULL) == 1)
{
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, DT_MIPMAP_BLOCKING);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
gtk_drag_set_icon_pixbuf(context, scaled, 0, 0);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
free(scratchmem);
g_free(rgbbuf);
}
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
}
static gboolean _lib_filmstrip_button_press_callback(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data;
int32_t mouse_over_id = strip->mouse_over_id;
strip->select = DT_LIB_FILMSTRIP_SELECT_NONE;
if (e->button == 1)
{
if(e->type == GDK_BUTTON_PRESS)
{
/* let check if any thumb controls was clicked */
switch(strip->image_over)
{
case DT_VIEW_DESERT:
/* is this an activation of image */
if ((e->state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == 0)
strip->select = DT_LIB_FILMSTRIP_SELECT_SINGLE;
else if ((e->state & (GDK_CONTROL_MASK)) == GDK_CONTROL_MASK)
strip->select = DT_LIB_FILMSTRIP_SELECT_TOGGLE;
else if ((e->state & (GDK_SHIFT_MASK)) == GDK_SHIFT_MASK)
strip->select = DT_LIB_FILMSTRIP_SELECT_RANGE;
if(strip->select != DT_LIB_FILMSTRIP_SELECT_NONE)
{
strip->select_id = mouse_over_id;
return TRUE;
}
break;
case DT_VIEW_REJECT:
case DT_VIEW_STAR_1:
case DT_VIEW_STAR_2:
case DT_VIEW_STAR_3:
case DT_VIEW_STAR_4:
case DT_VIEW_STAR_5:
{
int offset = 0;
if(mouse_over_id == strip->activated_image)
offset = dt_collection_image_offset(mouse_over_id);
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, mouse_over_id);
dt_image_t *image = dt_image_cache_write_get(darktable.image_cache, cimg);
if(strip->image_over == DT_VIEW_STAR_1 && ((image->flags & 0x7) == 1)) image->flags &= ~0x7;
else if(strip->image_over == DT_VIEW_REJECT && ((image->flags & 0x7) == 6)) image->flags &= ~0x7;
else
{
image->flags &= ~0x7;
image->flags |= strip->image_over;
}
dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_SAFE);
dt_image_cache_read_release(darktable.image_cache, image);
dt_collection_hint_message(darktable.collection); // More than this, we need to redraw all
if(mouse_over_id == strip->activated_image)
if(_lib_filmstrip_imgid_in_collection(darktable.collection, mouse_over_id) == 0)
dt_view_filmstrip_scroll_relative(0, offset);
gtk_widget_queue_draw(darktable.view_manager->proxy.filmstrip.module->widget);
return TRUE;
}
default:
return FALSE;
}
}
else if(e->type == GDK_2BUTTON_PRESS)
{
if (mouse_over_id > 0)
{
strip->activated_image = mouse_over_id;
dt_control_signal_raise(darktable.signals, DT_SIGNAL_VIEWMANAGER_FILMSTRIP_ACTIVATE);
return TRUE;
}
}
}
return FALSE;
}
/* Timeout handler to regenerate the frame */
static gint
timeout (gpointer data)
{
double f;
int i;
double xmid, ymid;
double radius;
gdk_pixbuf_copy_area (background, 0, 0, back_width, back_height,
frame, 0, 0);
f = (double) (frame_num % CYCLE_LEN) / CYCLE_LEN;
xmid = back_width / 2.0;
ymid = back_height / 2.0;
radius = MIN (xmid, ymid) / 2.0;
for (i = 0; i < N_IMAGES; i++)
{
double ang;
int xpos, ypos;
int iw, ih;
double r;
GdkRectangle r1, r2, dest;
double k;
ang = 2.0 * G_PI * (double) i / N_IMAGES - f * 2.0 * G_PI;
iw = gdk_pixbuf_get_width (images[i]);
ih = gdk_pixbuf_get_height (images[i]);
r = radius + (radius / 3.0) * sin (f * 2.0 * G_PI);
xpos = floor (xmid + r * cos (ang) - iw / 2.0 + 0.5);
ypos = floor (ymid + r * sin (ang) - ih / 2.0 + 0.5);
k = (i & 1) ? sin (f * 2.0 * G_PI) : cos (f * 2.0 * G_PI);
k = 2.0 * k * k;
k = MAX (0.25, k);
r1.x = xpos;
r1.y = ypos;
r1.width = iw * k;
r1.height = ih * k;
r2.x = 0;
r2.y = 0;
r2.width = back_width;
r2.height = back_height;
if (gdk_rectangle_intersect (&r1, &r2, &dest))
gdk_pixbuf_composite (images[i],
frame,
dest.x, dest.y,
dest.width, dest.height,
xpos, ypos,
k, k,
GDK_INTERP_NEAREST,
((i & 1)
? MAX (127, fabs (255 * sin (f * 2.0 * G_PI)))
: MAX (127, fabs (255 * cos (f * 2.0 * G_PI)))));
}
GDK_THREADS_ENTER ();
gtk_widget_queue_draw (da);
GDK_THREADS_LEAVE ();
frame_num++;
return TRUE;
}
/* Handler to regenerate the frame */
static gboolean
on_tick (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer data)
{
gint64 current_time;
double f;
int i;
double xmid, ymid;
double radius;
gdk_pixbuf_copy_area (background, 0, 0, back_width, back_height,
frame, 0, 0);
if (start_time == 0)
start_time = gdk_frame_clock_get_frame_time (frame_clock);
current_time = gdk_frame_clock_get_frame_time (frame_clock);
f = ((current_time - start_time) % CYCLE_TIME) / (double)CYCLE_TIME;
xmid = back_width / 2.0;
ymid = back_height / 2.0;
radius = MIN (xmid, ymid) / 2.0;
for (i = 0; i < N_IMAGES; i++)
{
double ang;
int xpos, ypos;
int iw, ih;
double r;
GdkRectangle r1, r2, dest;
double k;
ang = 2.0 * G_PI * (double) i / N_IMAGES - f * 2.0 * G_PI;
iw = gdk_pixbuf_get_width (images[i]);
ih = gdk_pixbuf_get_height (images[i]);
r = radius + (radius / 3.0) * sin (f * 2.0 * G_PI);
xpos = floor (xmid + r * cos (ang) - iw / 2.0 + 0.5);
ypos = floor (ymid + r * sin (ang) - ih / 2.0 + 0.5);
k = (i & 1) ? sin (f * 2.0 * G_PI) : cos (f * 2.0 * G_PI);
k = 2.0 * k * k;
k = MAX (0.25, k);
r1.x = xpos;
r1.y = ypos;
r1.width = iw * k;
r1.height = ih * k;
r2.x = 0;
r2.y = 0;
r2.width = back_width;
r2.height = back_height;
if (gdk_rectangle_intersect (&r1, &r2, &dest))
gdk_pixbuf_composite (images[i],
frame,
dest.x, dest.y,
dest.width, dest.height,
xpos, ypos,
k, k,
GDK_INTERP_NEAREST,
((i & 1)
? MAX (127, fabs (255 * sin (f * 2.0 * G_PI)))
: MAX (127, fabs (255 * cos (f * 2.0 * G_PI)))));
}
gtk_widget_queue_draw (da);
return G_SOURCE_CONTINUE;
}
G_MODULE_EXPORT gboolean
live_preview_cb(GstBus *bus, GstMessage *msg, gpointer data)
{
signal_user_data_t *ud = (signal_user_data_t*)data;
switch (GST_MESSAGE_TYPE(msg))
{
case GST_MESSAGE_UNKNOWN:
{
//printf("unknown");
} break;
case GST_MESSAGE_EOS:
{
// Done
//printf("eos\n");
live_preview_stop(ud);
gst_element_seek(ud->preview->play, 1.0,
GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
GST_SEEK_TYPE_SET, 0,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
} break;
case GST_MESSAGE_ERROR:
{
//printf("error\n");
GError *err;
gchar *debug;
gst_message_parse_error(msg, &err, &debug);
g_warning("Gstreamer Error: %s", err->message);
g_error_free(err);
g_free(debug);
} break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_INFO:
case GST_MESSAGE_TAG:
case GST_MESSAGE_BUFFERING:
case GST_MESSAGE_STATE_CHANGED:
{
//printf("state change %x\n", state);
GstState state, pending;
gst_element_get_state(ud->preview->play, &state, &pending, 0);
if (state == GST_STATE_PAUSED || state == GST_STATE_PLAYING)
{
update_stream_info(ud);
}
} break;
case GST_MESSAGE_STATE_DIRTY:
{
//printf("state dirty\n");
} break;
case GST_MESSAGE_STEP_DONE:
{
//printf("step done\n");
} break;
case GST_MESSAGE_CLOCK_PROVIDE:
{
//printf("clock provide\n");
} break;
case GST_MESSAGE_CLOCK_LOST:
{
//printf("clock lost\n");
} break;
case GST_MESSAGE_NEW_CLOCK:
{
//printf("new clock\n");
} break;
case GST_MESSAGE_STRUCTURE_CHANGE:
{
//printf("structure change\n");
} break;
case GST_MESSAGE_STREAM_STATUS:
{
//printf("stream status\n");
} break;
case GST_MESSAGE_APPLICATION:
{
//printf("application\n");
} break;
case GST_MESSAGE_ELEMENT:
{
//printf("element\n");
if (gst_is_missing_plugin_message(msg))
{
GtkWindow *hb_window;
hb_window = GTK_WINDOW(GHB_WIDGET(ud->builder, "hb_window"));
gst_element_set_state(ud->preview->play, GST_STATE_PAUSED);
gchar *message, *desc;
desc = gst_missing_plugin_message_get_description(msg);
message = g_strdup_printf(
_("Missing GStreamer plugin\n"
"Audio or Video may not play as expected\n\n%s"),
desc);
ghb_message_dialog(hb_window, GTK_MESSAGE_WARNING,
message, "Ok", NULL);
g_free(message);
gst_element_set_state(ud->preview->play, GST_STATE_PLAYING);
}
else if (msg->src == GST_OBJECT_CAST(ud->preview->vsink))
{
const GstStructure *gstStruct;
const GValue *val;
gstStruct = gst_message_get_structure(msg);
if (gstStruct != NULL &&
(gst_structure_has_name(gstStruct, "preroll-pixbuf") ||
gst_structure_has_name(gstStruct, "pixbuf")))
{
val = gst_structure_get_value(gstStruct, "pixbuf");
if (val != NULL)
{
GdkPixbuf * pix;
GtkWidget *widget;
int width, height;
if (ud->preview->pix != NULL)
g_object_unref(ud->preview->pix);
if (ud->preview->scaled_pix != NULL)
g_object_unref(ud->preview->scaled_pix);
pix = GDK_PIXBUF(g_value_dup_object(val));
width = gdk_pixbuf_get_width(pix);
height = gdk_pixbuf_get_height(pix);
if (width != ud->preview->width ||
height != ud->preview->height ||
width != ud->preview->render_width ||
height != ud->preview->render_height)
{
double xscale, yscale;
xscale = (double)ud->preview->render_width /
ud->preview->width;
yscale = (double)ud->preview->render_height /
ud->preview->height;
if (xscale <= yscale)
{
width = ud->preview->render_width;
height = ud->preview->height * xscale;
}
else
{
width = ud->preview->width * yscale;
height = ud->preview->render_height;
}
ud->preview->scaled_pix =
gdk_pixbuf_scale_simple(pix,
width, height,
GDK_INTERP_BILINEAR);
g_object_ref(pix);
}
else
{
ud->preview->scaled_pix = pix;
}
ud->preview->pix = ud->preview->scaled_pix;
g_object_ref(ud->preview->pix);
widget = GHB_WIDGET (ud->builder, "preview_image");
gtk_widget_queue_draw(widget);
}
}
}
} break;
case GST_MESSAGE_SEGMENT_START:
{
//printf("segment start\n");
} break;
case GST_MESSAGE_SEGMENT_DONE:
{
//printf("segment done\n");
} break;
case GST_MESSAGE_DURATION_CHANGED:
{
//printf("duration change\n");
};
case GST_MESSAGE_LATENCY:
{
//printf("latency\n");
};
case GST_MESSAGE_ASYNC_START:
{
//printf("async start\n");
} break;
case GST_MESSAGE_ASYNC_DONE:
{
//printf("async done\n");
} break;
case GST_MESSAGE_REQUEST_STATE:
{
//printf("request state\n");
} break;
case GST_MESSAGE_STEP_START:
{
//printf("step start\n");
} break;
case GST_MESSAGE_QOS:
{
//printf("qos\n");
} break;
case GST_MESSAGE_PROGRESS:
{
//printf("progress\n");
} break;
case GST_MESSAGE_TOC:
{
//printf("toc\n");
} break;
case GST_MESSAGE_RESET_TIME:
{
//printf("reset time\n");
} break;
case GST_MESSAGE_STREAM_START:
{
//printf("stream start\n");
};
case GST_MESSAGE_ANY:
{
//printf("any\n");
} break;
default:
{
// Ignore
//printf("?msg? %x\n", GST_MESSAGE_TYPE(msg));
}
}
return TRUE;
}
static gboolean on_motion_notify_desklet (GtkWidget *pWidget,
GdkEventMotion* pMotion,
CairoDesklet *pDesklet)
{
/*if (pMotion->state & GDK_BUTTON1_MASK && cairo_dock_desklet_is_free (pDesklet))
{
cd_debug ("root : %d;%d", (int) pMotion->x_root, (int) pMotion->y_root);
}
else*/ // le 'press-button' est local au sous-widget clique, alors que le 'motion-notify' est global a la fenetre; c'est donc par lui qu'on peut avoir a coup sur les coordonnees du curseur (juste avant le clic).
{
pDesklet->container.iMouseX = pMotion->x;
pDesklet->container.iMouseY = pMotion->y;
gboolean bStartAnimation = FALSE;
gldi_object_notify (pDesklet, NOTIFICATION_MOUSE_MOVED, pDesklet, &bStartAnimation);
if (bStartAnimation)
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
if (pDesklet->rotating && cairo_dock_desklet_is_free (pDesklet))
{
double alpha = atan2 (pDesklet->container.iHeight, - pDesklet->container.iWidth);
pDesklet->fRotation = alpha - atan2 (.5*pDesklet->container.iHeight - pMotion->y, pMotion->x - .5*pDesklet->container.iWidth);
while (pDesklet->fRotation > G_PI)
pDesklet->fRotation -= 2 * G_PI;
while (pDesklet->fRotation <= - G_PI)
pDesklet->fRotation += 2 * G_PI;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pDesklet->rotatingY && cairo_dock_desklet_is_free (pDesklet))
{
pDesklet->fDepthRotationY = G_PI * (pMotion->x - .5*pDesklet->container.iWidth) / pDesklet->container.iWidth;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pDesklet->rotatingX && cairo_dock_desklet_is_free (pDesklet))
{
pDesklet->fDepthRotationX = G_PI * (pMotion->y - .5*pDesklet->container.iHeight) / pDesklet->container.iHeight;
gtk_widget_queue_draw(pDesklet->container.pWidget);
}
else if (pMotion->state & GDK_BUTTON1_MASK && cairo_dock_desklet_is_free (pDesklet) && ! pDesklet->moving)
{
gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (pWidget)),
1/*pButton->button*/,
pMotion->x_root/*pButton->x_root*/,
pMotion->y_root/*pButton->y_root*/,
pDesklet->time/*pButton->time*/);
pDesklet->moving = TRUE;
}
else
{
gboolean bStartAnimation = FALSE;
Icon *pIcon = gldi_desklet_find_clicked_icon (pDesklet);
if (pIcon != NULL)
{
if (! pIcon->bPointed)
{
Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDesklet->icons);
if (pPointedIcon != NULL)
pPointedIcon->bPointed = FALSE;
pIcon->bPointed = TRUE;
//g_print ("on survole %s\n", pIcon->cName);
gldi_object_notify (pDesklet, NOTIFICATION_ENTER_ICON, pIcon, pDesklet, &bStartAnimation);
}
}
else
{
Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDesklet->icons);
if (pPointedIcon != NULL)
{
pPointedIcon->bPointed = FALSE;
//g_print ("kedal\n");
//gldi_object_notify (pDesklet, NOTIFICATION_ENTER_ICON, pPointedIcon, pDesklet, &bStartAnimation);
}
}
if (bStartAnimation)
{
cairo_dock_launch_animation (CAIRO_CONTAINER (pDesklet));
}
}
gdk_device_get_state (pMotion->device, pMotion->window, NULL, NULL); // pour recevoir d'autres MotionNotify.
return FALSE;
}
static gboolean
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
widget_data_t *data = get_widget_data(widget);
data->mouse_down = map_location(data, _point(event->x, event->y));
designer_node_t *hn = NULL;
_hit_t ht = HIT_NOTHING;
int hs = -1;
/* check for best node hit */
for (GSList *list = data->design->nodes;
list != NULL; list = list->next) {
designer_node_t *node = list->data;
_hit_t nht = hit_node(node, data->mouse_down);
if (nht) {
hn = node;
ht = nht;
}
}
if (event->type == GDK_2BUTTON_PRESS)
return double_click_event(widget, event, hn, ht);
switch(ht) {
case HIT_LABEL:
case HIT_TITLE:
case HIT_BODY:
data->active_node = hn;
data->state = STATE_MOVING;
data->origin = node_data(hn)->origin;
designer_node_push_back(hn);
break;
case HIT_CLOSE:
designer_disconnect_and_delete_node(hn);
promote_focus(data);
signal_design_change(data);
update_area_conditional(data, FALSE);
break;
case HIT_INPUT:
hs = hit_input_slot(hn, data->mouse_down);
/* loosen connection if connected */
if (data->target_check == DESIGNER_CONNECTION_CONNECTABLE) {
loosen_connection(data, hn, hs);
data->state = STATE_CONOUT;
break;
}
data->active_node = hn;
data->active_slot_id = hs;
data->origin = input_slot_origin(hn, hs);
// g_print("hit %lf,%lf -> %d\n", event->x, event->y, data->active_slot_id);
data->state = STATE_CONIN;
break;
case HIT_OUTPUT:
hs = hit_output_slot(hn, data->mouse_down);
data->active_node = hn;
data->active_slot_id = hs;
data->origin = output_slot_origin(hn, data->active_slot_id);
// g_print("hit %lf,%lf -> %d\n", event->x, event->y, data->active_slot_Id);
data->state = STATE_CONOUT;
break;
default:
data->state = STATE_IDLE;
break;
}
data->dragging = TRUE;
gtk_widget_queue_draw(widget);
return TRUE;
}
static gboolean
gtk_switch_button_release (GtkWidget *widget,
GdkEventButton *event)
{
GtkSwitchPrivate *priv = GTK_SWITCH (widget)->priv;
GtkAllocation allocation;
/* Don't handle extra mouse buttons events, let them bubble up */
if (event->button > 5)
return GDK_EVENT_PROPAGATE;
gtk_widget_get_allocation (widget, &allocation);
/* dragged toggles have a "soft" grab, so we don't care whether we
* are in the switch or not when the button is released; we do care
* for direct toggles, instead
*/
if (!priv->is_dragging && !priv->in_switch)
return GDK_EVENT_PROPAGATE;
/* direct toggle */
if (priv->in_press)
{
priv->in_press = FALSE;
gtk_switch_set_active (GTK_SWITCH (widget), !priv->is_active);
return GDK_EVENT_STOP;
}
/* toggle the switch if the handle was clicked but a drag had not been
* initiated */
if (!priv->is_dragging && !priv->in_press)
{
gtk_switch_set_active (GTK_SWITCH (widget), !priv->is_active);
return GDK_EVENT_STOP;
}
/* dragged toggle */
if (priv->is_dragging)
{
priv->is_dragging = FALSE;
/* if half the handle passed the middle of the switch, then we
* consider it to be on
*/
if ((priv->handle_x + (allocation.width / 4)) >= (allocation.width / 2))
{
gtk_switch_set_active (GTK_SWITCH (widget), TRUE);
priv->handle_x = allocation.width / 2;
}
else
{
gtk_switch_set_active (GTK_SWITCH (widget), FALSE);
priv->handle_x = 0;
}
gtk_widget_queue_draw (widget);
return GDK_EVENT_STOP;
}
return GDK_EVENT_PROPAGATE;
}
static void
photos_print_preview_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
PhotosPrintPreviewPrivate *priv = PHOTOS_PRINT_PREVIEW (object)->priv;
gboolean paper_size_changed = FALSE;
switch (prop_id) {
case PROP_PIXBUF:
if (priv->pixbuf) {
g_object_unref (priv->pixbuf);
}
priv->pixbuf = GDK_PIXBUF (g_value_dup_object (value));
if (priv->pixbuf_scaled) {
g_object_unref (priv->pixbuf_scaled);
priv->pixbuf_scaled = NULL;
}
priv->flag_create_surface = TRUE;
break;
case PROP_PIXBUF_X_ALIGN:
priv->pixbuf_x_align = g_value_get_float (value);
break;
case PROP_PIXBUF_Y_ALIGN:
priv->pixbuf_y_align = g_value_get_float (value);
break;
case PROP_PIXBUF_SCALE:
priv->i_scale = g_value_get_float (value);
priv->flag_create_surface = TRUE;
break;
case PROP_PAPER_WIDTH:
priv->p_width = g_value_get_float (value);
paper_size_changed = TRUE;
break;
case PROP_PAPER_HEIGHT:
priv->p_height = g_value_get_float (value);
paper_size_changed = TRUE;
break;
case PROP_PAGE_LEFT_MARGIN:
priv->l_margin = g_value_get_float (value);
break;
case PROP_PAGE_RIGHT_MARGIN:
priv->r_margin = g_value_get_float (value);
break;
case PROP_PAGE_TOP_MARGIN:
priv->t_margin = g_value_get_float (value);
break;
case PROP_PAGE_BOTTOM_MARGIN:
priv->b_margin = g_value_get_float (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
if (paper_size_changed) {
g_object_set (object,
"ratio", priv->p_width/priv->p_height,
NULL);
}
update_relative_sizes (PHOTOS_PRINT_PREVIEW (object));
gtk_widget_queue_draw (priv->area);
}
static gboolean lowlight_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_lowlight_gui_data_t *c = (dt_iop_lowlight_gui_data_t *)self->gui_data;
dt_iop_lowlight_params_t *p = (dt_iop_lowlight_params_t *)self->params;
const int inset = DT_IOP_LOWLIGHT_INSET;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int height = allocation.height - 2 * inset, width = allocation.width - 2 * inset;
if(!c->dragging) c->mouse_x = CLAMP(event->x - inset, 0, width) / (float)width;
c->mouse_y = 1.0 - CLAMP(event->y - inset, 0, height) / (float)height;
if(c->dragging)
{
*p = c->drag_params;
if(c->x_move >= 0)
{
const float mx = CLAMP(event->x - inset, 0, width) / (float)width;
if(c->x_move > 0 && c->x_move < DT_IOP_LOWLIGHT_BANDS - 1)
{
const float minx = p->transition_x[c->x_move - 1] + 0.001f;
const float maxx = p->transition_x[c->x_move + 1] - 0.001f;
p->transition_x[c->x_move] = fminf(maxx, fmaxf(minx, mx));
}
}
else
{
dt_iop_lowlight_get_params(p, c->mouse_x, c->mouse_y + c->mouse_pick, c->mouse_radius);
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
else if(event->y > height)
{
c->x_move = 0;
float dist = fabs(p->transition_x[0] - c->mouse_x);
for(int k = 1; k < DT_IOP_LOWLIGHT_BANDS; k++)
{
float d2 = fabs(p->transition_x[k] - c->mouse_x);
if(d2 < dist)
{
c->x_move = k;
dist = d2;
}
}
}
else
{
c->x_move = -1;
}
gtk_widget_queue_draw(widget);
gint x, y;
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(event->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(
gdk_window_get_display(event->window))),
&x, &y, 0);
#else
gdk_window_get_device_position(event->window,
gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(gdk_window_get_display(event->window))),
&x, &y, NULL);
#endif
return TRUE;
}
int vfo_update(void *data) {
BANDSTACK_ENTRY* entry=bandstack_entry_get_current();
FILTER* band_filters=filters[entry->mode];
FILTER* band_filter=&band_filters[entry->filter];
if(vfo_surface) {
cairo_t *cr;
cr = cairo_create (vfo_surface);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_paint (cr);
cairo_select_font_face(cr, "Arial",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_BOLD);
//cairo_set_font_size(cr, 36);
cairo_set_font_size(cr, 28);
if(isTransmitting()) {
cairo_set_source_rgb(cr, 1, 0, 0);
} else {
cairo_set_source_rgb(cr, 0, 1, 0);
}
long long f=entry->frequencyA+ddsOffset;
char sf[32];
//sprintf(sf,"%0lld.%06lld MHz",entry->frequencyA/(long long)1000000,entry->frequencyA%(long long)1000000);
sprintf(sf,"%0lld.%06lld MHz",f/(long long)1000000,f%(long long)1000000);
cairo_move_to(cr, 5, 30);
cairo_show_text(cr, sf);
cairo_set_font_size(cr, 12);
cairo_move_to(cr, (my_width/2)+40, 30);
//cairo_show_text(cr, getFrequencyInfo(entry->frequencyA));
cairo_show_text(cr, getFrequencyInfo(f));
sprintf(sf,"Step %dHz",step);
cairo_move_to(cr, (my_width/2)+40, 15);
cairo_show_text(cr, sf);
if(locked) {
cairo_set_source_rgb(cr, 1, 0, 0);
cairo_move_to(cr, 10, 50);
cairo_show_text(cr, "Locked");
}
if(function) {
cairo_set_source_rgb(cr, 1, 0.5, 0);
cairo_move_to(cr, 70, 50);
cairo_show_text(cr, "Function");
}
cairo_set_source_rgb(cr, 1, 1, 0);
cairo_move_to(cr, 130, 50);
cairo_show_text(cr, mode_string[entry->mode]);
cairo_move_to(cr, 190, 50);
cairo_show_text(cr, band_filter->title);
cairo_move_to(cr, 250, 50);
if(nr) {
cairo_show_text(cr, "NR");
}
if(nr2) {
cairo_show_text(cr, "NR2");
}
if(nb) {
cairo_show_text(cr, "NB");
}
if(nb2) {
cairo_show_text(cr, "NB2");
}
if(anf) {
cairo_show_text(cr, "ANF");
}
if(snb) {
cairo_show_text(cr, "SNB");
}
cairo_move_to(cr, 310, 50);
switch(agc) {
case AGC_OFF:
cairo_show_text(cr, "AGC OFF");
break;
case AGC_LONG:
cairo_show_text(cr, "AGC LONG");
break;
case AGC_SLOW:
cairo_show_text(cr, "AGC SLOW");
break;
case AGC_MEDIUM:
cairo_show_text(cr, "AGC MEDIUM");
break;
case AGC_FAST:
cairo_show_text(cr, "AGC FAST");
break;
}
cairo_destroy (cr);
gtk_widget_queue_draw (vfo);
} else {
fprintf(stderr,"vfo_update: no surface!\n");
}
return 0;
}
void
ags_navigation_init(AgsNavigation *navigation)
{
GtkHBox *hbox;
GtkLabel *label;
navigation->flags = 0;
navigation->soundcard = NULL;
g_signal_connect_after(G_OBJECT(navigation), "parent-set\0",
G_CALLBACK(ags_navigation_parent_set_callback), NULL);
/* GtkWidget */
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
gtk_box_pack_start((GtkBox *) navigation, (GtkWidget *) hbox, FALSE, FALSE, 2);
navigation->expander = (GtkToggleButton *) gtk_toggle_button_new();
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) navigation->expander, FALSE, FALSE, 2);
gtk_container_add((GtkContainer *) navigation->expander,
(GtkWidget *) gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE));
label = (GtkLabel *) gtk_label_new("bpm\0");
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->bpm = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 1000.0, 1.0);
navigation->bpm->adjustment->value = 120.0;
gtk_box_pack_start((GtkBox*) hbox, (GtkWidget *) navigation->bpm, FALSE, FALSE, 2);
navigation->current_bpm = 120.0;
navigation->rewind = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->rewind, FALSE, FALSE, 0);
navigation->previous = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->previous, FALSE, FALSE, 0);
navigation->play = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->play, FALSE, FALSE, 0);
navigation->stop = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->stop, FALSE, FALSE, 0);
navigation->next = (GtkButton *) g_object_new(GTK_TYPE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_NEXT, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->next, FALSE, FALSE, 0);
navigation->forward = (GtkToggleButton *) g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"image\0", (GtkWidget *) gtk_image_new_from_stock(GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_LARGE_TOOLBAR),
NULL);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->forward, FALSE, FALSE, 0);
navigation->loop = (GtkCheckButton *) gtk_check_button_new_with_label("loop\0");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(navigation->loop),
TRUE);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("position\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->position_time = (GtkLabel *) gtk_label_new(g_strdup("00:00.00\0"));
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->position_time, FALSE, FALSE, 2);
navigation->position_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, AGS_NOTE_EDIT_MAX_CONTROLS * 64.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->position_tact, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("duration\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->duration_time = (GtkLabel *) gtk_label_new(NULL);
g_object_set(navigation->duration_time,
"label\0", g_strdup("0000:00.00\0"),
NULL);
gtk_widget_queue_draw(navigation->duration_time);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->duration_time, FALSE, FALSE, 2);
navigation->duration_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, AGS_NOTE_EDIT_MAX_CONTROLS * 64.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->duration_tact, FALSE, FALSE, 2);
/* expansion */
hbox = (GtkHBox *) gtk_hbox_new(FALSE, 0);
// GTK_WIDGET_SET_FLAGS((GtkWidget *) hbox, GTK_NO_SHOW_ALL);
gtk_box_pack_start((GtkBox *) navigation, (GtkWidget *) hbox, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("loop L\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->loop_left_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 65000.0, 1.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop_left_tact, FALSE, FALSE, 2);
label = (GtkLabel *) gtk_label_new("loop R\0");
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) label, FALSE, FALSE, 2);
navigation->loop_right_tact = (GtkSpinButton *) gtk_spin_button_new_with_range(0.0, 65000.0, 1.0);
gtk_spin_button_set_value(navigation->loop_right_tact,
4.0);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->loop_right_tact, FALSE, FALSE, 2);
navigation->scroll = (GtkCheckButton *) gtk_check_button_new_with_label("auto-scroll\0");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(navigation->scroll),
TRUE);
gtk_box_pack_start((GtkBox *) hbox, (GtkWidget *) navigation->scroll, FALSE, FALSE, 2);
}
static gboolean _lib_histogram_motion_notify_callback(GtkWidget *widget, GdkEventMotion *event,
gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_histogram_t *d = (dt_lib_histogram_t *)self->data;
/* check if exposure hooks are available */
gboolean hooks_available = dt_dev_exposure_hooks_available(darktable.develop);
if(!hooks_available) return TRUE;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
if(d->dragging && d->highlight == 2)
{
float white = d->white - (event->x - d->button_down_x) * 1.0f / (float)allocation.width;
dt_dev_exposure_set_white(darktable.develop, white);
}
else if(d->dragging && d->highlight == 1)
{
float black = d->black - (event->x - d->button_down_x) * .1f / (float)allocation.width;
dt_dev_exposure_set_black(darktable.develop, black);
}
else
{
const float offs = 4 * DT_HIST_INSET;
const float x = event->x - offs;
const float y = event->y - DT_HIST_INSET;
const float pos = x / (float)(allocation.width - 2 * offs);
if(pos < 0 || pos > 1.0)
;
else if(x > d->mode_x && x < d->mode_x + d->mode_w && y > d->button_y && y < d->button_y + d->button_h)
{
d->highlight = 3;
switch(darktable.develop->histogram_type)
{
case DT_DEV_HISTOGRAM_LOGARITHMIC:
g_object_set(G_OBJECT(widget), "tooltip-text", _("set histogram mode to linear"), (char *)NULL);
break;
case DT_DEV_HISTOGRAM_LINEAR:
g_object_set(G_OBJECT(widget), "tooltip-text", _("set histogram mode to waveform"), (char *)NULL);
break;
case DT_DEV_HISTOGRAM_WAVEFORM:
g_object_set(G_OBJECT(widget), "tooltip-text", _("set histogram mode to logarithmic"), (char *)NULL);
break;
case DT_DEV_HISTOGRAM_N:
g_assert_not_reached();
}
}
else if(x > d->red_x && x < d->red_x + d->color_w && y > d->button_y && y < d->button_y + d->button_h)
{
d->highlight = 4;
g_object_set(G_OBJECT(widget), "tooltip-text",
d->red ? _("click to hide red channel") : _("click to show red channel"), (char *)NULL);
}
else if(x > d->green_x && x < d->green_x + d->color_w && y > d->button_y && y < d->button_y + d->button_h)
{
d->highlight = 5;
g_object_set(G_OBJECT(widget), "tooltip-text",
d->red ? _("click to hide green channel") : _("click to show green channel"),
(char *)NULL);
}
else if(x > d->blue_x && x < d->blue_x + d->color_w && y > d->button_y && y < d->button_y + d->button_h)
{
d->highlight = 6;
g_object_set(G_OBJECT(widget), "tooltip-text",
d->red ? _("click to hide blue channel") : _("click to show blue channel"), (char *)NULL);
}
else if(pos < 0.2)
{
d->highlight = 1;
g_object_set(G_OBJECT(widget), "tooltip-text", _("drag to change black point,\ndoubleclick resets"),
(char *)NULL);
}
else
{
d->highlight = 2;
g_object_set(G_OBJECT(widget), "tooltip-text", _("drag to change exposure,\ndoubleclick resets"),
(char *)NULL);
}
gtk_widget_queue_draw(widget);
}
gint x, y; // notify gtk for motion_hint.
gdk_window_get_device_position(event->window,
gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(gdk_window_get_display(event->window))),
&x, &y, NULL);
return TRUE;
}
void shoes_native_slot_paint(SHOES_SLOT_OS *slot)
{
gtk_widget_queue_draw(slot->canvas);
}
void MainWindow::updateViewport() {
GtkWidget *drawingArea = GTK_WIDGET(gtk_builder_get_object(_definitions, "drawingArea"));
gtk_widget_queue_draw(drawingArea);
}
static void on_composited_changed(GtkWidget* window, WindowData* windata)
{
windata->composited = gdk_screen_is_composited(gtk_widget_get_screen(window));
gtk_widget_queue_draw (windata->win);
}
static gboolean _cairo_dock_write_desklet_size (CairoDesklet *pDesklet)
{
if ((pDesklet->iDesiredWidth == 0 && pDesklet->iDesiredHeight == 0) && pDesklet->pIcon != NULL && pDesklet->pIcon->pModuleInstance != NULL && gldi_desklet_manager_is_ready ())
{
gchar *cSize = g_strdup_printf ("%d;%d", pDesklet->container.iWidth, pDesklet->container.iHeight);
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_STRING, "Desklet", "size", cSize,
G_TYPE_INVALID);
g_free (cSize);
gldi_object_notify (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
}
pDesklet->iSidWriteSize = 0;
pDesklet->iKnownWidth = pDesklet->container.iWidth;
pDesklet->iKnownHeight = pDesklet->container.iHeight;
if (((pDesklet->iDesiredWidth != 0 || pDesklet->iDesiredHeight != 0) && pDesklet->iDesiredWidth == pDesklet->container.iWidth && pDesklet->iDesiredHeight == pDesklet->container.iHeight) || (pDesklet->iDesiredWidth == 0 && pDesklet->iDesiredHeight == 0))
{
pDesklet->iDesiredWidth = 0;
pDesklet->iDesiredHeight = 0;
gldi_desklet_load_desklet_decorations (pDesklet); // reload the decorations at the new desklet size.
if (pDesklet->pIcon != NULL && pDesklet->pIcon->pModuleInstance != NULL)
{
// on recalcule la vue du desklet a la nouvelle dimension.
CairoDeskletRenderer *pRenderer = pDesklet->pRenderer;
if (pRenderer)
{
// on calcule les icones et les parametres internes de la vue.
if (pRenderer->calculate_icons != NULL)
pRenderer->calculate_icons (pDesklet);
// on recharge l'icone principale.
Icon* pIcon = pDesklet->pIcon;
if (pIcon) // if the view doesn't display the main icon, it will set the allocated size to 0 so that the icon won't be loaded.
{
cairo_dock_load_icon_buffers (pIcon, CAIRO_CONTAINER (pDesklet)); // pas de trigger, car on veut pouvoir associer un contexte a l'icone principale tout de suite.
}
// on recharge chaque icone.
GList* ic;
for (ic = pDesklet->icons; ic != NULL; ic = ic->next)
{
pIcon = ic->data;
if (cairo_dock_icon_get_allocated_width (pIcon) != pIcon->image.iWidth || cairo_dock_icon_get_allocated_height (pIcon) != pIcon->image.iHeight)
{
cairo_dock_trigger_load_icon_buffers (pIcon);
}
}
// on recharge les buffers de la vue.
if (pRenderer->load_data != NULL)
pRenderer->load_data (pDesklet);
}
// on recharge le module associe.
gldi_object_reload (GLDI_OBJECT(pDesklet->pIcon->pModuleInstance), FALSE);
gtk_widget_queue_draw (pDesklet->container.pWidget); // sinon on ne redessine que l'interieur.
}
if (pDesklet->bSpaceReserved) // l'espace est reserve, on reserve la nouvelle taille.
{
_reserve_space_for_desklet (pDesklet, TRUE);
}
}
//g_print ("iWidth <- %d;iHeight <- %d ; (%dx%d) (%x)\n", pDesklet->container.iWidth, pDesklet->container.iHeight, pDesklet->iKnownWidth, pDesklet->iKnownHeight, pDesklet->pIcon);
return FALSE;
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log(darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log(darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
static gboolean on_button_press_desklet(G_GNUC_UNUSED GtkWidget *pWidget,
GdkEventButton *pButton,
CairoDesklet *pDesklet)
{
if (pButton->button == 1) // clic gauche.
{
pDesklet->container.iMouseX = pButton->x;
pDesklet->container.iMouseY = pButton->y;
if (pButton->type == GDK_BUTTON_PRESS)
{
pDesklet->bClicked = TRUE;
if (cairo_dock_desklet_is_free (pDesklet))
{
///pDesklet->container.iMouseX = pButton->x; // pour le deplacement manuel.
///pDesklet->container.iMouseY = pButton->y;
if (pButton->x < myDeskletsParam.iDeskletButtonSize && pButton->y < myDeskletsParam.iDeskletButtonSize)
pDesklet->rotating = TRUE;
else if (pButton->x > pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize && pButton->y < myDeskletsParam.iDeskletButtonSize)
pDesklet->retaching = TRUE;
else if (pButton->x > (pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < (pDesklet->container.iWidth + myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < myDeskletsParam.iDeskletButtonSize)
pDesklet->rotatingY = TRUE;
else if (pButton->y > (pDesklet->container.iHeight - myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < (pDesklet->container.iHeight + myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < myDeskletsParam.iDeskletButtonSize)
pDesklet->rotatingX = TRUE;
else
pDesklet->time = pButton->time;
}
if (pDesklet->bAllowNoClickable && pButton->x > pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize && pButton->y > pDesklet->container.iHeight - myDeskletsParam.iDeskletButtonSize)
pDesklet->making_transparent = TRUE;
}
else if (pButton->type == GDK_BUTTON_RELEASE)
{
if (!pDesklet->bClicked) // on n'accepte le release que si on avait clique sur le desklet avant (on peut recevoir le release si on avait clique sur un dialogue qui chevauchait notre desklet et qui a disparu au clic).
{
return FALSE;
}
pDesklet->bClicked = FALSE;
//g_print ("GDK_BUTTON_RELEASE\n");
int x = pDesklet->container.iMouseX;
int y = pDesklet->container.iMouseY;
if (pDesklet->moving)
{
pDesklet->moving = FALSE;
}
else if (pDesklet->rotating)
{
pDesklet->rotating = FALSE;
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "rotation", (int) (pDesklet->fRotation / G_PI * 180.),
G_TYPE_INVALID);
gtk_widget_queue_draw (pDesklet->container.pWidget);
gldi_object_notify (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
}
else if (pDesklet->retaching)
{
pDesklet->retaching = FALSE;
if (x > pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize && y < myDeskletsParam.iDeskletButtonSize) // on verifie qu'on est encore dedans.
{
Icon *icon = pDesklet->pIcon;
g_return_val_if_fail (CAIRO_DOCK_IS_APPLET (icon), FALSE);
gldi_module_instance_detach (icon->pModuleInstance);
return GLDI_NOTIFICATION_INTERCEPT; // interception du signal.
}
}
else if (pDesklet->making_transparent)
{
cd_debug ("pDesklet->making_transparent\n");
pDesklet->making_transparent = FALSE;
if (x > pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize && y > pDesklet->container.iHeight - myDeskletsParam.iDeskletButtonSize) // on verifie qu'on est encore dedans.
{
Icon *icon = pDesklet->pIcon;
g_return_val_if_fail (CAIRO_DOCK_IS_APPLET (icon), FALSE);
pDesklet->bNoInput = ! pDesklet->bNoInput;
cd_debug ("no input : %d (%s)", pDesklet->bNoInput, icon->pModuleInstance->cConfFilePath);
cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
G_TYPE_BOOLEAN, "Desklet", "no input", pDesklet->bNoInput,
G_TYPE_INVALID);
_cairo_dock_set_desklet_input_shape (pDesklet);
gtk_widget_queue_draw (pDesklet->container.pWidget);
}
}
else if (pDesklet->rotatingY)
{
pDesklet->rotatingY = FALSE;
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "depth rotation y", (int) (pDesklet->fDepthRotationY / G_PI * 180.),
G_TYPE_INVALID);
gtk_widget_queue_draw (pDesklet->container.pWidget);
}
else if (pDesklet->rotatingX)
{
pDesklet->rotatingX = FALSE;
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "depth rotation x", (int) (pDesklet->fDepthRotationX / G_PI * 180.),
G_TYPE_INVALID);
gtk_widget_queue_draw (pDesklet->container.pWidget);
}
else
{
Icon *pClickedIcon = gldi_desklet_find_clicked_icon (pDesklet);
gldi_object_notify (pDesklet, NOTIFICATION_CLICK_ICON, pClickedIcon, pDesklet, pButton->state);
}
// prudence.
pDesklet->rotating = FALSE;
pDesklet->retaching = FALSE;
pDesklet->making_transparent = FALSE;
pDesklet->rotatingX = FALSE;
pDesklet->rotatingY = FALSE;
}
else if (pButton->type == GDK_2BUTTON_PRESS)
{
if (! (pButton->x < myDeskletsParam.iDeskletButtonSize && pButton->y < myDeskletsParam.iDeskletButtonSize) && ! (pButton->x > (pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < (pDesklet->container.iWidth + myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < myDeskletsParam.iDeskletButtonSize))
{
Icon *pClickedIcon = gldi_desklet_find_clicked_icon (pDesklet); // can be NULL
gldi_object_notify (pDesklet, NOTIFICATION_DOUBLE_CLICK_ICON, pClickedIcon, pDesklet);
}
}
}
else if (pButton->button == 3 && pButton->type == GDK_BUTTON_PRESS) // clique droit.
{
Icon *pClickedIcon = gldi_desklet_find_clicked_icon (pDesklet);
GtkWidget *menu = gldi_container_build_menu (CAIRO_CONTAINER (pDesklet), pClickedIcon); // genere un CAIRO_DOCK_BUILD_ICON_MENU.
gldi_menu_popup (menu);
}
else if (pButton->button == 2 && pButton->type == GDK_BUTTON_PRESS) // clique milieu.
{
if (pButton->x < myDeskletsParam.iDeskletButtonSize && pButton->y < myDeskletsParam.iDeskletButtonSize)
{
pDesklet->fRotation = 0.;
gtk_widget_queue_draw (pDesklet->container.pWidget);
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "rotation", 0,
G_TYPE_INVALID);
gldi_object_notify (pDesklet, NOTIFICATION_CONFIGURE_DESKLET, pDesklet);
}
else if (pButton->x > (pDesklet->container.iWidth - myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < (pDesklet->container.iWidth + myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < myDeskletsParam.iDeskletButtonSize)
{
pDesklet->fDepthRotationY = 0.;
gtk_widget_queue_draw (pDesklet->container.pWidget);
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "depth rotation y", 0,
G_TYPE_INVALID);
}
else if (pButton->y > (pDesklet->container.iHeight - myDeskletsParam.iDeskletButtonSize)/2 && pButton->y < (pDesklet->container.iHeight + myDeskletsParam.iDeskletButtonSize)/2 && pButton->x < myDeskletsParam.iDeskletButtonSize)
{
pDesklet->fDepthRotationX = 0.;
gtk_widget_queue_draw (pDesklet->container.pWidget);
cairo_dock_update_conf_file (pDesklet->pIcon->pModuleInstance->cConfFilePath,
G_TYPE_INT, "Desklet", "depth rotation x", 0,
G_TYPE_INVALID);
}
else
{
gldi_object_notify (pDesklet, NOTIFICATION_MIDDLE_CLICK_ICON, pDesklet->pIcon, pDesklet);
}
}
return FALSE;
}
static gboolean dt_iop_tonecurve_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_tonecurve_gui_data_t *c = (dt_iop_tonecurve_gui_data_t *)self->gui_data;
dt_iop_tonecurve_params_t *p = (dt_iop_tonecurve_params_t *)self->params;
int ch = c->channel;
int nodes = p->tonecurve_nodes[ch];
dt_iop_tonecurve_node_t *tonecurve = p->tonecurve[ch];
int autoscale_ab = p->tonecurve_autoscale_ab;
// if autoscale_ab is on: do not modify a and b curves
if (autoscale_ab && ch != ch_L) goto finally;
const int inset = DT_GUI_CURVE_EDITOR_INSET;
int height = widget->allocation.height - 2*inset, width = widget->allocation.width - 2*inset;
c->mouse_x = CLAMP(event->x - inset, 0, width);
c->mouse_y = CLAMP(event->y - inset, 0, height);
const float mx = c->mouse_x/(float)width;
const float my = 1.0f - c->mouse_y/(float)height;
if(event->state & GDK_BUTTON1_MASK)
{
// got a vertex selected:
if(c->selected >= 0)
{
tonecurve[c->selected].x = mx;
tonecurve[c->selected].y = my;
// delete vertex if order has changed:
if(nodes > 2)
if((c->selected > 0 && tonecurve[c->selected-1].x >= mx) ||
(c->selected < nodes-1 && tonecurve[c->selected+1].x <= mx))
{
for(int k=c->selected; k<nodes-1; k++)
{
tonecurve[k].x = tonecurve[k+1].x;
tonecurve[k].y = tonecurve[k+1].y;
}
c->selected = -2; // avoid re-insertion of that point immediately after this
p->tonecurve_nodes[ch] --;
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
else if(nodes < 20 && c->selected >= -1)
{
// no vertex was close, create a new one!
if(tonecurve[0].x > mx)
c->selected = 0;
else for(int k=1; k<nodes; k++)
{
if(tonecurve[k].x > mx)
{
c->selected = k;
break;
}
}
if(c->selected == -1) c->selected = nodes;
for(int i=nodes; i>c->selected; i--)
{
tonecurve[i].x = tonecurve[i-1].x;
tonecurve[i].y = tonecurve[i-1].y;
}
// found a new point
tonecurve[c->selected].x = mx;
tonecurve[c->selected].y = my;
p->tonecurve_nodes[ch] ++;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
}
else
{
// minimum area around the node to select it:
float min = .04f;
min *= min; // comparing against square
int nearest = -1;
for(int k=0; k<nodes; k++)
{
float dist = (my - tonecurve[k].y)*(my - tonecurve[k].y)
+ (mx - tonecurve[k].x)*(mx - tonecurve[k].x);
if(dist < min)
{
min = dist;
nearest = k;
}
}
c->selected = nearest;
}
finally:
gtk_widget_queue_draw(widget);
return TRUE;
}
void pen_motion(tool_t* tool, canvas_t* canvas, GdkEventMotion* event) {
cairo_move_to(cr, tool->last_x, tool->last_y);
cairo_line_to(cr, event->x, event->y);
cairo_stroke(cr);
gtk_widget_queue_draw(GTK_WIDGET(canvas->darea));
}
