void
gtk_inspector_on_inspect (GtkWidget *button,
GtkInspectorWindow *iw)
{
GdkDisplay *display;
GdkCursor *cursor;
GdkGrabStatus status;
if (!iw->invisible)
{
iw->invisible = gtk_invisible_new_for_screen (gdk_screen_get_default ());
gtk_widget_add_events (iw->invisible,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK);
gtk_widget_realize (iw->invisible);
gtk_widget_show (iw->invisible);
}
display = gdk_display_get_default ();
cursor = gdk_cursor_new_from_name (display, "crosshair");
status = gdk_seat_grab (gdk_display_get_default_seat (display),
gtk_widget_get_window (iw->invisible),
GDK_SEAT_CAPABILITY_ALL_POINTING, TRUE,
cursor, NULL, NULL, NULL);
g_object_unref (cursor);
iw->grabbed = status == GDK_GRAB_SUCCESS;
g_signal_connect (iw->invisible, "event", G_CALLBACK (property_query_event), iw);
gtk_grab_add (GTK_WIDGET (iw->invisible));
deemphasize_window (GTK_WIDGET (iw));
}
static void
add_button (GtkWidget *section,
const gchar *css_name)
{
GtkWidget *image, *button;
GdkDisplay *display;
GdkCursor *cursor;
display = gtk_widget_get_display (section);
cursor = gdk_cursor_new_from_name (display, css_name);
if (cursor == NULL)
image = gtk_image_new_from_icon_name ("image-missing", GTK_ICON_SIZE_MENU);
else
{
gchar *path;
path = g_strdup_printf ("/cursors/%s_cursor.png", css_name);
g_strdelimit (path, "-", '_');
image = gtk_image_new_from_resource (path);
g_free (path);
}
gtk_widget_set_size_request (image, 32, 32);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button");
g_signal_connect (button, "clicked", G_CALLBACK (set_cursor), cursor);
gtk_widget_set_tooltip_text (button, css_name);
gtk_container_add (GTK_CONTAINER (section), button);
}
/* Asks the user to click on a window, then waits for them click
* the mouse. When the mouse is released, returns the toplevel
* window under the pointer, or NULL, if there is none.
*/
static GtkWidget *
query_for_toplevel (GdkScreen *screen,
const char *prompt)
{
GdkDisplay *display = gdk_screen_get_display (screen);
GtkWidget *popup, *label, *frame;
GdkCursor *cursor;
GtkWidget *toplevel = NULL;
popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup), screen);
gtk_window_set_modal (GTK_WINDOW (popup), TRUE);
gtk_window_set_position (GTK_WINDOW (popup), GTK_WIN_POS_CENTER);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (popup), frame);
label = gtk_label_new (prompt);
g_object_set (label, "margin", 10, NULL);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show_all (popup);
cursor = gdk_cursor_new_from_name (display, "crosshair");
if (gdk_device_grab (gtk_get_current_event_device (),
gtk_widget_get_window (popup),
GDK_OWNERSHIP_NONE,
FALSE,
GDK_BUTTON_RELEASE_MASK,
cursor,
GDK_CURRENT_TIME) == GDK_GRAB_SUCCESS)
{
gboolean clicked = FALSE;
g_signal_connect (popup, "button-release-event",
G_CALLBACK (button_release_event_cb), &clicked);
/* Process events until clicked is set by button_release_event_cb.
* We pass in may_block=TRUE since we want to wait if there
* are no events currently.
*/
while (!clicked)
g_main_context_iteration (NULL, TRUE);
toplevel = find_toplevel_at_pointer (gdk_screen_get_display (screen));
if (toplevel == popup)
toplevel = NULL;
}
g_object_unref (cursor);
gtk_widget_destroy (popup);
gdk_flush (); /* Really release the grab */
return toplevel;
}
void* iupdrvImageLoad(const char* name, int type)
{
if (type == IUPIMAGE_CURSOR)
#if GTK_CHECK_VERSION(2, 8, 0)
return gdk_cursor_new_from_name(gdk_display_get_default(), name);
#else
return NULL;
#endif
else
{
static void
test_cursor_existence (gconstpointer name)
{
GdkDisplay *display;
GdkCursor *cursor;
display = gdk_display_get_default ();
cursor = gdk_cursor_new_from_name (display, name);
g_assert (cursor != NULL);
g_object_unref (cursor);
}
/**
* glade_cursor_init:
*
* Initializes cursors for use with glade_cursor_set().
*/
void
glade_cursor_init (void)
{
gchar *path;
GError *error = NULL;
GdkDisplay *display;
cursor = g_new0 (GladeCursor, 1);
display = gdk_display_get_default ();
cursor->selector = NULL;
cursor->add_widget = gdk_cursor_new_from_name (display, "crosshair");
cursor->resize_top_left = gdk_cursor_new_from_name (display, "nw-resize");
cursor->resize_top_right = gdk_cursor_new_from_name (display, "ne-resize");
cursor->resize_bottom_left = gdk_cursor_new_from_name (display, "sw-resize");
cursor->resize_bottom_right = gdk_cursor_new_from_name (display, "se-resize");
cursor->resize_left = gdk_cursor_new_from_name (display, "w-resize");
cursor->resize_right = gdk_cursor_new_from_name (display, "e-resize");
cursor->resize_top = gdk_cursor_new_from_name (display, "n-resize");
cursor->resize_bottom = gdk_cursor_new_from_name (display, "s-resize");
cursor->drag = gdk_cursor_new_from_name (display, "move");
cursor->add_widget_pixbuf = NULL;
/* load "add" cursor pixbuf */
path =
g_build_filename (glade_app_get_pixmaps_dir (), ADD_PIXBUF_FILENAME,
NULL);
cursor->add_widget_pixbuf = gdk_pixbuf_new_from_file (path, &error);
if (cursor->add_widget_pixbuf == NULL)
{
g_critical (_("Unable to load image (%s)"), error->message);
g_error_free (error);
error = NULL;
}
g_free (path);
}
static PlatformRefPtr<GdkCursor> createNamedCursor(CustomCursorType cursorType)
{
CustomCursor cursor = CustomCursors[cursorType];
PlatformRefPtr<GdkCursor> c = adoptPlatformRef(gdk_cursor_new_from_name(gdk_display_get_default(), cursor.name));
if (c)
return c;
const GdkColor fg = { 0, 0, 0, 0 };
const GdkColor bg = { 65535, 65535, 65535, 65535 };
IntSize cursorSize = IntSize(32, 32);
PlatformRefPtr<GdkPixmap> source = adoptPlatformRef(createPixmapFromBits(cursor.bits, cursorSize));
PlatformRefPtr<GdkPixmap> mask = adoptPlatformRef(createPixmapFromBits(cursor.mask_bits, cursorSize));
return adoptPlatformRef(gdk_cursor_new_from_pixmap(source.get(), mask.get(), &fg, &bg, cursor.hot_x, cursor.hot_y));
}
/*#
@method new_from_name GdkCursor
@brief Creates a new cursor by looking up name in the current cursor theme.
@param name the name of the cursor
@return a new GdkCursor, or NULL if there is no cursor with the given name
*/
FALCON_FUNC Cursor::new_from_name( VMARG )
{
Item* i_name = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_name || !i_name->isString() )
throw_inv_params( "S" );
#endif
AutoCString name( i_name->asString() );
GdkCursor* cur = gdk_cursor_new_from_name( GET_DISPLAY( vm->self() ), name.c_str() );
if ( cur )
vm->retval( new Gdk::Cursor( vm->findWKI( "GdkCursor" )->asClass(), cur ) );
else
vm->retnil();
}
static gboolean
gth_image_rotator_motion_notify (GthImageViewerTool *base,
GdkEventMotion *event)
{
GthImageRotator *self = GTH_IMAGE_ROTATOR (base);
if (! self->priv->dragging
&& gtk_drag_check_threshold (GTK_WIDGET (self->priv->viewer),
self->priv->drag_p1.x,
self->priv->drag_p1.y,
self->priv->drag_p2.x,
self->priv->drag_p2.y))
{
GdkCursor *cursor;
self->priv->angle_before_dragging = self->priv->angle;
self->priv->dragging = TRUE;
cursor = gdk_cursor_new_from_name (gtk_widget_get_display (GTK_WIDGET (self->priv->viewer)), "grabbing");
gth_image_viewer_set_cursor (self->priv->viewer, cursor);
if (cursor != NULL)
g_object_unref (cursor);
}
if (self->priv->dragging) {
GdkPoint center;
double angle1;
double angle2;
double angle;
self->priv->drag_p2.x = event->x;
self->priv->drag_p2.y = event->y;
center.x = self->priv->center.x * self->priv->preview_zoom + self->priv->preview_image_area.x;
center.y = self->priv->center.y * self->priv->preview_zoom + self->priv->preview_image_area.y;
angle1 = get_angle (¢er, &self->priv->drag_p1);
angle2 = get_angle (¢er, &self->priv->drag_p2);
angle = self->priv->angle_before_dragging + (angle2 - angle1);
if (angle < - G_PI)
angle = G_2_PI + angle;
if (angle > + G_PI)
angle = angle - G_2_PI;
g_signal_emit (self, signals[ANGLE_CHANGED], 0, CLAMP (RAD_TO_DEG (angle), -180.0, 180));
}
return FALSE;
}
static GdkCursor* customCursorNew(CustomCursorType cursorType)
{
CustomCursor cursor = CustomCursors[cursorType];
GdkCursor* c = gdk_cursor_new_from_name(gdk_display_get_default(), cursor.name);
if (!c) {
const GdkColor fg = { 0, 0, 0, 0 };
const GdkColor bg = { 65535, 65535, 65535, 65535 };
GdkPixmap* source = gdk_bitmap_create_from_data(NULL, cursor.bits, 32, 32);
GdkPixmap* mask = gdk_bitmap_create_from_data(NULL, cursor.mask_bits, 32, 32);
c = gdk_cursor_new_from_pixmap(source, mask, &fg, &bg, cursor.hot_x, cursor.hot_y);
g_object_unref(source);
g_object_unref(mask);
}
return c;
}
static GRefPtr<GdkCursor> createNamedCursor(CustomCursorType cursorType)
{
CustomCursor cursor = CustomCursors[cursorType];
GRefPtr<GdkCursor> c = adoptGRef(gdk_cursor_new_from_name(gdk_display_get_default(), cursor.name));
if (c)
return c;
RefPtr<cairo_surface_t> source = adoptRef(cairo_image_surface_create_for_data(const_cast<unsigned char*>(cursor.bits), CAIRO_FORMAT_A1, 32, 32, 4));
RefPtr<cairo_surface_t> mask = adoptRef(cairo_image_surface_create_for_data(const_cast<unsigned char*>(cursor.mask_bits), CAIRO_FORMAT_A1, 32, 32, 4));
RefPtr<cairo_surface_t> surface = adoptRef(cairo_image_surface_create(CAIRO_FORMAT_A1, 32, 32));
RefPtr<cairo_t> cr = adoptRef(cairo_create(surface.get()));
cairo_set_source_surface(cr.get(), source.get(), 0, 0);
cairo_mask_surface(cr.get(), mask.get(), 0, 0);
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(gdk_pixbuf_get_from_surface(surface.get(), 0, 0, 32, 32));
return adoptGRef(gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf.get(), cursor.hot_x, cursor.hot_y));
}
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 VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
GdkCursor* cursor = NULL;
if (argc == 1){
VALUE type;
rb_scan_args(argc, argv, "10", &type);
cursor = gdk_cursor_new(RVAL2GDKCURSORTYPE(type));
} else if (argc == 2) {
VALUE display, type_or_name;
rb_scan_args(argc, argv, "20", &display, &type_or_name);
if (TYPE(type_or_name) == T_STRING)
cursor = gdk_cursor_new_from_name(RVAL2GDKDISPLAYOBJECT(display),
RVAL2CSTR(type_or_name));
else
cursor = gdk_cursor_new_for_display(RVAL2GDKDISPLAYOBJECT(display),
RVAL2GDKCURSORTYPE(type_or_name));
} else if (argc == 4) {
VALUE display, pixbuf, x, y;
rb_scan_args(argc, argv, "40", &display, &pixbuf, &x, &y);
cursor = gdk_cursor_new_from_pixbuf(RVAL2GDKDISPLAYOBJECT(display),
RVAL2GDKPIXBUF(pixbuf),
NUM2INT(x), NUM2INT(y));
/* deprecated
} else if (argc == 6) {
VALUE pixmap, mask, fg, bg, x, y;
rb_scan_args(argc, argv, "60", &pixmap, &mask, &fg, &bg, &x, &y);
cursor = gdk_cursor_new_from_pixmap(RVAL2GDKPIXMAP(pixmap),
NIL_P(mask)?NULL:RVAL2GDKPIXMAP(mask),
RVAL2GDKCOLOR(fg),
RVAL2GDKCOLOR(bg),
NUM2INT(x), NUM2INT(y));
*/
}
G_INITIALIZE(self, cursor);
return Qnil;
}
void ImGui_ImplGtk3Cogl_NewFrame()
{
if (!g_ColorPipeline)
ImGui_ImplGtk3Cogl_CreateDeviceObjects();
bool next_redraw = false;
if (g_NumRedraws > 0)
{
GdkFrameClock *clock = gdk_window_get_frame_clock(g_GdkWindow);
gdk_frame_clock_request_phase(clock, GDK_FRAME_CLOCK_PHASE_PAINT);
g_NumRedraws--;
next_redraw = true;
}
ImGuiIO& io = ImGui::GetIO();
// Setup display size (every frame to accommodate for window resizing)
int w, h;
gdk_window_get_geometry(g_GdkWindow, NULL, NULL, &w, &h);
io.DisplaySize = ImVec2((float)w, (float)h);
io.DisplayFramebufferScale = g_Callbacks->get_scale(g_GdkWindow);
// Setup time step
guint64 current_time = g_get_monotonic_time();
io.DeltaTime = g_Time > 0 ? ((float)(current_time - g_Time) / 1000000) : (float)(1.0f/60.0f);
g_Time = current_time;
// Setup inputs
if (gdk_window_get_state(g_GdkWindow) & GDK_WINDOW_STATE_FOCUSED)
{
io.MousePos = g_MousePosition; // Mouse position in screen coordinates (set to -1,-1 if no mouse / on another screen, etc.)
}
else
{
io.MousePos = ImVec2(-1,-1);
}
GdkDevice *pointer = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_display_get_default()));
GdkModifierType modifiers;
gdk_device_get_state(pointer, g_GdkWindow, NULL, &modifiers);
for (int i = 0; i < 3; i++)
{
io.MouseDown[i] = g_MousePressed[i] || (modifiers & (GDK_BUTTON1_MASK << i)) != 0;
g_MousePressed[i] = false;
}
io.MouseWheel = g_MouseWheel;
g_MouseWheel = 0.0f;
// Hide OS mouse cursor if ImGui is drawing it
GdkDisplay *display = gdk_window_get_display(g_GdkWindow);
GdkCursor *cursor =
gdk_cursor_new_from_name(display, io.MouseDrawCursor ? "none" : "default");
gdk_window_set_cursor(g_GdkWindow, cursor);
g_object_unref(cursor);
// Start the frame
ImGui::NewFrame();
if (!next_redraw && io.WantTextInput)
kick_timeout_redraw(0.2);
}
void
gstyle_eyedropper_set_source_event (GstyleEyedropper *self,
GdkEvent *event)
{
GtkWidget *source;
GtkStyleContext *context;
GtkWidget *box;
GtkWidget *swatch;
GdkGrabStatus status;
gint x_root, y_root;
gint x, y;
g_return_if_fail (GSTYLE_IS_EYEDROPPER (self));
g_return_if_fail (event != NULL);
self->seat = g_object_ref (gdk_event_get_seat (event));
source = gtk_get_event_widget (event);
self->screen = gdk_event_get_screen (event);
g_signal_connect_swapped (self->screen,
"size-changed",
G_CALLBACK (gstyle_eyedropper_screen_size_changed_cb),
self);
self->window = g_object_ref_sink (gtk_window_new (GTK_WINDOW_POPUP));
gtk_window_set_screen (GTK_WINDOW (self->window),self->screen);
gtk_widget_set_name (self->window, "gstyleeyedropper");
context = gtk_widget_get_style_context (self->window);
self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context));
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (self->window), box);
self->zoom_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (self->zoom_area, ZOOM_AREA_WIDTH, ZOOM_AREA_HEIGHT);
gtk_container_add (GTK_CONTAINER (box), self->zoom_area);
swatch = g_object_new (GSTYLE_TYPE_COLOR_WIDGET,
"fallback-name-kind", GSTYLE_COLOR_KIND_RGB_HEX6,
"fallback-name-visible", TRUE,
"color", self->color,
NULL);
gtk_container_add (GTK_CONTAINER (box), swatch);
g_signal_connect_object (self->zoom_area,
"draw",
G_CALLBACK (gstyle_eyedropper_zoom_area_draw_cb),
self,
G_CONNECT_SWAPPED);
self->screen_width = gdk_screen_get_width (self->screen);
self->screen_height = gdk_screen_get_height (self->screen);
gstyle_eyedropper_event_get_root_coords (self, event, &x_root, &y_root);
gstyle_eyedropper_calculate_window_position (self, GTK_WINDOW (self->window), x_root, y_root, &x, &y);
gtk_window_move (GTK_WINDOW (self->window), x, y);
gtk_widget_show_all (self->window);
gtk_widget_add_events (self->window,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
self->cursor = gdk_cursor_new_from_name (gdk_screen_get_display (self->screen), "cell");
gtk_grab_add (self->window);
status = gdk_seat_grab (self->seat,
gtk_widget_get_window (source),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
self->cursor,
event,
NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
{
g_warning ("grab failed status:%i\n", status);
return;
}
self->motion_notify_handler_id =
g_signal_connect_swapped (self->window, "motion-notify-event",
G_CALLBACK (gstyle_eyedropper_pointer_motion_notify_cb),
self);
self->pointer_pressed_handler_id =
g_signal_connect_swapped (self->window,
"button-press-event",
G_CALLBACK (gstyle_eyedropper_pointer_pressed_cb),
self);
self->pointer_wheel_handler_id =
g_signal_connect_swapped (self->window,
"scroll-event",
G_CALLBACK (gstyle_eyedropper_pointer_wheel_cb),
self);
self->key_handler_id =
g_signal_connect_swapped (self->window,
"key-press-event",
G_CALLBACK (gstyle_eyedropper_key_pressed_cb),
self);
self->grab_broken_handler_id =
g_signal_connect_swapped (self->window,
"grab-broken-event",
G_CALLBACK (gstyle_eyedropper_grab_broken_cb),
self);
}
static GRefPtr<GdkCursor> createNamedCursor(const char* name)
{
return adoptGRef(gdk_cursor_new_from_name(gdk_display_get_default(), name));
}
GdkCursor* get_native_cursor(int type)
{
GdkCursor *cursor = NULL;
switch (type) {
case com_sun_glass_ui_Cursor_CURSOR_DEFAULT:
cursor = gdk_cursor_new(GDK_LEFT_PTR);
break;
case com_sun_glass_ui_Cursor_CURSOR_TEXT:
cursor = gdk_cursor_new(GDK_XTERM);
break;
case com_sun_glass_ui_Cursor_CURSOR_CROSSHAIR:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "cross");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "crosshair");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_CROSSHAIR);
break;
case com_sun_glass_ui_Cursor_CURSOR_CLOSED_HAND:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "closedhand");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_HAND2);
break;
case com_sun_glass_ui_Cursor_CURSOR_OPEN_HAND:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "openhand");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_HAND2);
break;
case com_sun_glass_ui_Cursor_CURSOR_POINTING_HAND:
cursor = gdk_cursor_new(GDK_HAND2);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_UP:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "n-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ns-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_ver");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_TOP_SIDE);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_DOWN:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "s-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ns-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_ver");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_BOTTOM_SIDE);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_UPDOWN:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ns-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_ver");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_SB_V_DOUBLE_ARROW);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_LEFT:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "w-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ew-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_hor");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_LEFT_SIDE);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_RIGHT:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "e-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ew-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_hor");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_RIGHT_SIDE);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_LEFTRIGHT:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ew-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_hor");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_SB_H_DOUBLE_ARROW);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_SOUTHWEST:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "sw-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "nesw-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_bdiag");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_BOTTOM_LEFT_CORNER);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_NORTHEAST:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "ne-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "nesw-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_bdiag");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_TOP_RIGHT_CORNER);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_SOUTHEAST:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "se-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "nwse-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_fdiag");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER);
break;
case com_sun_glass_ui_Cursor_CURSOR_RESIZE_NORTHWEST:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "nw-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "nwse-resize");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "size_fdiag");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_TOP_LEFT_CORNER);
break;
case com_sun_glass_ui_Cursor_CURSOR_MOVE:
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "fleur");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "move");
if (cursor == NULL)
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "all-scroll");
if (cursor == NULL)
cursor = gdk_cursor_new(GDK_SIZING);
break;
case com_sun_glass_ui_Cursor_CURSOR_WAIT:
cursor = gdk_cursor_new(GDK_WATCH);
break;
case com_sun_glass_ui_Cursor_CURSOR_DISAPPEAR:
case com_sun_glass_ui_Cursor_CURSOR_NONE:
cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
break;
default:
cursor = gdk_cursor_new(GDK_LEFT_PTR);
break;
}
return cursor;
}
static void process_dnd_source_drag_status(GdkWindow *window, GdkEventDND *event)
{
GdkDragAction selected = GLASS_GDK_DRAG_CONTEXT_GET_SELECTED_ACTION(event->context);
GdkCursor* cursor;
if (selected & GDK_ACTION_COPY) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "dnd-copy");
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "copy");
}
} else if (selected & (GDK_ACTION_MOVE | GDK_ACTION_PRIVATE)) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "dnd-move");
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "move");
}
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "closedhand");
}
} else if (selected & GDK_ACTION_LINK) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "dnd-link");
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "link");
}
} else {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "dnd-no-drop");
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "no-drop");
}
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "not-allowed");
}
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "forbidden");
}
if (cursor == NULL) {
cursor = gdk_cursor_new_from_name(gdk_display_get_default(), "dnd-none");
}
}
if (cursor == NULL) {
cursor = gdk_cursor_new(GDK_LEFT_PTR);
}
dnd_pointer_grab(cursor);
}
int CreateTopWindow(void)
{
#ifdef MOUSE_POINTER_CHANGE
#ifdef WIN32
static const gchar *cr[CURSOR_MODE_3270] = { "arrow",
"wait",
"arrow",
"sizenwse", // Top-left
"sizenesw", // Top-right
"sizens", // Top
"sizenesw", // Bottom-left
"sizenwse", // Bottom-right
"sizens", // Bottom
"sizewe", // Left
"sizewe", // Right
"sizeall" // Inside
};
#else
static int cr[CURSOR_MODE_3270] = { GDK_XTERM,
GDK_WATCH,
GDK_X_CURSOR,
GDK_TOP_LEFT_CORNER, // Top-left
GDK_TOP_RIGHT_CORNER, // Top-right
GDK_TOP_SIDE, // Top
GDK_BOTTOM_LEFT_CORNER, // Bottom-left
GDK_BOTTOM_RIGHT_CORNER, // Bottom-right
GDK_BOTTOM_SIDE, // Bottom
GDK_LEFT_SIDE, // Left
GDK_RIGHT_SIDE, // Right
GDK_FLEUR // Inside
};
#endif // WIN32
int f;
#endif // MOUSE_POINTER_CHANGE
static const struct ui_menu_setup_table widget_setup[] =
{
{ "fontselect", setup_font_select_menu },
{ "inputmethod", setup_input_methods_menu },
{ "screensizes", setup_screen_size_menu },
{ NULL, NULL }
};
gchar *ptr;
init_actions();
#ifdef MOUSE_POINTER_CHANGE
// Load mouse pointers
#ifdef WIN32
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new_from_name(gdk_display_get_default(), cr[f]);
#else
for(f=0;f<CURSOR_MODE_3270;f++)
wCursor[f] = gdk_cursor_new(cr[f]);
#endif
#endif // MOUSE_POINTER_CHANGE
if(!CreateTerminalWindow())
return -1;
// Load UI - Create toplevel window
ptr = g_build_filename(program_data,"ui",NULL);
topwindow = create_window_from_ui_files(ptr,terminal,widget_setup);
g_free(ptr);
// Load program logo
load_icon();
/*
if(program_logo && g_file_test(program_logo,G_FILE_TEST_IS_REGULAR))
{
pix = gdk_pixbuf_new_from_file(program_logo,NULL);
}
else
{
gchar *filename = g_build_filename(program_data,PROGRAM_LOGO,NULL);
if(g_file_test(filename,G_FILE_TEST_IS_REGULAR))
pix = gdk_pixbuf_new_from_file(filename, NULL);
Trace("pixbuf(%s): %p",filename,pix);
g_free(filename);
}
if(pix)
{
gtk_window_set_icon(GTK_WINDOW(topwindow),pix);
g_object_set_data_full(G_OBJECT(topwindow),"logo",pix,g_object_unref);
#if defined( HAVE_IGEMAC )
gtk_osxapplication_set_dock_icon_pixbuf(osxapp,pix);
#endif
}
*/
gtk_action_set_sensitive(action_by_id[ACTION_RESELECT],FALSE);
g_signal_connect(G_OBJECT(topwindow),"destroy",G_CALLBACK(action_quit),0);
// gtk_window_set_icon_list(GTK_WINDOW(topwindow),main_icon);
gtk_window_set_default_size(GTK_WINDOW(topwindow),590,430);
ptr = GetString("TopWindow","Title","");
settitle(ptr);
g_free(ptr);
action_restore(0);
gtk_window_set_position(GTK_WINDOW(topwindow),GTK_WIN_POS_CENTER);
return 0;
}
