/* This function exists because GDK retrieves client coordinates, not window ones. (Kevin: GDK uses GetClientRect and ClientToScreen). We need that to save and restore windows position. */ void window_get_rect(GtkWidget *widget, GdkRect *rect) { gtk_window_get_size(GTK_WINDOW(widget), &rect->w, &rect->h); #ifdef __WIN32__ { BOOL bResult; HWND hWnd = GDK_WINDOW_HWND(widget->window); RECT lpRect; GdkRectangle gdkRect; bResult = GetWindowRect(hWnd, &lpRect); rect->x = lpRect.left; rect->y = lpRect.top; // Now obtain and add the offset between GDK and Win32 coordinates // (in the multi-screen case). gdk_screen_get_monitor_geometry(gdk_screen_get_default(), 0, &gdkRect); rect->x += gdkRect.x; rect->y += gdkRect.y; } #else gdk_window_get_position(widget->window, &rect->x, &rect->y); #endif }
gboolean gd_tagged_entry_tag_get_area (GdTaggedEntryTag *tag, cairo_rectangle_int_t *rect) { GtkStyleContext *context; GtkAllocation background_allocation; int window_x, window_y; GtkAllocation alloc; g_return_val_if_fail (GD_IS_TAGGED_ENTRY_TAG (tag), FALSE); g_return_val_if_fail (rect != NULL, FALSE); gdk_window_get_position (tag->window, &window_x, &window_y); gtk_widget_get_allocation (GTK_WIDGET (tag->entry), &alloc); context = gd_tagged_entry_tag_get_context (tag, tag->entry); gd_tagged_entry_tag_get_relative_allocations (tag, tag->entry, context, &background_allocation, NULL, NULL); rect->x = window_x - alloc.x + background_allocation.x; rect->y = window_y - alloc.y + background_allocation.y; rect->width = background_allocation.width; rect->height = background_allocation.height; return TRUE; }
/** * anjuta_tabber_get_widget_coordinates: * @widget: widget for the coordinates * @event: event to get coordinates from * @x: return location for x coordinate * @y: return location for y coordinate * * Returns: %TRUE if coordinates were set, %FALSE otherwise */ static gboolean anjuta_tabber_get_widget_coordinates (GtkWidget *widget, GdkEvent *event, gint *x, gint *y) { GdkWindow *window = ((GdkEventAny *)event)->window; gdouble tx, ty; if (!gdk_event_get_coords (event, &tx, &ty)) return FALSE; while (window && window != gtk_widget_get_window (widget)) { gint window_x, window_y; gdk_window_get_position (window, &window_x, &window_y); tx += window_x; ty += window_y; window = gdk_window_get_parent (window); } if (window) { *x = tx; *y = ty; return TRUE; } else return FALSE; }
static VALUE gdkwin_get_position(VALUE self) { gint x, y; gdk_window_get_position(_SELF(self), &x, &y); return rb_assoc_new(INT2NUM(x), INT2NUM(y)); }
/** \brief Retrieve info from window, needed for accel layer */ void UI_getWindowInfo(void *draw, GUI_WindowInfo *xinfo) { GdkWindow *win; GtkWidget *widget=(GtkWidget *)draw; win = gtk_widget_get_parent_window(widget); #ifdef __WIN32 xinfo->display = (void*)GDK_WINDOW_HWND(widget->window); #elif defined(__APPLE__) int windowWidth, windowHeight; int x, y; gdk_drawable_get_size(win, &windowWidth, &windowHeight); gdk_window_get_position(widget->window, &x, &y); xinfo->display = 0; xinfo->window = getMainNSWindow(); xinfo->x = x; xinfo->y = windowHeight - (y + lastH); xinfo->width = lastW; xinfo->height = lastH; #else xinfo->window = GDK_WINDOW_XWINDOW(widget->window); xinfo->display = GDK_WINDOW_XDISPLAY(win); #endif }
void WinDraw_InitWindowSize(WORD width, WORD height) { static BOOL inited = FALSE; if (!inited) { GdkWindow *t, *root = window->window; while ((t = gdk_window_get_parent(root)) != 0) root = t; gdk_window_get_size(root, &root_width, &root_height); inited = TRUE; } gdk_window_get_position(window->window, &winx, &winy); winw = width; winh = height; if (root_width < winw) winx = (root_width - winw) / 2; else if (winx < 0) winx = 0; else if ((winx + winw) > root_width) winx = root_width - winw; if (root_height < winh) winy = (root_height - winh) / 2; else if (winy < 0) winy = 0; else if ((winy + winh) > root_height) winy = root_height - winh; }
/** \brief Retrieve info from window, needed for accel layer */ void UI_getWindowInfo(void *draw, GUI_WindowInfo *xinfo) { GdkWindow *win, *parentWin; GtkWidget *widget=(GtkWidget *)draw; win = gtk_widget_get_window(widget); parentWin = gtk_widget_get_parent_window(widget); #ifdef _WIN32 xinfo->display = (void*)GDK_WINDOW_HWND(win); #elif defined(__APPLE__) xinfo->display = 0; xinfo->window = getMainNSWindow(); #else xinfo->systemWindowId = GDK_WINDOW_XID(win); xinfo->display = GDK_WINDOW_XDISPLAY(parentWin); #endif int windowWidth, windowHeight; int x, y; windowWidth = gdk_window_get_width(parentWin); windowHeight = gdk_window_get_height(parentWin); gdk_window_get_position(win, &x, &y); xinfo->x = x; xinfo->y = windowHeight - (y + lastH); xinfo->width = lastW; xinfo->height = lastH; }
/* Translates coordinates from dest_widget->window relative (src_x, src_y), * to allocation relative (dest_x, dest_y) of dest_widget. */ static void window_to_alloc (GtkWidget *dest_widget, gint src_x, gint src_y, gint *dest_x, gint *dest_y) { /* Translate from window relative to allocation relative */ if (gtk_widget_get_has_window (dest_widget) && dest_widget->parent) { gint wx, wy; gdk_window_get_position (dest_widget->window, &wx, &wy); /* Offset coordinates if widget->window is smaller than * widget->allocation. */ src_x += wx - dest_widget->allocation.x; src_y += wy - dest_widget->allocation.y; } else { src_x -= dest_widget->allocation.x; src_y -= dest_widget->allocation.y; } if (dest_x) *dest_x = src_x; if (dest_y) *dest_y = src_y; }
/* panel_window_get_position */ void panel_window_get_position(PanelWindow * panel, gint * x, gint * y) { GdkWindow * window; window = gtk_widget_get_window(panel->window); gdk_window_get_position(window, x, y); }
static gboolean on_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) { cairo_t *cr; gint x, y, width, height; int i; cr = gdk_cairo_create(widget->window); gdk_window_get_position(widget->window, &x, &y); gdk_drawable_get_size(widget->window, &width, &height); cairo_set_source_rgb (cr, 0, 0, 0); //cairo_set_source(cr, bgpattern); cairo_paint (cr); for (i = 0; i < NUM_CIRCLES; ++i) { draw_circle(cr, width, height, circles + i); } cairo_destroy(cr); return FALSE; }
static void size_allocate(GtkWidget* widget, GtkAllocation* alloc) { wxPizza* pizza = WX_PIZZA(widget); int border_x, border_y; pizza->get_border_widths(border_x, border_y); int w = alloc->width - 2 * border_x; if (w < 0) w = 0; if (gtk_widget_get_realized(widget)) { int h = alloc->height - 2 * border_y; if (h < 0) h = 0; const int x = alloc->x + border_x; const int y = alloc->y + border_y; GdkWindow* window = gtk_widget_get_window(widget); int old_x, old_y; gdk_window_get_position(window, &old_x, &old_y); if (x != old_x || y != old_y || w != gdk_window_get_width(window) || h != gdk_window_get_height(window)) { gdk_window_move_resize(window, x, y, w, h); if (border_x + border_y) { // old and new border areas need to be invalidated, // otherwise they will not be erased/redrawn properly GdkWindow* parent = gtk_widget_get_parent_window(widget); gdk_window_invalidate_rect(parent, &widget->allocation, false); gdk_window_invalidate_rect(parent, alloc, false); } } } widget->allocation = *alloc; // adjust child positions for (const GList* list = pizza->m_fixed.children; list; list = list->next) { const GtkFixedChild* child = static_cast<GtkFixedChild*>(list->data); if (gtk_widget_get_visible(child->widget)) { GtkAllocation child_alloc; // note that child positions do not take border into // account, they need to be relative to widget->window, // which has already been adjusted child_alloc.x = child->x - pizza->m_scroll_x; child_alloc.y = child->y - pizza->m_scroll_y; GtkRequisition req; gtk_widget_get_child_requisition(child->widget, &req); child_alloc.width = req.width; child_alloc.height = req.height; if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) child_alloc.x = w - child_alloc.x - child_alloc.width; gtk_widget_size_allocate(child->widget, &child_alloc); } } }
static void pizza_size_allocate(GtkWidget* widget, GtkAllocation* alloc) { wxPizza* pizza = WX_PIZZA(widget); GtkBorder border; pizza->get_border(border); int w = alloc->width - border.left - border.right; if (w < 0) w = 0; if (gtk_widget_get_realized(widget)) { int h = alloc->height - border.top - border.bottom; if (h < 0) h = 0; const int x = alloc->x + border.left; const int y = alloc->y + border.top; GdkWindow* window = gtk_widget_get_window(widget); int old_x, old_y; gdk_window_get_position(window, &old_x, &old_y); if (x != old_x || y != old_y || w != gdk_window_get_width(window) || h != gdk_window_get_height(window)) { gdk_window_move_resize(window, x, y, w, h); if (border.left + border.right + border.top + border.bottom) { // old and new border areas need to be invalidated, // otherwise they will not be erased/redrawn properly GtkAllocation old_alloc; gtk_widget_get_allocation(widget, &old_alloc); GdkWindow* parent = gtk_widget_get_parent_window(widget); gdk_window_invalidate_rect(parent, &old_alloc, false); gdk_window_invalidate_rect(parent, alloc, false); } } } gtk_widget_set_allocation(widget, alloc); // adjust child positions for (const GList* p = pizza->m_children; p; p = p->next) { const wxPizzaChild* child = static_cast<wxPizzaChild*>(p->data); if (gtk_widget_get_visible(child->widget)) { GtkAllocation child_alloc; // note that child positions do not take border into // account, they need to be relative to widget->window, // which has already been adjusted child_alloc.x = child->x - pizza->m_scroll_x; child_alloc.y = child->y - pizza->m_scroll_y; child_alloc.width = child->width; child_alloc.height = child->height; if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) child_alloc.x = w - child_alloc.x - child_alloc.width; gtk_widget_size_allocate(child->widget, &child_alloc); } } }
static gboolean cb_panel_size_allocate(GtkWidget *widget, GtkAllocation *size, GkrellmPanel *p) { gdk_window_get_position(p->drawing_area->window, NULL, &p->y_mapped); if (_GK.frame_left_panel_overlap > 0 || _GK.frame_right_panel_overlap > 0) _GK.need_frame_packing = TRUE; return FALSE; }
static gboolean is_in_viewport (GtkWindow *window, GdkScreen *screen, gint workspace, gint viewport_x, gint viewport_y) { GdkScreen *s; GdkDisplay *display; GdkWindow *gdkwindow; const gchar *cur_name; const gchar *name; gint cur_n; gint n; gint ws; gint sc_width, sc_height; gint x, y, width, height; gint vp_x, vp_y; /* Check for screen and display match */ display = gdk_screen_get_display (screen); cur_name = gdk_display_get_name (display); cur_n = gdk_screen_get_number (screen); s = gtk_window_get_screen (window); display = gdk_screen_get_display (s); name = gdk_display_get_name (display); n = gdk_screen_get_number (s); if (strcmp (cur_name, name) != 0 || cur_n != n) { return FALSE; } /* Check for workspace match */ ws = gedit_utils_get_window_workspace (window); if (ws != workspace && ws != GEDIT_ALL_WORKSPACES) { return FALSE; } /* Check for viewport match */ gdkwindow = gtk_widget_get_window (GTK_WIDGET (window)); gdk_window_get_position (gdkwindow, &x, &y); width = gdk_window_get_width (gdkwindow); height = gdk_window_get_height (gdkwindow); gedit_utils_get_current_viewport (screen, &vp_x, &vp_y); x += vp_x; y += vp_y; sc_width = gdk_screen_get_width (screen); sc_height = gdk_screen_get_height (screen); return x + width * .25 >= viewport_x && x + width * .75 <= viewport_x + sc_width && y >= viewport_y && y + height <= viewport_y + sc_height; }
static void nsp_window_main_menu_position (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data) { GtkWidget *button = GTK_WIDGET(user_data); GdkWindow *window = gtk_widget_get_window(button); gdk_window_get_position(window, x, y); *x += 1; *y += button->allocation.height; }
CAMLprim value ml_gdk_window_get_position (value window) { int x, y; value ret; gdk_window_get_position (GdkWindow_val(window), &x, &y); ret = alloc_small (2,0); Field(ret,0) = Val_int(x); Field(ret,1) = Val_int(y); return ret; }
static void menu_pos( GtkMenu* menu, int* x, int* y, gboolean *push_in, GtkWidget* btn ) { GtkAllocation allocation; /* FIXME: I'm not sure if this work well in different WMs */ gdk_window_get_position( gtk_widget_get_window( btn ), x, y); /* gdk_window_get_root_origin( btn->window, x, y); */ gtk_widget_get_allocation ( GTK_WIDGET( btn ), &allocation ); *x += allocation.x; *y += allocation.y + allocation.height; *push_in = FALSE; }
static gboolean cb_treeview_motion (GtkWidget *widget, GdkEventMotion *event, StfDialogData *pagedata) { int x = (int)event->x; int col, dx; RenderData_t *renderdata = pagedata->fixed.renderdata; int old_ruler_x = pagedata->fixed.ruler_x; int colstart, colend, colwidth; gpointer user; pagedata->fixed.ruler_x = -1; /* We get events from the buttons too. Translate x. */ gdk_window_get_user_data (event->window, &user); if (GTK_IS_BUTTON (user)) { int ewx; gdk_window_get_position (event->window, &ewx, NULL); x += ewx; } stf_preview_find_column (renderdata, x, &col, &dx); colstart = (col == 0) ? 0 : stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col - 1); colend = stf_parse_options_fixed_splitpositions_nth (pagedata->parseoptions, col); colwidth = (colend == -1) ? G_MAXINT : colend - colstart; if (col >= 0 && col < renderdata->colcount) { int ci = calc_char_index (renderdata, col, &dx); if (ci <= colwidth) { int padx; GtkCellRenderer *cell = stf_preview_get_cell_renderer (renderdata, col); gtk_cell_renderer_get_padding (cell, &padx, NULL); pagedata->fixed.ruler_x = x - dx + padx; } } gdk_event_request_motions (event); if (pagedata->fixed.ruler_x == old_ruler_x) return FALSE; queue_redraw (widget, old_ruler_x); queue_redraw (widget, pagedata->fixed.ruler_x); return FALSE; }
/* *------------------------------------------------------------------- * window *------------------------------------------------------------------- */ static void collection_window_get_geometry(CollectWindow *cw) { CollectionData *cd; GdkWindow *window; if (!cw) return; cd = cw->cd; window = gtk_widget_get_window(cw->window); gdk_window_get_position(window, &cd->window_x, &cd->window_y); cd->window_w = gdk_window_get_width(window); cd->window_h = gdk_window_get_height(window); cd->window_read = TRUE; }
static gboolean gnc_header_draw (GtkWidget *header, cairo_t *cr) { GnucashSheet *sheet = GNC_HEADER(header)->sheet; GdkWindow *sheet_layout_win = gtk_layout_get_bin_window (GTK_LAYOUT(sheet)); gint x, y; // use this to get the scroll x value to align the header gdk_window_get_position (sheet_layout_win, &x, &y); cairo_set_source_surface (cr, GNC_HEADER(header)->surface, x, 0); cairo_paint (cr); return TRUE; }
GtkWidget* get_child_at_pos(GtkWidget* container, gfloat x, gfloat y) { GList *children = gtk_container_get_children(GTK_CONTAINER(container)); int len = g_list_length(children); int i; for(i =0; i < len; i++) { gint px, py, width, height; GdkWindow *w = gtk_widget_get_window(g_list_nth_data(children, i)); gdk_window_get_position(w, &px, &py); gtk_widget_get_size_request(w, &width, &height); if(x >= px && x <= px + width && y >= py && y <= py + height) return w; } return NULL; }
static gboolean popup_button_press(GtkWidget *popup, GdkEventButton *event, GebrGuiToolButton *button) { GdkWindow *window = gtk_widget_get_window(popup); gint xroot, yroot, width, height; gdk_window_get_position(window, &xroot, &yroot); gdk_drawable_get_size(GDK_DRAWABLE(window), &width, &height); if (event->x_root < xroot || event->x_root > xroot + width || event->y_root < yroot || event->y_root > yroot + height) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); return TRUE; }
/** * eel_gdk_window_get_bounds: * @gdk_window: The source GdkWindow. * * Return value: An EelIRect representation of the given GdkWindow's geometry * relative to its parent in the Gdk window hierarchy. * */ EelIRect eel_gdk_window_get_bounds (GdkWindow *gdk_window) { EelIRect bounds; int width; int height; g_return_val_if_fail (gdk_window != NULL, eel_irect_empty); gdk_window_get_position (gdk_window, &bounds.x0, &bounds.y0); gdk_drawable_get_size (gdk_window, &width, &height); bounds.x1 = bounds.x0 + width; bounds.y1 = bounds.y0 + height; return bounds; }
/* This function exists because GDK retrieves client coordinates, not window ones. (Kevin: GDK uses GetClientRect and ClientToScreen). We need that to save and restore windows position. */ void window_get_rect(GtkWidget *widget, GdkRect *rect) { gtk_window_get_size(GTK_WINDOW(widget), &rect->w, &rect->h); gdk_window_get_position(widget->window, &rect->x, &rect->y); #ifdef __WIN32__ { BOOL bResult; HWND hWnd = GDK_WINDOW_HWND(widget->window); RECT lpRect; bResult = GetWindowRect(hWnd, &lpRect); rect->x = lpRect.left; rect->y = lpRect.top; } #endif }
static gboolean overlay_enter_notify_cb (GtkWidget *parent, GdkEventCrossing *event, gpointer user_data) { GtkWidget *widget = user_data; CheckPointerData *data; gint y_pos; NautilusFloatingBar *self = NAUTILUS_FLOATING_BAR (widget); if (self->hover_timeout_id != 0) { g_source_remove (self->hover_timeout_id); } if (event->window != gtk_widget_get_window (widget)) { return GDK_EVENT_PROPAGATE; } if (NAUTILUS_FLOATING_BAR (widget)->is_interactive) { return GDK_EVENT_PROPAGATE; } gdk_window_get_position (gtk_widget_get_window (widget), NULL, &y_pos); data = g_slice_new (CheckPointerData); data->overlay = parent; data->floating_bar = widget; data->device = gdk_event_get_device ((GdkEvent *) event); data->y_down_limit = y_pos; data->y_upper_limit = y_pos + gtk_widget_get_allocated_height (widget); self->hover_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT, HOVER_HIDE_TIMEOUT_INTERVAL, check_pointer_timeout, data, check_pointer_data_free); g_source_set_name_by_id (self->hover_timeout_id, "[nautilus-floating-bar] overlay_enter_notify_cb"); return GDK_EVENT_STOP; }
static void save_window (GString *s, GdkWindow *window) { gint x, y; GdkColor *color; gdk_window_get_position (window, &x, &y); color = g_object_get_data (G_OBJECT (window), "color"); g_string_append_printf (s, "%d,%d %dx%d (%d,%d,%d) %d %d\n", x, y, gdk_window_get_width (window), gdk_window_get_height (window), color->red, color->green, color->blue, gdk_window_has_native (window), g_list_length (gdk_window_peek_children (window))); save_children (s, window); }
static void move_window_clicked (GtkWidget *button, gpointer data) { GdkWindow *window; GtkDirectionType direction; GList *selected, *l; gint x, y; direction = GPOINTER_TO_INT (data); selected = get_selected_windows (); for (l = selected; l != NULL; l = l->next) { window = l->data; gdk_window_get_position (window, &x, &y); switch (direction) { case GTK_DIR_UP: y -= 10; break; case GTK_DIR_DOWN: y += 10; break; case GTK_DIR_LEFT: x -= 10; break; case GTK_DIR_RIGHT: x += 10; break; default: break; } gdk_window_move (window, x, y); } g_list_free (selected); }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetGetLocationOnScreenUnlocked (JNIEnv * env, jobject obj, jintArray jpoint) { void *ptr; jint *point; GtkWidget *widget; ptr = gtkpeer_get_widget (env, obj); point = (*env)->GetIntArrayElements (env, jpoint, 0); widget = get_widget(GTK_WIDGET (ptr)); while(gtk_widget_get_parent(widget) != NULL) widget = gtk_widget_get_parent(widget); gdk_window_get_position (GTK_WIDGET(widget)->window, point, point+1); *point += GTK_WIDGET(ptr)->allocation.x; *(point+1) += GTK_WIDGET(ptr)->allocation.y; (*env)->ReleaseIntArrayElements(env, jpoint, point, 0); }
JNIEXPORT void JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1position ( JNIEnv* env, jclass cls, jlong _self, jintArray _x, jintArray _y ) { GdkWindow* self; gint* x; gint* y; // convert parameter self self = (GdkWindow*) _self; // convert parameter x x = (gint*) (*env)->GetIntArrayElements(env, _x, NULL); if (x == NULL) { return; // Java Exception already thrown } // convert parameter y y = (gint*) (*env)->GetIntArrayElements(env, _y, NULL); if (y == NULL) { return; // Java Exception already thrown } // call function gdk_window_get_position(self, x, y); // cleanup parameter self // cleanup parameter x (*env)->ReleaseIntArrayElements(env, _x, (jint*)x, 0); // cleanup parameter y (*env)->ReleaseIntArrayElements(env, _y, (jint*)y, 0); }
Rect Ctrl::GetWndScreenRect() const { GuiLock __; if(IsOpen()) { gint x, y; gdk_window_get_position(gdk(), &x, &y); #if GTK_CHECK_VERSION(2, 24, 0) gint width = gdk_window_get_width(gdk()); gint height = gdk_window_get_height(gdk()); #else gint width, height; gdk_drawable_get_size(gdk(), &width, &height); #endif return RectC(x, y, width, height); } return Null; }