Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
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);
    }
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 9
0
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;
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
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);
        }
    }
}
Ejemplo n.º 12
0
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 ();
}
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
0
Archivo: gui-misc.c Proyecto: bert/pcb
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;
}
Ejemplo n.º 17
0
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;
}
Ejemplo n.º 18
0
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);
}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
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;
}
Ejemplo n.º 22
0
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 );
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
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);
}
Ejemplo n.º 25
0
/* 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);
}
Ejemplo n.º 26
0
/**
 * 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);
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
0
/* 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;
}
Ejemplo n.º 29
0
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;
}
Ejemplo n.º 30
0
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);
	}
}