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