/*
==================================
ProfileWindow::make_busy_cursor
==================================
*/
void ProfileWindow::make_busy_cursor(bool busy)
{
{
Glib::Mutex::Lock lock(mutex);
GdkDisplay* display;
GdkCursor* cursor;
GdkWindow* window;
display = gdk_display_get_default();
if(busy)
cursor = gdk_cursor_new(GDK_WATCH);
else
cursor = gdk_cursor_new(GDK_LEFT_PTR);
window = (GdkWindow*) profilewindow->get_window()->gobj();
gdk_window_set_cursor(window, cursor);
window = (GdkWindow*) prof->get_window()->gobj();
if(!busy && (fencetoggleprof->get_active() || rulertoggle->get_active()))
{
gdk_cursor_unref(cursor);
cursor = gdk_cursor_new(GDK_CROSSHAIR);
}
gdk_window_set_cursor(window, cursor);
gdk_cursor_unref(cursor);
gdk_display_sync(display);
}
}
void
draw_preview_image (gboolean recompute)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
compute_preview_rectangle (&startx, &starty, &pw, &ph);
if (recompute)
{
GdkDisplay *display = gtk_widget_get_display (previewarea);
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
compute_preview (startx, starty, pw, ph);
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
gdk_flush ();
/* if we recompute, clear backbuf, so we don't
* restore the wrong bitmap */
if (backbuf.image != NULL)
{
g_object_unref (backbuf.image);
backbuf.image = NULL;
}
}
gdk_draw_rgb_image (previewarea->window, gc,
0, 0, PREVIEW_WIDTH, PREVIEW_HEIGHT,
GDK_RGB_DITHER_MAX, preview_rgb_data,
3 * PREVIEW_WIDTH);
/* draw symbols if enabled in UI */
if (mapvals.interactive_preview)
{
draw_handles ();
}
}
static void
immerse_controls_destroy(ImmerseControls *controls)
{
gtk_widget_destroy(controls->dialog);
gwy_si_unit_value_format_free(controls->vf);
g_object_unref(controls->mydata);
gdk_cursor_unref(controls->near_cursor);
gdk_cursor_unref(controls->move_cursor);
GWY_OBJECT_UNREF(controls->detail);
}
void
draw_preview_image (gint docompute)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
linetab[0].x1 = -1;
pw = PREVIEW_WIDTH * mapvals.zoom;
ph = PREVIEW_HEIGHT * mapvals.zoom;
startx = (PREVIEW_WIDTH - pw) / 2;
starty = (PREVIEW_HEIGHT - ph) / 2;
if (docompute == TRUE)
{
GdkDisplay *display = gtk_widget_get_display (previewarea);
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
compute_preview (0, 0, width - 1, height - 1, pw, ph);
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gdk_window_set_cursor(previewarea->window, cursor);
gdk_cursor_unref (cursor);
clear_light_marker ();
}
if (pw != PREVIEW_WIDTH || ph != PREVIEW_HEIGHT)
gdk_window_clear (previewarea->window);
gdk_draw_rgb_image (previewarea->window, gc,
startx, starty, pw, ph,
GDK_RGB_DITHER_MAX,
preview_rgb_data, 3 * pw);
draw_lights (startx, starty, pw, ph);
}
static void
mucharmap_charmap_finalize (GObject *object)
{
MucharmapCharmap *charmap = MUCHARMAP_CHARMAP (object);
MucharmapCharmapPrivate *priv = charmap->priv;
gdk_cursor_unref (priv->hand_cursor);
gdk_cursor_unref (priv->regular_cursor);
if (priv->font_desc)
pango_font_description_free (priv->font_desc);
G_OBJECT_CLASS (mucharmap_charmap_parent_class)->finalize (object);
}
static void
gs_graph_finalize (GObject *object)
{
GsGraph *graph = GS_GRAPH (object);
g_free (graph->priv->grid_color);
g_free (graph->priv->axes_color);
g_free (graph->priv->background_color);
gdk_cursor_unref (graph->priv->default_cursor);
gdk_cursor_unref (graph->priv->drag_cursor);
G_OBJECT_CLASS (gs_graph_parent_class)->finalize (object);
}
static void
git_source_view_dispose (GObject *object)
{
GitSourceView *self = (GitSourceView *) object;
GitSourceViewPrivate *priv = self->priv;
if (priv->paint_source)
{
g_object_unref (priv->paint_source);
priv->paint_source = NULL;
}
git_source_view_unref_hadjustment (self);
git_source_view_unref_vadjustment (self);
git_source_view_unref_loading_source (self);
if (priv->state_error)
{
g_error_free (priv->state_error);
priv->state_error = NULL;
}
if (priv->hand_cursor)
{
gdk_cursor_unref (priv->hand_cursor);
priv->hand_cursor = NULL;
}
G_OBJECT_CLASS (git_source_view_parent_class)->dispose (object);
}
/* Looks at all tags covering the position (x, y) in the text view,
* and if one of them is a link, change the cursor to the "hands" cursor
* typically used by web browsers.
*/
static void
set_cursor_if_appropriate (GtkTextView *text_view, gint x, gint y)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
gboolean hovering = FALSE;
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
tags = gtk_text_iter_get_tags (&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
gchar *tag_name;
GtkTextTag *tag = tagp->data;
g_object_get (G_OBJECT (tag), "name", &tag_name, NULL);
if ( g_ascii_strcasecmp(tag_name, "link") == 0)
{
hovering = TRUE;
break;
}
}
GdkCursor *cursor;
if (hovering)
cursor = gdk_cursor_new (GDK_LEFT_PTR);
else
cursor = gdk_cursor_new (GDK_XTERM);
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT),
cursor);
gdk_cursor_unref (cursor);
if (tags)
g_slist_free (tags);
}
/**
* Grab the keyboard and mouse for the display. The mouse cursor is hidden and
* moved to the centre of the window.
*
* @param win The window receiving the grab
* @return TRUE if the grab was successful, FALSE on failure.
*/
gboolean video_window_grab_display( main_window_t win )
{
GdkWindow *gdkwin = win->video->window;
GdkColor color = { 0,0,0,0 };
char bytes[32]; /* 16 * 16 / 8 */
memset(bytes, 0, 32);
GdkPixmap *pixmap = gdk_bitmap_create_from_data(NULL, bytes, 16, 16);
GdkCursor *cursor = gdk_cursor_new_from_pixmap(pixmap, pixmap, &color, &color, 16, 16);
gdk_pixmap_unref(pixmap);
gboolean success =
gdk_pointer_grab( gdkwin, FALSE,
GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK,
gdkwin, cursor, GDK_CURRENT_TIME ) == GDK_GRAB_SUCCESS;
gdk_cursor_unref(cursor);
if( success ) {
success = gdk_keyboard_grab( gdkwin, FALSE, GDK_CURRENT_TIME ) == GDK_GRAB_SUCCESS;
if( !success ) {
gdk_pointer_ungrab(GDK_CURRENT_TIME);
}
}
win->is_grabbed = success;
main_window_set_running(win, dreamcast_is_running());
return success;
}
void gTextArea::updateCursor(GdkCursor *cursor)
{
GdkWindow *win;
#ifdef GTK3
win = gtk_text_view_get_window(GTK_TEXT_VIEW(textview), GTK_TEXT_WINDOW_TEXT);
#else
win = ((PrivateGtkTextWindow *)GTK_TEXT_VIEW(textview)->text_window)->bin_window;
#endif
gControl::updateCursor(cursor);
if (!win)
return;
if (cursor)
gdk_window_set_cursor(win, cursor);
else
{
cursor = gdk_cursor_new_for_display(gtk_widget_get_display(textview), GDK_XTERM);
gdk_window_set_cursor(win, cursor);
#ifdef GTK3
g_object_unref(cursor);
#else
gdk_cursor_unref(cursor);
#endif
}
}
static void
gdict_speller_finalize (GObject *gobject)
{
GdictSpeller *speller = GDICT_SPELLER (gobject);
GdictSpellerPrivate *priv = speller->priv;
if (priv->context)
set_gdict_context (speller, NULL);
if (priv->busy_cursor)
#if GTK_CHECK_VERSION (3, 0, 0)
g_object_unref (priv->busy_cursor);
#else
gdk_cursor_unref (priv->busy_cursor);
#endif
g_free (priv->strategy);
g_free (priv->database);
g_free (priv->word);
if (priv->store)
g_object_unref (priv->store);
G_OBJECT_CLASS (gdict_speller_parent_class)->finalize (gobject);
}
void
panel_push_window_busy (GtkWidget *window)
{
int busy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window),
"Panel:WindowBusy"));
busy ++;
if (busy == 1) {
GdkWindow *win;
gtk_widget_set_sensitive (window, FALSE);
win = gtk_widget_get_window (window);
if (win != NULL) {
GdkCursor *cursor = gdk_cursor_new_for_display (gdk_display_get_default (),
GDK_WATCH);
gdk_window_set_cursor (win, cursor);
#if GTK_CHECK_VERSION (3, 0, 0)
g_object_unref (cursor);
#else
gdk_cursor_unref (cursor);
#endif
gdk_flush ();
}
}
g_object_set_data (G_OBJECT (window), "Panel:WindowBusy",
GINT_TO_POINTER (busy));
}
static void
gdict_source_chooser_dispose (GObject *gobject)
{
GdictSourceChooser *chooser = GDICT_SOURCE_CHOOSER (gobject);
GdictSourceChooserPrivate *priv = chooser->priv;
if (priv->store)
{
g_object_unref (priv->store);
priv->store = NULL;
}
if (priv->loader)
{
g_object_unref (priv->loader);
priv->loader = NULL;
}
if (priv->busy_cursor)
{
gdk_cursor_unref (priv->busy_cursor);
priv->busy_cursor = NULL;
}
G_OBJECT_CLASS (gdict_source_chooser_parent_class)->dispose (gobject);
}
void layer_new_mouse(void)
{
// Local variables
GdkCursor *selection_cursor; // Holds the new temporary selection cursor
// If no project is loaded then don't run this function
if (NULL == get_current_slide())
{
// Make a beep, then return
gdk_beep();
return;
}
// Change the focus of the window to be this widget
set_delete_focus(FOCUS_LAYER);
// Change the cursor to something suitable
selection_cursor = gdk_cursor_new(GDK_CROSSHAIR);
gdk_window_set_cursor(get_main_drawing_area()->window, selection_cursor);
gdk_cursor_unref(selection_cursor);
// Set a toggle so the release button callback will know to do the rest
set_new_layer_selected(TYPE_MOUSE_CURSOR);
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Please click the insertion point"));
gdk_flush();
}
Cursor& Cursor::operator=(const Cursor& other)
{
gdk_cursor_ref(other.m_impl);
gdk_cursor_unref(m_impl);
m_impl = other.m_impl;
return *this;
}
static void
wp_add_images (AppearanceData *data,
GSList *images)
{
GdkWindow *window;
GtkWidget *w;
GdkCursor *cursor;
MateWPItem *item;
w = appearance_capplet_get_widget (data, "appearance_window");
window = gtk_widget_get_window (w);
item = NULL;
cursor = gdk_cursor_new_for_display (gdk_display_get_default (),
GDK_WATCH);
gdk_window_set_cursor (window, cursor);
gdk_cursor_unref (cursor);
while (images != NULL)
{
gchar *uri = images->data;
item = wp_add_image (data, uri);
images = g_slist_remove (images, uri);
g_free (uri);
}
gdk_window_set_cursor (window, NULL);
if (item != NULL)
{
select_item (data, item, TRUE);
}
}
void
panel_force_quit (GdkScreen *screen,
guint time)
{
GdkGrabStatus status;
GdkCursor *cross;
GtkWidget *popup;
GdkWindow *root;
popup = display_popup_window (screen);
root = gdk_screen_get_root_window (screen);
gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup);
cross = gdk_cursor_new (GDK_CROSS);
status = gdk_pointer_grab (root, FALSE, GDK_BUTTON_PRESS_MASK,
NULL, cross, time);
gdk_cursor_unref (cross);
if (status != GDK_GRAB_SUCCESS) {
g_warning ("Pointer grab failed\n");
remove_popup (popup);
return;
}
status = gdk_keyboard_grab (root, FALSE, time);
if (status != GDK_GRAB_SUCCESS) {
g_warning ("Keyboard grab failed\n");
remove_popup (popup);
return;
}
gdk_flush ();
}
static void
gtk_ellipsis_state_changed (GtkWidget *widget,
GtkStateType previous_state)
{
GtkEllipsis *ellipsis = GTK_ELLIPSIS (widget);
GtkEllipsisPrivate *priv = ellipsis->priv;
if (!GTK_WIDGET_IS_SENSITIVE (widget))
priv->button_down = FALSE;
if (GTK_WIDGET_REALIZED (widget))
{
GdkCursor *cursor;
if (GTK_WIDGET_IS_SENSITIVE (widget))
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GTK_ELLIPSIS_CURSOR);
else
cursor = NULL;
gdk_window_set_cursor (priv->event_window, cursor);
if (cursor)
gdk_cursor_unref (cursor);
}
}
void
panel_push_window_busy (GtkWidget *window)
{
int busy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window),
"Panel:WindowBusy"));
busy ++;
if (busy == 1) {
GdkWindow *win;
gtk_widget_set_sensitive (window, FALSE);
win = gtk_widget_get_window (window);
if (win != NULL) {
GdkCursor *cursor = gdk_cursor_new (GDK_WATCH);
gdk_window_set_cursor (win, cursor);
gdk_cursor_unref (cursor);
gdk_flush ();
}
}
g_object_set_data (G_OBJECT (window), "Panel:WindowBusy",
GINT_TO_POINTER (busy));
}
void dt_control_change_cursor(dt_cursor_t curs)
{
GtkWidget *widget = dt_ui_main_window(darktable.gui->ui);
GdkCursor* cursor = gdk_cursor_new(curs);
gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
gdk_cursor_unref(cursor);
}
/* Starts the selection state in the icon text item */
static void
iti_start_selecting (MateIconTextItem *iti, int idx, guint32 event_time)
{
MateIconTextItemPrivate *priv;
GtkEditable *e;
GdkCursor *ibeam;
priv = iti->_priv;
e = GTK_EDITABLE (priv->entry);
gtk_editable_select_region (e, idx, idx);
gtk_editable_set_position (e, idx);
ibeam = gdk_cursor_new (GDK_XTERM);
mate_canvas_item_grab (MATE_CANVAS_ITEM (iti),
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
ibeam, event_time);
gdk_cursor_unref (ibeam);
gtk_editable_select_region (e, idx, idx);
priv->selecting = TRUE;
priv->selection_start = idx;
mate_canvas_item_request_update (MATE_CANVAS_ITEM (iti));
g_signal_emit (iti, iti_signals[SELECTION_STARTED], 0);
}
/**
* e_cursor_set:
* @widget: Any widget in a window, to which busy cursor has to be set
* cursor: The type of cursor to be set defined in e-cursor.h
*
* Sets the cursor specified, to the top level window of the given widget.
* It is not window aware, so if you popup a window, it will not have
* busy cursor set. That has to be handled seperately with a new call to this
* function.
*
* Return value:
**/
void e_cursor_set (GtkWidget *widget, ECursorType cursor)
{
GtkWidget *toplevel;
GdkCursor *window_cursor;
toplevel = gtk_widget_get_toplevel (widget);
if (GTK_WIDGET_TOPLEVEL (toplevel) && toplevel->window) {
switch (cursor) {
case E_CURSOR_NORMAL :
window_cursor = gdk_cursor_new (GDK_LEFT_PTR);
break;
case E_CURSOR_BUSY :
window_cursor = gdk_cursor_new (GDK_WATCH);
break;
default :
window_cursor = gdk_cursor_new (GDK_LEFT_PTR);
}
gdk_window_set_cursor (toplevel->window, window_cursor);
gdk_cursor_unref (window_cursor);
}
}
static void
gtk_icon_entry_map (GtkWidget *widget)
{
GtkIconEntryPrivate *priv;
GdkCursor *cursor;
if (GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_MAPPED (widget))
{
int i;
GTK_WIDGET_CLASS (parent_class)->map (widget);
priv = GTK_ICON_ENTRY_GET_PRIVATE (widget);
for (i = 0; i < MAX_ICONS; i++)
{
if (priv->icons[i].pixbuf != NULL)
gdk_window_show (priv->icons[i].window);
if (priv->icons[i].custom_cursor == TRUE && !priv->icons[i].insensitive)
{
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
priv->icons[i].cursor_type);
gdk_window_set_cursor (priv->icons[i].window, cursor);
gdk_cursor_unref (cursor);
}
}
GTK_WIDGET_CLASS (parent_class)->map (widget);
}
}
/* Called by gdk_x11_display_finalize to flush any cached cursors
* for a dead display.
*/
void
_gdk_x11_cursor_display_finalize (GdkDisplay *display)
{
GSList* item;
GSList** itemp; /* Pointer to the thing to fix when we delete an item */
item = cursor_cache;
itemp = &cursor_cache;
while (item)
{
GdkX11Cursor* cursor = (GdkX11Cursor*)(item->data);
if (gdk_cursor_get_display (GDK_CURSOR (cursor)) == display)
{
GSList* olditem;
gdk_cursor_unref ((GdkCursor*) cursor);
/* Remove this item from the list */
*(itemp) = item->next;
olditem = item;
item = g_slist_next (item);
g_slist_free_1 (olditem);
}
else
{
itemp = &(item->next);
item = g_slist_next (item);
}
}
}
/**
* gtk_icon_entry_set_icon_sensitive
* @entry: A #GtkIconEntry.
* @position: Icon position.
* @sensitive: Specifies whether the icon should appear sensitive or insensitive.
*
* Sets the sensitivity for the specified icon.
*/
void
gtk_icon_entry_set_icon_sensitive (const GtkIconEntry *icon_entry,
GtkIconEntryPosition icon_pos,
gboolean sensitive)
{
EntryIconInfo *icon_info;
GtkIconEntryPrivate *priv;
g_return_if_fail (icon_entry != NULL);
g_return_if_fail (GTK_IS_ICON_ENTRY (icon_entry));
g_return_if_fail (IS_VALID_ICON_ENTRY_POSITION (icon_pos));
priv = GTK_ICON_ENTRY_GET_PRIVATE (icon_entry);
icon_info = &priv->icons[icon_pos];
icon_info->insensitive = !sensitive;
if (icon_info->custom_cursor == TRUE && GTK_WIDGET_REALIZED (GTK_WIDGET (icon_entry)))
{
GdkCursor *cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (icon_entry)),
sensitive ? icon_info->cursor_type : GDK_ARROW);
gdk_window_set_cursor (icon_info->window, cursor);
gdk_cursor_unref (cursor);
}
}
static void
uni_image_view_unrealize (GtkWidget * widget)
{
UniImageView *view = UNI_IMAGE_VIEW (widget);
gdk_cursor_unref (view->void_cursor);
GTK_WIDGET_CLASS (uni_image_view_parent_class)->unrealize (widget);
}
/* Redraw the screen from the backing pixmap */
static gboolean expose_event (GtkWidget *widget,
GdkEventExpose *event)
{
static GdkImage *image = NULL;
GdkCursor *cursor;
GdkPixbuf *pixbuf;
if (framebuffer_allocated == FALSE) {
rfbClientSetClientData (cl, gtk_init, widget);
image = gdk_drawable_get_image (widget->window, 0, 0,
widget->allocation.width,
widget->allocation.height);
cl->frameBuffer= image->mem;
cl->width = widget->allocation.width;
cl->height = widget->allocation.height;
cl->format.bitsPerPixel = image->bits_per_pixel;
cl->format.redShift = image->visual->red_shift;
cl->format.greenShift = image->visual->green_shift;
cl->format.blueShift = image->visual->blue_shift;
cl->format.redMax = (1 << image->visual->red_prec) - 1;
cl->format.greenMax = (1 << image->visual->green_prec) - 1;
cl->format.blueMax = (1 << image->visual->blue_prec) - 1;
#ifdef LIBVNCSERVER_CONFIG_LIBVA
/* Allow libvncclient to use a more efficient way
* of putting the framebuffer on the screen when
* using the H.264 format.
*/
cl->outputWindow = GDK_WINDOW_XID(widget->window);
#endif
SetFormatAndEncodings (cl);
framebuffer_allocated = TRUE;
/* Also disable local cursor */
pixbuf = gdk_pixbuf_new_from_xpm_data(dot_cursor_xpm);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, dot_cursor_x_hot, dot_cursor_y_hot);
g_object_unref(pixbuf);
gdk_window_set_cursor (gtk_widget_get_window(GTK_WIDGET(window)), cursor);
gdk_cursor_unref(cursor);
}
#ifndef LIBVNCSERVER_CONFIG_LIBVA
gdk_draw_image (GDK_DRAWABLE (widget->window),
widget->style->fg_gc[gtk_widget_get_state(widget)],
image,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
#endif
return FALSE;
}
static gboolean on_mouse_move(GtkWidget *entry,
GdkEventMotion *evt,
gpointer user_data)
{
if( evt->state == GDK_CONTROL_MASK )
{
if( ! is_hand_cursor_used( entry ) )
{
GdkCursor* hand = gdk_cursor_new_for_display( gtk_widget_get_display(entry), GDK_HAND2 );
gdk_window_set_cursor( entry->window, hand );
gdk_cursor_unref( hand );
g_object_set_qdata( entry, use_hand_cursor, (gpointer)TRUE );
g_debug( "SET" );
}
return TRUE;
}
else
{
if( is_hand_cursor_used( entry ) )
{
gdk_window_set_cursor( entry->window, NULL );
g_object_set_qdata( entry, use_hand_cursor, (gpointer)FALSE );
g_debug( "UNSET" );
}
}
return FALSE;
}
/*
==================================
FileSaver::on_filesaverdialogresponse
If Save button has been pressed creates a SaveWorker which
saves selected flightline.
==================================
*/
void FileSaver::on_filesaverdialogresponse(int response_id)
{
if(response_id == Gtk::RESPONSE_CLOSE)
{
//filesaverdialog->set_filename("");
filesaverdialog->hide_all();
}
else if(response_id == 1)
{
if (lidardata==NULL)
return;
if (saveworker != NULL)
return;
double scale_factor[3];
if (!btnUseDefault->get_active())
{
const char* temp;
temp = scaleFactorEntryX->get_text().c_str();
scale_factor[0] = atof(temp);
temp = scaleFactorEntryY->get_text().c_str();
scale_factor[1] = atof(temp);
temp = scaleFactorEntryZ->get_text().c_str();
scale_factor[2] = atof(temp);
}
else
{
scale_factor[0] = scale_factor[1] = scale_factor[2] = 0;
}
// tdo and prof should have the same pointbucket mutex
Glib::Mutex* pbkt_mutex = tdo->getPointBucketMutex();
saveworker = new SaveWorker(this, filesaverdialog->get_filename(), lidardata->getFileName(flightlinesaveselect->get_value_as_int()), flightlinesaveselect->get_value_as_int(), parsestringentry->get_text(), latlongselect->get_active(), btnUseDefault->get_active(), scale_factor, pbkt_mutex);
saveworker->start();
saveworker->sig_done.connect(sigc::mem_fun(*this, &FileSaver::files_saved));
saveworker->sig_progress.connect(sigc::mem_fun(*this, &FileSaver::on_progress));
saveworker->sig_waveform.connect(sigc::mem_fun(*this, &FileSaver::waveform_started));
saveworker->sig_waveform_progress.connect(sigc::mem_fun(*this, &FileSaver::on_waveform_progress));
// Show saving dialog
savedialog->show_all();
saveprogressbar->set_fraction(0);
// Change cursor to busy
GdkDisplay* display;
GdkCursor* cursor;
GdkWindow* window;
cursor = gdk_cursor_new(GDK_WATCH);
display = gdk_display_get_default();
window = (GdkWindow*) filesaverdialog->get_window()->gobj();
gdk_window_set_cursor(window, cursor);
gdk_display_sync(display);
gdk_cursor_unref(cursor);
}
}
void ZLGtkProgressDialog::run(ZLRunnable &runnable) {
while (gtk_events_pending()) {
gtk_main_iteration();
}
GtkWindow *mainWindow = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
gtk_window_set_accept_focus(mainWindow, FALSE);
myLabel = gtk_label_new(messageText().c_str());
gtk_misc_set_padding(GTK_MISC(myLabel), 10, 10); // something nice?
gtk_container_add(GTK_CONTAINER(mainWindow), myLabel);
gtk_widget_show_all(GTK_WIDGET(mainWindow));
GdkCursor *cursor = gdk_cursor_new(GDK_WATCH);
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, cursor);
}
gdk_window_set_cursor(GTK_WIDGET(mainWindow)->window, cursor);
gdk_cursor_unref(cursor);
int x, y, w, h;
if (myParent != 0) {
gtk_window_get_position(myParent, &x, &y);
gtk_window_get_size(myParent, &w, &h);
x += w / 2;
y += h / 2;
} else {
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
gdk_window_get_geometry(root, &x, &y, &w, &h, 0);
x += w / 2;
y += h / 2;
}
gtk_window_get_size(mainWindow, &w, &h);
x -= w / 2;
y -= h / 2;
gtk_window_move(mainWindow, x, y);
while (gtk_events_pending()) {
gtk_main_iteration();
}
if (myParent != 0) {
gtk_widget_queue_draw(GTK_WIDGET(myParent));
}
while (gtk_events_pending()) {
gtk_main_iteration();
}
runnable.run();
myLabel = 0;
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, 0);
}
gtk_widget_destroy(GTK_WIDGET(mainWindow));
}
