static void ol_scroll_window_update_cursor (GtkWidget *widget, GdkEventMotion *event) { GdkWindowEdge edge; gint width, height; gtk_window_get_size (GTK_WINDOW (widget), &width, &height); GdkCursor *cursor = NULL; OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (widget); if (_get_pointer_edge (event->x, event->y, width, height, priv->frame_width, priv->frame_width, priv->frame_width, priv->frame_width, &edge)) { switch (edge) { case GDK_WINDOW_EDGE_EAST: cursor = gdk_cursor_new (GDK_RIGHT_SIDE); break; case GDK_WINDOW_EDGE_WEST: cursor = gdk_cursor_new (GDK_LEFT_SIDE); break; case GDK_WINDOW_EDGE_NORTH: cursor = gdk_cursor_new (GDK_TOP_SIDE); break; case GDK_WINDOW_EDGE_SOUTH: cursor = gdk_cursor_new (GDK_BOTTOM_SIDE); break; case GDK_WINDOW_EDGE_NORTH_EAST: cursor = gdk_cursor_new (GDK_TOP_RIGHT_CORNER); break; case GDK_WINDOW_EDGE_NORTH_WEST: cursor = gdk_cursor_new (GDK_TOP_LEFT_CORNER); break; case GDK_WINDOW_EDGE_SOUTH_EAST: cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER); break; case GDK_WINDOW_EDGE_SOUTH_WEST: cursor = gdk_cursor_new (GDK_BOTTOM_LEFT_CORNER); break; } } gdk_window_set_cursor (widget->window, cursor); if (cursor) gdk_cursor_unref (cursor); }
static void gdl_dock_item_grip_realize (GtkWidget *widget) { GdlDockItemGrip *grip = GDL_DOCK_ITEM_GRIP (widget); GTK_WIDGET_CLASS (parent_class)->realize (widget); if (!grip->title_window) { GdkWindowAttr attributes; GdkRectangle area; GdkCursor *cursor; ensure_title_and_icon_pixbuf (grip); gdl_dock_item_grip_get_title_area (grip, &area); attributes.x = area.x; attributes.y = area.y; attributes.width = area.width; attributes.height = area.height; attributes.window_type = GDK_WINDOW_TEMP; attributes.wclass = GDK_INPUT_ONLY; attributes.override_redirect = TRUE; attributes.event_mask = (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK | gtk_widget_get_events (widget)); grip->title_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, (GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR)); gdk_window_set_user_data (grip->title_window, widget); if (GDL_DOCK_ITEM_CANT_CLOSE (grip->item)) cursor = NULL; else if (GDL_DOCK_ITEM_CANT_ICONIFY (grip->item)) cursor = NULL; else cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_HAND2); gdk_window_set_cursor (grip->title_window, cursor); if (cursor) gdk_cursor_unref (cursor); } }
void common_button_event (WnckWindow *win, decor_event *gtkwd_event, decor_event_type gtkwd_type, int button, int max, char *tooltip) { decor_t *d = g_object_get_data (G_OBJECT (win), "decor"); guint state = d->button_states[button]; gboolean use_tooltips = FALSE; g_object_get (settings, "use-tooltips", &use_tooltips, NULL); if (use_tooltips) handle_tooltip_event (win, gtkwd_event, gtkwd_type, state, tooltip); if (d->frame_window && gtkwd_type == GEnterNotify) { GdkCursor* cursor; cursor = gdk_cursor_new (GDK_LEFT_PTR); gdk_window_set_cursor (d->frame_window, cursor); gdk_cursor_unref (cursor); } switch (gtkwd_type) { case GButtonPress: if (gtkwd_event->button <= max) d->button_states[button] |= PRESSED_EVENT_WINDOW; break; case GButtonRelease: if (gtkwd_event->button <= max) d->button_states[button] &= ~PRESSED_EVENT_WINDOW; break; case GEnterNotify: d->button_states[button] |= IN_EVENT_WINDOW; break; case GLeaveNotify: d->button_states[button] &= ~IN_EVENT_WINDOW; break; default: break; } if (state != d->button_states[button]) queue_decor_draw (d); }
void tTextButton::create (GtkWidget * pfixed, gint x, gint y, gint w, gint h,gint tx1, gint ty1,gint tx2, gint ty2, GdkPixmap * pix_1, GdkPixmap * pix_2, gchar * str, void (*func) (gpointer), gpointer data) { init (); pix_normal = pix_1; pix_down = pix_2; width = w; height = h; text_x1 = tx1; text_y1 = ty1; text_x2 = tx2; text_y2 = ty2; runfunc = func; funcdata = data; draw_area = gtk_drawing_area_new (); gtk_widget_set_size_request (draw_area, width, height); gtk_widget_set_events (draw_area, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK); g_signal_connect (G_OBJECT (draw_area), "expose_event", G_CALLBACK (on_textbutton_expose), this); g_signal_connect (G_OBJECT (draw_area), "button_press_event", G_CALLBACK (on_textbutton_buttonpress), this); g_signal_connect (G_OBJECT (draw_area), "button_release_event", G_CALLBACK (on_textbutton_buttonrelease), this); g_signal_connect (G_OBJECT (draw_area), "enter_notify_event", G_CALLBACK (on_textbutton_enter_notify), this); g_signal_connect (G_OBJECT (draw_area), "leave_notify_event", G_CALLBACK (on_textbutton_leave_notify), this); gtk_fixed_put (GTK_FIXED (pfixed), draw_area, x, y); gtk_widget_show (draw_area); gdk_window_set_cursor (draw_area->window, Skin->reciteword.hand_cursor.cursor); draw_pixmap = gdk_pixmap_new (draw_area->window, width, height, gdk_rgb_get_visual ()->depth); strcpy (text, str); layout=gtk_widget_create_pango_layout (draw_area, text); draw (false); }
int hide_cursor (GtkWindow* window) { GdkCursor* cursor; GdkPixmap* source, *mask; GdkColor fg = { 0, 0, 0, 0 }; /* Transparent. */ GdkColor bg = { 0, 0, 0, 0 }; /* Transparent. */ source = gdk_bitmap_create_from_data (NULL, cursor1_bits, cursor1_width, cursor1_height); mask = gdk_bitmap_create_from_data (NULL, cursor1mask_bits, cursor1_width, cursor1_height); cursor = gdk_cursor_new_from_pixmap (source, mask, &fg, &bg, 8, 8); gdk_pixmap_unref (source); gdk_pixmap_unref (mask); gdk_window_set_cursor (((GtkWidget*)window)->window, cursor); }
int main(int argc, char **argv) { gtk_init(&argc, &argv); struct data_t data = {0}; data.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); assert(data.window); gtk_window_set_title(GTK_WINDOW(data.window), "Plasma Cleaner"); gtk_window_set_keep_above(GTK_WINDOW(data.window), TRUE); gtk_widget_add_events(data.window, GDK_BUTTON_PRESS_MASK|GDK_KEY_PRESS_MASK); gtk_window_fullscreen(GTK_WINDOW(data.window)); g_signal_connect(G_OBJECT(data.window), "draw", G_CALLBACK(&on_draw), &data); g_signal_connect(G_OBJECT(data.window), "destroy", G_CALLBACK(&on_destroy), &data); g_signal_connect(G_OBJECT(data.window), "button-press-event", G_CALLBACK(&on_button_or_key_press), NULL); g_signal_connect(G_OBJECT(data.window), "key-press-event", G_CALLBACK(&on_button_or_key_press), NULL); gtk_widget_realize(data.window); GdkCursor *cursor = gdk_cursor_new(GDK_BLANK_CURSOR); assert(cursor); gdk_window_set_cursor(gtk_widget_get_window(data.window), cursor); g_object_unref(cursor); gtk_window_present(GTK_WINDOW(data.window)); data.pattern = cairo_pattern_create_linear(0.0, 0.0, 1.0, 0.0); cairo_pattern_add_color_stop_rgb(data.pattern, 0.0, BAR_COLOUR_R, BAR_COLOUR_G, BAR_COLOUR_B); cairo_pattern_add_color_stop_rgb(data.pattern, BAR_FRACTION, BAR_COLOUR_R, BAR_COLOUR_G, BAR_COLOUR_B); cairo_pattern_add_color_stop_rgb(data.pattern, BAR_FRACTION, 0.0, 0.0, 0.0); cairo_pattern_add_color_stop_rgb(data.pattern, 1.0, 0.0, 0.0, 0.0); cairo_pattern_set_extend(data.pattern, CAIRO_EXTEND_REPEAT); guint screensaver_suppression_timeout_id = g_timeout_add( SCREENSAVER_SUPPRESSION_PERIOD_MS, &on_screensaver_suppression_timer, NULL); gtk_main(); g_source_remove(screensaver_suppression_timeout_id); cairo_pattern_destroy(data.pattern); return 0; }
/* Sets dialog busy state according to busy * * When busy: * Sets the cursor to busy * Disables the interface to prevent that the user interferes * Reverts all this when non-busy * * Note that this function takes into account the * authentication state of the dialog. So setting the * dialog to busy and then back to normal should leave * the dialog unchanged. */ static void passdlg_set_busy (PasswordDialog *pdialog, gboolean busy) { GtkBuilder *dialog; GtkWidget *toplevel; GdkCursor *cursor = NULL; GdkDisplay *display; dialog = pdialog->ui; /* Set cursor */ toplevel = WID ("change-password"); display = gtk_widget_get_display (toplevel); if (busy) { cursor = gdk_cursor_new_for_display (display, GDK_WATCH); } gdk_window_set_cursor (gtk_widget_get_window (toplevel), cursor); gdk_display_flush (display); if (busy) { gdk_cursor_unref (cursor); } /* Disable/Enable UI */ if (pdialog->authenticated) { /* Authenticated state */ /* Enable/disable new password section */ g_object_set (pdialog->new_password, "sensitive", !busy, NULL); g_object_set (pdialog->retyped_password, "sensitive", !busy, NULL); g_object_set (WID ("new-password-label"), "sensitive", !busy, NULL); g_object_set (WID ("retyped-password-label"), "sensitive", !busy, NULL); /* Enable/disable change password button */ g_object_set (WID ("change-password-button"), "sensitive", !busy, NULL); } else { /* Not-authenticated state */ /* Enable/disable auth section state */ g_object_set (pdialog->current_password, "sensitive", !busy, NULL); g_object_set (WID ("authenticate-button"), "sensitive", !busy, NULL); g_object_set (WID ("current-password-label"), "sensitive", !busy, NULL); } }
static void language_changed (UmEditableCombo *combo, UmUserPanelPrivate *d) { GtkTreeModel *model; GtkTreeIter iter; gchar *lang; UmUser *user; if (!um_editable_combo_get_active_iter (combo, &iter)) return; user = get_selected_user (d); model = um_editable_combo_get_model (combo); gtk_tree_model_get (model, &iter, 0, &lang, -1); if (lang) { if (g_strcmp0 (lang, um_user_get_language (user)) != 0) { um_user_set_language (user, lang); } g_free (lang); goto out; } if (d->language_chooser) { cc_language_chooser_clear_filter (d->language_chooser); gtk_window_present (GTK_WINDOW (d->language_chooser)); gtk_widget_set_sensitive (GTK_WIDGET (combo), FALSE); goto out; } d->language_chooser = cc_language_chooser_new (gtk_widget_get_toplevel (d->main_box), FALSE); g_signal_connect (d->language_chooser, "response", G_CALLBACK (language_response), d); g_signal_connect (d->language_chooser, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); gdk_window_set_cursor (gtk_widget_get_window (gtk_widget_get_toplevel (d->main_box)), NULL); gtk_window_present (GTK_WINDOW (d->language_chooser)); gtk_widget_set_sensitive (GTK_WIDGET (combo), FALSE); out: g_object_unref (user); }
static void error_cb (GdictContext *context, const GError *error, gpointer user_data) { GdictSpeller *speller = GDICT_SPELLER (user_data); GdictSpellerPrivate *priv = speller->priv; gdict_speller_clear (speller); if (gtk_widget_get_window (GTK_WIDGET (speller))) gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (speller)), NULL); g_free (priv->word); priv->word = NULL; priv->is_searching = FALSE; }
static void lookup_start_cb (GdictContext *context, gpointer user_data) { GdictSpeller *speller = GDICT_SPELLER (user_data); GdictSpellerPrivate *priv = speller->priv; if (!priv->busy_cursor) { GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (speller)); priv->busy_cursor = gdk_cursor_new_for_display (display, GDK_WATCH); } if (gtk_widget_get_window (GTK_WIDGET (speller))) gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (speller)), priv->busy_cursor); priv->is_searching = TRUE; }
static void gimp_dialog_factories_unset_busy_foreach (gconstpointer key, GimpDialogFactory *factory, gpointer data) { GList *list; for (list = factory->open_dialogs; list; list = g_list_next (list)) { GtkWidget *widget = list->data; if (GTK_IS_WIDGET (widget) && GTK_WIDGET_TOPLEVEL (widget)) { if (widget->window) gdk_window_set_cursor (widget->window, NULL); } } }
static void dirtree_set_cursor (GtkWidget * widget, GdkCursorType cursor_type) { GdkCursor *cursor = NULL; if (!widget || !widget->window) return; if (cursor_type > -1) cursor = gdk_cursor_new (cursor_type); gdk_window_set_cursor (widget->window, cursor); if (cursor) gdk_cursor_destroy (cursor); gdk_flush (); }
static gboolean vi_list_item_leave_notify_event(GtkWidget *widget, GdkEventCrossing *event, struct vi_list_item_t *item) { PangoAttrList *attrs; PangoAttribute *underline_attr; GdkWindow *window; window = gtk_widget_get_parent_window(widget); gdk_window_set_cursor(window, NULL); attrs = gtk_label_get_attributes(GTK_LABEL(item->label)); underline_attr = pango_attr_underline_new(PANGO_UNDERLINE_NONE); pango_attr_list_change(attrs, underline_attr); gtk_widget_modify_fg(item->label, GTK_STATE_NORMAL, &item->label_color); return FALSE; }
static void accept_password_dialog (GtkButton *button, UmPasswordDialog *um) { const gchar *password; password = gtk_entry_get_text (GTK_ENTRY (um->password_entry)); switch (um->password_mode) { act_user_set_password_mode (um->user, ACT_USER_PASSWORD_MODE_REGULAR); case ACT_USER_PASSWORD_MODE_REGULAR: if (act_user_get_uid (um->user) == getuid ()) { GdkDisplay *display; GdkCursor *cursor; /* When setting a password for the current user, * use passwd directly, to preserve the audit trail * and to e.g. update the keyring password. */ passwd_change_password (um->passwd_handler, password, (PasswdCallback) password_changed_cb, um); gtk_widget_set_sensitive (um->dialog, FALSE); display = gtk_widget_get_display (um->dialog); cursor = gdk_cursor_new_for_display (display, GDK_WATCH); gdk_window_set_cursor (gtk_widget_get_window (um->dialog), cursor); gdk_display_flush (display); g_object_unref (cursor); return; } act_user_set_password (um->user, password, ""); break; case ACT_USER_PASSWORD_MODE_SET_AT_LOGIN: act_user_set_password_mode (um->user, um->password_mode); act_user_set_automatic_login (um->user, FALSE); break; default: g_assert_not_reached (); } finish_password_change (um); }
static void gcal_event_widget_realize (GtkWidget *widget) { GcalEventWidget *self; GdkWindowAttr attributes; GtkAllocation allocation; GdkWindow *parent_window; GdkCursor *pointer_cursor; gint attributes_mask; self = GCAL_EVENT_WIDGET (widget); gtk_widget_set_realized (widget, TRUE); parent_window = gtk_widget_get_parent_window (widget); gtk_widget_set_window (widget, parent_window); g_object_ref (parent_window); gtk_widget_get_allocation (widget, &allocation); attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_ONLY; attributes.x = allocation.x; attributes.y = allocation.y; attributes.width = allocation.width; attributes.height = allocation.height; attributes.event_mask = gtk_widget_get_events (widget); attributes.event_mask |= (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_POINTER_MOTION_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_SMOOTH_SCROLL_MASK | GDK_SCROLL_MASK); attributes_mask = GDK_WA_X | GDK_WA_Y; self->event_window = gdk_window_new (parent_window, &attributes, attributes_mask); gtk_widget_register_window (widget, self->event_window); gdk_window_show (self->event_window); pointer_cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_HAND1); gdk_window_set_cursor (self->event_window, pointer_cursor); }
static GdkCursorType gport_set_cursor (GdkCursorType shape) { GdkWindow *window; GdkCursorType old_shape = gport->X_cursor_shape; GdkColor fg = { 0, 65535, 65535, 65535 }; /* white */ GdkColor bg = { 0, 0, 0, 0 }; /* black */ if (gport->drawing_area == NULL) return GDK_X_CURSOR; window = gtk_widget_get_window (gport->drawing_area); if (gport->X_cursor_shape == shape) return shape; /* check if window exists to prevent from fatal errors */ if (window == NULL) return GDK_X_CURSOR; gport->X_cursor_shape = shape; if (shape > GDK_LAST_CURSOR) { if (shape == CUSTOM_CURSOR_CLOCKWISE) gport->X_cursor = gdk_cursor_new_from_pixmap (XC_clock_source, XC_clock_mask, &fg, &bg, ICON_X_HOT, ICON_Y_HOT); else if (shape == CUSTOM_CURSOR_DRAG) gport->X_cursor = gdk_cursor_new_from_pixmap (XC_hand_source, XC_hand_mask, &fg, &bg, ICON_X_HOT, ICON_Y_HOT); else if (shape == CUSTOM_CURSOR_LOCK) gport->X_cursor = gdk_cursor_new_from_pixmap (XC_lock_source, XC_lock_mask, &fg, &bg, ICON_X_HOT, ICON_Y_HOT); } else gport->X_cursor = gdk_cursor_new (shape); gdk_window_set_cursor (window, gport->X_cursor); gdk_cursor_unref (gport->X_cursor); return old_shape; }
gboolean WnCourt::on_button_press_event_callback(GtkWidget * widget, GdkEventButton *event, WnCourt *wncourt) { if (wncourt->timeout == 0) { wncourt->timeout = g_timeout_add(int(1000/16), do_render_scene, wncourt); } if (event->type == GDK_BUTTON_PRESS) { if (event->button == 1) { wnobj * b; if (event->x > wncourt->widget_width - 15 && event->y > wncourt->widget_height - 15) { wncourt->resizing = true; GdkCursor* cursor = gdk_cursor_new(GDK_SIZING); gdk_window_set_cursor(widget->window, cursor); gdk_cursor_unref(cursor); } else if (wncourt->_court->hit((int)(event->x), (int)(event->y), &b)) { wncourt->dragball = b; wncourt->dragball->set_anchor(true); } else { wncourt->panning = true; } wncourt->oldX = (int)(event->x); wncourt->oldY = (int)(event->y); } else if (event->button == 2) { return FALSE; } } else if (event->type == GDK_2BUTTON_PRESS) { if (event->button == 1) { wnobj * b; if (wncourt->_court->hit((int)(event->x), (int)(event->y), &b)) { if (b->getT() & wnobj::et_word) { char *sWord = g_strdup(b->get_text()); char ***Word; char ****WordData; wncourt->lookup_dict(wncourt->_dictid, sWord, &Word, &WordData); wncourt->set_word(sWord, Word[0], WordData[0]); wncourt->FreeResultData(1, Word, WordData); g_free(sWord); } } else { wncourt->CenterScene(); } } } return TRUE; }
static void ide_frame_set_cursor (IdeFrame *self, const gchar *name) { GdkWindow *window; GdkDisplay *display; GdkCursor *cursor; g_assert (IDE_IS_FRAME (self)); g_assert (name != NULL); window = gtk_widget_get_window (GTK_WIDGET (self)); display = gtk_widget_get_display (GTK_WIDGET (self)); cursor = gdk_cursor_new_from_name (display, name); gdk_window_set_cursor (window, cursor); g_clear_object (&cursor); }
static gboolean utils_mouse_hover_leave_cb(GtkWidget* widget, GdkEvent* evt, gpointer udata) { GdkWindow* win; GdkDisplay* disp; GdkCursor* cursor; win = ((GdkEventMotion*) evt)->window; disp = gdk_window_get_display(win); cursor = gdk_cursor_new_for_display(disp, GDK_LEFT_PTR); gdk_window_set_cursor(win, cursor); g_object_unref(cursor); return FALSE; }
static void lookup_start_cb (GdictContext *context, gpointer user_data) { GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data); GdictDatabaseChooserPrivate *priv = chooser->priv; if (!priv->busy_cursor) { GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (chooser)); priv->busy_cursor = gdk_cursor_new_for_display (display, GDK_WATCH); } if (gtk_widget_get_window (GTK_WIDGET (chooser))) gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), priv->busy_cursor); priv->is_searching = TRUE; }
bool widget_set_cursor(GtkWidget *widget, GdkCursorType type) { GdkCursor *watchCursor; GdkWindow *gdkWindow; g_return_val_if_fail(widget, false); gdkWindow = gtk_widget_get_window(widget); g_return_val_if_fail(gdkWindow, false); watchCursor = gdk_cursor_new(type); gdk_window_set_cursor(gdkWindow, watchCursor); while (gtk_events_pending()) gtk_main_iteration(); return true; }
static void finish_search( FindFile* data ) { if( data->pid ) { int status; kill( data->pid, SIGTERM ); waitpid( data->pid, &status, 0 ); data->pid = 0; /* g_debug( "find process is killed!" ); */ } if( data->task ) { g_object_unref( data->task ); data->task = NULL; } gdk_window_set_cursor( gtk_widget_get_window( data->search_result ), NULL ); gtk_widget_hide( data->stop_btn ); gtk_widget_show( data->again_btn ); }
static gboolean button_press_event_fill( GtkWidget *widget, GdkEventButton *event ) { printf("HI"); //Changing cursor GdkWindow *win = gtk_widget_get_window( GTK_WIDGET( widget ) ); GdkCursor *cur; cur = gdk_cursor_new( GDK_TARGET ); gdk_window_set_cursor( win, cur ); gdk_cursor_unref( cur ); while( gtk_events_pending() ) gtk_main_iteration(); // printf("Handler id : %d\n",handler_id); // g_signal_handler_block(widget, handler_id); // FILL=1; // g_signal_connect(widget, "button_press_event", G_CALLBACK (floodfill_select), GINT_TO_POINTER(10)); return TRUE; }
void trace_set_cursor(GdkCursorType type) { GdkWindow *window; GdkCursor *cursor; if (!parent_window) return; window = GTK_WIDGET(parent_window)->window; /* save the previous cursor */ cursor = gdk_window_get_cursor(window); push_cursor(cursor); cursor = gdk_cursor_new(type); if (!cursor) die("Can't create cursor"); gdk_window_set_cursor(window, cursor); }
/* Realize handler for the image view */ static void image_view_realize (GtkWidget *widget) { GdkWindowAttr attr; int attr_mask; GdkCursor *cursor; g_return_if_fail (widget != NULL); g_return_if_fail (IS_IMAGE_VIEW (widget)); GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); attr.window_type = GDK_WINDOW_CHILD; attr.x = widget->allocation.x; attr.y = widget->allocation.y; attr.width = widget->allocation.width; attr.height = widget->allocation.height; attr.wclass = GDK_INPUT_OUTPUT; attr.visual = gdk_rgb_get_visual (); attr.colormap = gdk_rgb_get_colormap (); attr.event_mask = (gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK | GDK_KEY_PRESS_MASK); attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attr, attr_mask); gdk_window_set_user_data (widget->window, widget); cursor = cursor_get (widget, CURSOR_HAND_OPEN); gdk_window_set_cursor (widget->window, cursor); gdk_cursor_unref (cursor); widget->style = gtk_style_attach (widget->style, widget->window); gdk_window_set_back_pixmap (widget->window, NULL, FALSE); }
/** * he_helper_show_cursor: * @context: A realized GtkWidget. * * Shows a cursor on the screen, for a window. * Its method of getting the x and y coordinate is dodgy - please fix... * **/ void he_helper_show_cursor (GtkWidget *widget) { GdkDisplay *display; GdkScreen *screen; GtkIconTheme *theme; GdkPixbuf *pixbuf; gint x; gint y; GdkCursor *cursor = NULL; g_return_if_fail (widget); g_return_if_fail (GTK_WIDGET_DRAWABLE(widget)); display = gdk_drawable_get_display (GDK_DRAWABLE(widget->window)); g_return_if_fail (display); screen = gtk_widget_get_screen (widget); g_return_if_fail (screen); theme = gtk_icon_theme_get_for_screen (screen); g_return_if_fail (theme); pixbuf = gtk_icon_theme_load_icon (theme, CURSOR_ICON_NAME, CURSOR_ICON_SIZE, 0, NULL); if (!pixbuf) goto cleanup; x = (gdk_pixbuf_get_width (pixbuf) / 2) - 7; y = (gdk_pixbuf_get_height (pixbuf) / 2) - 7; cursor = gdk_cursor_new_from_pixbuf (display, pixbuf, x, y); if (!cursor) goto cleanup; gdk_window_set_cursor (widget->window, cursor); cleanup: if (pixbuf) g_object_unref (pixbuf); if (cursor) gdk_cursor_unref (cursor); }
static gboolean yui_gl_hide_cursor(GtkWidget * widget, GdkEventMotion * event, gpointer user_data) { if (PerGetId(padbits) == PERMOUSE) { int x = event->x; int y = event->y; double speed = g_key_file_get_double(keyfile, "General", "MouseSpeed", NULL); PerMouseMove(padbits, speed * (x - oldx), -speed * (y - oldy)); oldx = x; oldy = y; } if (beforehiding == 0) { gdk_window_set_cursor(widget->window, NULL); g_timeout_add(1000, gonna_hide, widget); } beforehiding = 2; return FALSE; }
/* replaces the current cursor with the specified cursor */ void ui_common_place_cursor_no_wait(ui_common_cursor_t which_cursor, GtkWidget * widget) { GdkCursor * cursor; /* make sure we have cursors */ if (!ui_common_cursors_initialized) ui_common_cursor_init(); /* sanity checks */ if (widget == NULL) return; if (!GTK_WIDGET_REALIZED(widget)) return; if (which_cursor != UI_CURSOR_WAIT) current_cursor = which_cursor; cursor = ui_common_cursor[which_cursor]; gdk_window_set_cursor(gtk_widget_get_parent_window(widget), cursor); return; }
gboolean WnCourt::on_button_release_event_callback(GtkWidget * widget, GdkEventButton *event, WnCourt *wncourt) { if (event->button == 1) { if (wncourt->dragball) { wncourt->dragball->set_anchor(false); wncourt->_court->get_env().reset(); wncourt->dragball = NULL; } if (wncourt->resizing) { GdkCursor* cursor = gdk_cursor_new(GDK_LEFT_PTR); gdk_window_set_cursor(widget->window, cursor); gdk_cursor_unref(cursor); wncourt->resizing = false; } wncourt->panning = false; } else if (event->button == 2) { return FALSE; } return TRUE; }
static void increment_progress_bar_fraction (TotemYouTubePlugin *self, guint tree_view) { gdouble new_value = MIN (gtk_progress_bar_get_fraction (self->progress_bar[tree_view]) + self->progress_bar_increment[tree_view], 1.0); g_debug ("Incrementing progress bar by %f (new value: %f)", self->progress_bar_increment[tree_view], new_value); gtk_progress_bar_set_fraction (self->progress_bar[tree_view], new_value); /* Change the text if the operation's been cancelled */ if (self->cancellable[tree_view] == NULL || g_cancellable_is_cancelled (self->cancellable[tree_view]) == TRUE) gtk_progress_bar_set_text (self->progress_bar[tree_view], _("Cancelling query…")); /* Update the UI */ if (gtk_progress_bar_get_fraction (self->progress_bar[tree_view]) == 1.0) { /* The entire search process (including loading thumbnails and t params) is finished, so update the progress bar */ gdk_window_set_cursor (gtk_widget_get_window (self->vbox), NULL); gtk_progress_bar_set_text (self->progress_bar[tree_view], ""); gtk_progress_bar_set_fraction (self->progress_bar[tree_view], 0.0); } }