gboolean ly_3lrc_desktop_on_drag_cb( GtkWidget * widget, GdkEvent *event, gpointer data)
{
//GdkCursor *cursor;
if (event->button.button == 1)
{
switch(event->type)
{
case GDK_BUTTON_PRESS:
pos_old[X] = event->button.x;
pos_old[Y] = event->button.y;
flag_drag=TRUE;
//鼠标变成手形
//cursor= gdk_cursor_new(GDK_FLEUR);
//gdk_window_set_cursor(widget->window,cursor);
//gdk_cursor_destroy(cursor);
break;
case GDK_BUTTON_RELEASE:
flag_drag=FALSE;
//鼠标变成默认箭头
//cursor= gdk_cursor_new(GDK_LEFT_PTR);
//gdk_window_set_cursor(widget->window,cursor);
//gdk_cursor_destroy(cursor);
gtk_window_get_position(GTK_WINDOW(widget), &(pos_old[X]), &(pos_old[Y]));
int x=0;
int y=0;
int w=1000;
int h=50;
ly_reg_get("3lrc_desktop_pos_and_size", "%d:%d:%d:%d", &x, &y, &w, &h);
ly_reg_set("3lrc_desktop_pos_and_size", "%d:%d:%d:%d", pos_old[X], pos_old[Y], w, h);
break;
case GDK_MOTION_NOTIFY:
if(flag_drag)
{
int x, y;
GtkWidget *window = widget;
gtk_window_get_position(GTK_WINDOW(window), &x, &y);
gtk_window_move((GtkWindow *) window,x+event->button.x-pos_old[X],y+event->button.y-pos_old[Y]);
}
default:
break;
}
}
switch(event->type)
{
case GDK_ENTER_NOTIFY:
flag_notify=TRUE;
break;
case GDK_LEAVE_NOTIFY:
if(!flag_drag)
flag_notify=FALSE;
break;
default:
break;
}
return TRUE;
}
// save window position on program termination
extern "C" G_MODULE_EXPORT void on_window_destroy (GtkObject *object, gpointer user_data) {
gtk_label_set_text(GTK_LABEL(debug), "Terminating...");
gtk_widget_queue_draw (debug); // force a refresh
while (gtk_events_pending ())
gtk_main_iteration ();
gtk_window_get_position(GTK_WINDOW(window), &conf.x, &conf.y);
gtk_window_get_position(GTK_WINDOW(lookup), &conf.lx, &conf.ly);
gtk_window_get_size(GTK_WINDOW(lookup), &conf.dx, &conf.dy);
gtk_main_quit ();
}
/*
* This is function return if the point (x,y) in inside the ardesia bar window.
*/
gboolean
inside_bar_window (gdouble xp,
gdouble yp)
{
gint x = 0;
gint y = 0;
gint width = 0;
gint height = 0;
gdouble xd = 0;
gdouble yd = 0;
GtkWindow *bar = GTK_WINDOW (get_bar_window ());
gtk_window_get_position (bar, &x, &y);
xd = (gdouble) x;
yd = (gdouble) y;
gtk_window_get_size (bar, &width, &height);
if ((yp>=yd) && (yp<yd+height))
{
if ((xp>=xd) && (xp<xd+width))
{
return 1;
}
}
return 0;
}
void wxTopLevelWindowGTK::GTKConfigureEvent(int x, int y)
{
wxPoint point;
#ifdef GDK_WINDOWING_X11
if (gs_decorCacheValid)
{
const DecorSize& decorSize = GetCachedDecorSize();
point.x = x - decorSize.left;
point.y = y - decorSize.top;
}
else
#endif
{
gtk_window_get_position(GTK_WINDOW(m_widget), &point.x, &point.y);
}
if (m_x != point.x || m_y != point.y)
{
m_x = point.x;
m_y = point.y;
wxMoveEvent event(point, GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
}
}
int af_window_get_top()
{
GtkWidget *window = global_get("window");
int x, y;
gtk_window_get_position(GTK_WINDOW(window), &x, &y);
return y;
}
static void
on_unmap (GtkWidget *widget, gpointer user_data)
{
GError *error = NULL;
GKeyFile *keys;
const char *filename, *group;
char *dirname, *data;
int x, y, w, h;
keys = get_key_file ();
group = g_object_get_data (G_OBJECT (widget), GROUP_PROP);
gtk_window_get_position (GTK_WINDOW (widget), &x, &y);
g_key_file_set_integer (keys, group, WINDOW_X, x);
g_key_file_set_integer (keys, group, WINDOW_Y, y);
gtk_window_get_size (GTK_WINDOW (widget), &w, &h);
g_key_file_set_integer (keys, group, WINDOW_WIDTH, w);
g_key_file_set_integer (keys, group, WINDOW_HEIGHT, h);
filename = get_filename ();
dirname = g_path_get_dirname (filename);
g_mkdir_with_parents (dirname, 0755);
g_free (dirname);
data = g_key_file_to_data (keys, NULL, NULL);
if (!g_file_set_contents (filename, data, -1, &error)) {
g_warning ("Cannot write key file: %s", error->message);
g_error_free (error);
}
g_free (data);
g_key_file_free (keys);
}
static gboolean
geometry_store_cb (gpointer user_data)
{
GdkWindowState window_state;
GdkWindow *gdk_window;
GSettings *ui_settings;
gboolean maximized;
gint x, y, w, h;
if (!gtk_widget_get_visible (GTK_WIDGET (user_data))){
return FALSE;
}
/* Get window metrics and status */
gtk_window_get_position (GTK_WINDOW (user_data), &x, &y);
gtk_window_get_size (GTK_WINDOW (user_data), &w, &h);
gdk_window = gtk_widget_get_window (GTK_WIDGET (user_data));
window_state = gdk_window_get_state (gdk_window);
maximized = (window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
/* Save values */
ui_settings = g_object_get_data (G_OBJECT (user_data), GEOMETRY_DATA_NAME);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_X_POS, x);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_Y_POS, y);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_WIDTH, w);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_HEIGHT, h);
g_settings_set_boolean (ui_settings, TWITUX_UI_WINDOW_MAXIMISED, maximized);
save_queue_id = 0;
return FALSE;
}
static gboolean OnClosePreviewWindow(GtkWidget* window, GdkEvent* event_info, PREVIEW_WINDOW* preview)
{
APPLICATION *app = (APPLICATION*)g_object_get_data(G_OBJECT(window), "application_data");
gint x, y;
gint width, height;
gtk_window_get_position(GTK_WINDOW(window), &x, &y);
gtk_window_get_size(GTK_WINDOW(window), &width, &height);
preview->window_x = x, preview->window_y = y;
preview->window_width = width, preview->window_height = height;
cairo_destroy(preview->cairo_p);
preview->cairo_p = NULL;
cairo_surface_destroy(preview->surface_p);
preview->surface_p = NULL;
MEM_FREE_FUNC(preview->pixels);
preview->pixels = NULL;
MEM_FREE_FUNC(preview->reverse_buff);
preview->reverse_buff = NULL;
app->flags |= APPLICATION_IN_DELETE_EVENT;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(preview->menu_item), FALSE);
app->flags &= ~(APPLICATION_IN_DELETE_EVENT);
preview->window = NULL;
return FALSE;
}
void C4DevmodeDlg::SwitchPage(GtkWidget* widget)
{
bool is_visible = gtk_widget_get_visible(GTK_WIDGET(window));
// Remember window position
if (window != NULL && is_visible)
gtk_window_get_position(GTK_WINDOW(window), &x, &y);
if (widget != NULL)
{
assert(window != NULL);
// Show required page
int page_num = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), widget);
assert(page_num != -1); // Make sure it is contained
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), page_num);
gtk_window_set_title(GTK_WINDOW(window), gtk_notebook_get_tab_label_text(GTK_NOTEBOOK(notebook), widget));
// Show window if not visible
if (!is_visible)
{
gtk_widget_show(window);
if (x != -1 || y != -1)
gtk_window_move(GTK_WINDOW(window), x, y);
}
}
else
{
if (window != NULL && is_visible)
gtk_widget_hide(window);
}
}
static gboolean
DestroyHelpWindow( GtkWidget *win, GdkEvent *event, void *ptr )
{
int i;
GtkWidget *widget;
char tmp[ 20 ];
gint x, y;
/* get the slider position and save it */
widget = lookup_widget( win, PANED );
i = gtk_paned_get_position( GTK_PANED( widget ));
wPrefSetInteger( HTMLHELPSECTION, SLIDERPREFNAME, i );
/* get the window position */
gtk_window_get_position( (GtkWindow *)win, &x, &y );
sprintf( tmp, "%d %d", x, y );
wPrefSetString( HTMLHELPSECTION, WINDOWPOSPREFNAME, tmp );
/* get the window size */
gtk_window_get_size( (GtkWindow *)win , &x, &y );
sprintf( tmp, "%d %d", x, y );
wPrefSetString( HTMLHELPSECTION, WINDOWSIZEPREFNAME, tmp );
gtk_widget_hide( win );
return TRUE;
}
/**
* Print a window's position and size.
* @param window window to print information about
*/
void mk_print_GtkWindow_info(GtkWindow* window)
{
gint x, y, w, h;
gtk_window_get_position(window, &x, &y);
gtk_window_get_size(window, &w, &h);
g_printf("\t%d,%d\t%d,%d", x, y, w, h);
}
void toolkit_loop()
{
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_add(GTK_CONTAINER(window), (GtkWidget*)client->get_widget());
g_timeout_add(50, gtk_ui_recheck, nullptr);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_ui_destroy), nullptr);
gtk_window_set_resizable(GTK_WINDOW(window), client->is_resizable());
gtk_window_set_title(GTK_WINDOW(window), client->get_title());
gtk_window_get_position(GTK_WINDOW(window), &last_x, &last_y);
gtk_window_get_size(GTK_WINDOW(window), &last_width, &last_height);
if (settings.contains(QString("%1/pos_x").arg(client->get_title())))
{
last_x = settings.value(QString("%1/pos_x").arg(client->get_title()), last_x).toInt();
last_y = settings.value(QString("%1/pos_y").arg(client->get_title()), last_y).toInt();
gtk_window_move(GTK_WINDOW(window), last_x, last_y);
if (client->is_resizable())
{
last_width = settings.value(QString("%1/width").arg(client->get_title()), last_width).toInt();
last_height = settings.value(QString("%1/height").arg(client->get_title()), last_height).toInt();
gtk_window_resize(GTK_WINDOW(window), last_width, last_height);
}
}
osc_send_update();
// Main loop
gtk_main();
}
void window_get_position(ui::Window window, WindowPosition &position)
{
ASSERT_MESSAGE( window , "error saving window position" );
gtk_window_get_position( window, &position.x, &position.y );
gtk_window_get_size( window, &position.w, &position.h );
}
static gboolean
thunar_progress_dialog_toggled (ThunarProgressDialog *dialog,
GdkEventButton *event,
GtkStatusIcon *status_icon)
{
_thunar_return_val_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog), FALSE);
_thunar_return_val_if_fail (GTK_IS_STATUS_ICON (status_icon), FALSE);
/* check if the window is visible and has the focus */
if (gtk_widget_get_visible (GTK_WIDGET (dialog))
&& gtk_window_is_active (GTK_WINDOW (dialog)))
{
/* remember the position of the dialog */
gtk_window_get_position (GTK_WINDOW (dialog), &dialog->x, &dialog->y);
/* it is, so hide it now */
gtk_widget_hide (GTK_WIDGET (dialog));
}
else
{
/* check if the dialog is invisible */
if (!gtk_widget_get_visible (GTK_WIDGET (dialog)))
{
/* restore its previous position before presenting it */
gtk_window_move (GTK_WINDOW (dialog), dialog->x, dialog->y);
}
/* it's not, so we need to raise it above other windows */
gtk_window_present_with_time (GTK_WINDOW (dialog), event->time);
}
return TRUE;
}
void get_win0_geom()
{
if (!gwin0)
return;
gtk_window_get_position(GTK_WINDOW(gwin0), &win_x, &win_y);
get_win_size(gwin0, &win_xl, &win_yl);
}
static void configuration_save(running_machine &machine, int config_type, xml_data_node *parentnode)
{
/* we only care about game files */
if (config_type != CONFIG_TYPE_GAME)
return;
// Loop over all the nodes
for(win_i *p = win_list; p != NULL; p = p->next)
{
/* create a node */
xml_data_node *debugger_node;
debugger_node = xml_add_child(parentnode, "window", NULL);
xml_set_attribute_int(debugger_node, "type", p->type);
if (debugger_node != NULL)
{
int x, y;
gtk_window_get_position(GTK_WINDOW(p->win), &x, &y);
xml_set_attribute_int(debugger_node, "position_x", x);
xml_set_attribute_int(debugger_node, "position_y", y);
gtk_window_get_size(GTK_WINDOW(p->win), &x, &y);
xml_set_attribute_int(debugger_node, "size_x", x);
xml_set_attribute_int(debugger_node, "size_y", y);
}
}
}
int get_widget_xy(GtkWidget *win, GtkWidget *widget, int *rx, int *ry)
{
if (!win && !widget)
p_err("get_widget_xy err");
// gdk_flush();
GtkRequisition sz;
gtk_widget_get_preferred_size(widget, NULL, &sz);
int wx, wy;
wx=wy=0;
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
gtk_widget_translate_coordinates(widget, win,
0, sz.height, &wx, &wy);
// dbg("%d wx:%d\n", index, wx);
int win_x, win_y;
gtk_window_get_position(GTK_WINDOW(win), &win_x, &win_y);
int win_xl, win_yl;
get_win_size(win, &win_xl, &win_yl);
if (wx > win_xl)
wx = win_xl;
*rx = win_x + wx;
*ry = win_y + wy;
return wx;
}
gboolean
tray_toggle_visibility(gboolean force_hide)
{
static int x, y;
static GdkScreen *screen;
GtkWindow *win;
session *sess = sess_list->data;
if (!sticon)
return FALSE;
win = fe_gui_info_ptr(sess, 0);
tray_stop_flash();
tray_reset_counts();
if (!win)
return FALSE;
if (force_hide || GTK_WIDGET_VISIBLE(win))
{
gtk_window_get_position(win, &x, &y);
screen = gtk_window_get_screen(win);
gtk_widget_hide(GTK_WIDGET(win));
}
else
{
gtk_window_set_screen(win, screen);
gtk_window_move(win, x, y);
gtk_widget_show(GTK_WIDGET (win));
gtk_window_present(win);
}
return TRUE;
}
static void
show_layout_response (GtkWidget * dialog, gint resp)
{
GdkRectangle rect;
GtkWidget *kbdraw;
const gchar *groupName;
switch (resp) {
case GTK_RESPONSE_HELP:
gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (dialog)),
"ghelp:gswitchit?layout-view",
gtk_get_current_event_time (), NULL);
return;
case GTK_RESPONSE_CLOSE:
gtk_window_get_position (GTK_WINDOW (dialog), &rect.x,
&rect.y);
gtk_window_get_size (GTK_WINDOW (dialog), &rect.width,
&rect.height);
gkbd_preview_save_position (&rect);
gtk_widget_destroy (dialog);
break;
case GTK_RESPONSE_PRINT:
kbdraw =
GTK_WIDGET (g_object_get_data
(G_OBJECT (dialog), "kbdraw"));
groupName =
(const gchar *) g_object_get_data (G_OBJECT (dialog),
"groupName");
gkbd_keyboard_drawing_print (GKBD_KEYBOARD_DRAWING
(kbdraw), GTK_WINDOW (dialog),
groupName ? groupName :
_("Unknown"));
}
}
void tray_init(GtkWidget * main_window) {
gdk_pixbuf_xlib_init (GDK_DISPLAY(), DefaultScreen (GDK_DISPLAY()));
/* local copy */
window = main_window;
gtk_window_get_position(GTK_WINDOW(window), &x_pos, &y_pos);
tray_create_menu();
busy_ani = tray_icon_load_animation ("busy.ani", TRUE);
ready_ani = tray_icon_load_animation("ready.ani", FALSE);
frame_basic = load_pixmap_as_pixbuf("trayicon/frame_basic.png");
if (frame_basic)
tray_icon = egg_tray_icon_new ("xqf", frame_basic);
if (tray_icon && tray_icon->ready) {
g_signal_connect(tray_icon, "button_press_event", G_CALLBACK(tray_icon_pressed),tray_icon);
gtk_widget_hide(window);
}
else
gtk_widget_show(window);
}
static gboolean
on_window_delete(GtkWidget *window, GdkEvent *event, ReaderWindowPrivate *priv)
{
if (!cainteoir_settings_get_boolean(priv->settings, "window", "maximized", FALSE))
{
gint width = 0;
gint height = 0;
gint top = 0;
gint left = 0;
gtk_window_get_position(GTK_WINDOW(priv->self), &left, &top);
gtk_window_get_size(GTK_WINDOW(priv->self), &width, &height);
cainteoir_settings_set_integer(priv->settings, "window", "width", width);
cainteoir_settings_set_integer(priv->settings, "window", "height", height);
cainteoir_settings_set_integer(priv->settings, "window", "top", top);
cainteoir_settings_set_integer(priv->settings, "window", "left", left);
}
cainteoir_settings_set_string(priv->settings, "index", "type",
reader_document_view_get_index_type(READER_DOCUMENT_VIEW(priv->view)));
cainteoir_settings_set_integer(priv->settings, "index", "position",
reader_document_view_get_index_pane_position(READER_DOCUMENT_VIEW(priv->view)));
cainteoir_settings_set_boolean(priv->settings, "index", "visible",
reader_document_view_get_index_pane_visible(READER_DOCUMENT_VIEW(priv->view)));
cainteoir_settings_save(priv->settings);
return FALSE;
}
G_MODULE_EXPORT void
gw_radicalswindow_show_cb (GtkWidget *widget, gpointer data)
{
//Declarations
GtkWindow *window;
GtkScrolledWindow *scrolledwindow;
GtkPolicyType policy;
int x, y, width, height, max_height;
//Initializations
window = GTK_WINDOW (widget);
if (window == NULL) return;
scrolledwindow = GTK_SCROLLED_WINDOW (data);
gtk_scrolled_window_get_policy (scrolledwindow, NULL, &policy);
gtk_scrolled_window_set_policy (scrolledwindow, GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_widget_queue_resize_no_redraw (GTK_WIDGET (window));
gtk_window_get_position (window, &x, &y);
gtk_window_get_size (window, &width, &height);
max_height = gdk_screen_height () - y;
if (max_height > 50) max_height -= 50;
if (height > max_height)
{
gtk_scrolled_window_set_policy (scrolledwindow, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_window_resize (GTK_WINDOW (window), width, max_height);
}
else
{
gtk_scrolled_window_set_policy (scrolledwindow, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
}
return;
}
static int slow_show_win(gpointer data)
{
Win *win = (Win *) data;
int x_diff;
int x, y;
if (win->size == NHEIGHT) {
win->handlerid =
g_signal_connect(G_OBJECT(win->win),
"enter-notify-event",
G_CALLBACK(mouseover_win), data);
/* Trace animation timeout */
win->ani_timer_id = 0;
win->timeout_id = gtk_timeout_add(
popup_timeout, wait_win, data);
return FALSE;
}
gtk_window_get_position(GTK_WINDOW(win->win), &x, &y);
y -= STEPS;
win->size += STEPS;
x_diff = width - win->win->allocation.width;
if (x_diff < 0)
x_diff = 0;
gtk_window_move(GTK_WINDOW(win->win), x_diff, y);
return TRUE;
}
/**
* polkit_mate_authentication_dialog_indicate_error:
* @dialog: the auth dialog
*
* Call this function to indicate an authentication error; typically shakes the window
**/
void
polkit_mate_authentication_dialog_indicate_error (PolkitMateAuthenticationDialog *dialog)
{
int x, y;
int n;
int diff;
/* TODO: detect compositing manager and do fancy stuff here */
gtk_window_get_position (GTK_WINDOW (dialog), &x, &y);
for (n = 0; n < 10; n++)
{
if (n % 2 == 0)
diff = -15;
else
diff = 15;
gtk_window_move (GTK_WINDOW (dialog), x + diff, y);
while (gtk_events_pending ())
{
gtk_main_iteration ();
}
g_usleep (10000);
}
gtk_window_move (GTK_WINDOW (dialog), x, y);
}
void
gimmix_save_window_pos (void)
{
gint x,y;
gchar xpos[4];
gchar ypos[4];
gchar width[4];
gchar height[4];
/* save position and geometry */
gtk_window_get_position (GTK_WINDOW(main_window), &x, &y);
sprintf (xpos, "%d", x);
sprintf (ypos, "%d", y);
gtk_window_get_size (GTK_WINDOW(main_window), &x, &y);
sprintf (width, "%d", x);
sprintf (height, "%d", y);
cfg_add_key (&conf, "window_xpos", xpos);
cfg_add_key (&conf, "window_ypos", ypos);
cfg_add_key (&conf, "window_width", width);
cfg_add_key (&conf, "window_height", height);
/* save mode */
if (GTK_WIDGET_VISIBLE (GTK_WIDGET(playlist_box)))
cfg_add_key (&conf, "full_view_mode", "true");
else
cfg_add_key (&conf, "full_view_mode", "false");
gimmix_config_save ();
return;
}
void ZLGtkProgressDialog::run(ZLRunnable &runnable) {
while (gtk_events_pending()) {
gtk_main_iteration();
}
GtkWindow *mainWindow = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
gtk_window_set_accept_focus(mainWindow, FALSE);
myLabel = gtk_label_new(messageText().c_str());
gtk_misc_set_padding(GTK_MISC(myLabel), 10, 10); // something nice?
gtk_container_add(GTK_CONTAINER(mainWindow), myLabel);
gtk_widget_show_all(GTK_WIDGET(mainWindow));
GdkCursor *cursor = gdk_cursor_new(GDK_WATCH);
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, cursor);
}
gdk_window_set_cursor(GTK_WIDGET(mainWindow)->window, cursor);
gdk_cursor_unref(cursor);
int x, y, w, h;
if (myParent != 0) {
gtk_window_get_position(myParent, &x, &y);
gtk_window_get_size(myParent, &w, &h);
x += w / 2;
y += h / 2;
} else {
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
gdk_window_get_geometry(root, &x, &y, &w, &h, 0);
x += w / 2;
y += h / 2;
}
gtk_window_get_size(mainWindow, &w, &h);
x -= w / 2;
y -= h / 2;
gtk_window_move(mainWindow, x, y);
while (gtk_events_pending()) {
gtk_main_iteration();
}
if (myParent != 0) {
gtk_widget_queue_draw(GTK_WIDGET(myParent));
}
while (gtk_events_pending()) {
gtk_main_iteration();
}
runnable.run();
myLabel = 0;
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, 0);
}
gtk_widget_destroy(GTK_WIDGET(mainWindow));
}
static gint delete_event(GtkWidget* widget, GdkEvent* event, gpointer data)
{
gint main_wnd_pos_x = 0, main_wnd_pos_y = 0;
gtk_window_get_position(GTK_WINDOW(g_pEngine->GetMainWindow()), &main_wnd_pos_x, &main_wnd_pos_y);
g_pEngine->SetMainWndPos(main_wnd_pos_x, main_wnd_pos_y);
gtk_widget_hide_all(widget);
return TRUE;
}
void module_win_geom()
{
if (!win_anthy)
return;
gtk_window_get_position(GTK_WINDOW(win_anthy), gmf.mf_win_x, gmf.mf_win_y);
gmf.mf_get_win_size(win_anthy, gmf.mf_win_xl, gmf.mf_win_yl);
}
// TODO allow specifying either as NULL on all platforms
void uiWindowPosition(uiWindow *w, int *x, int *y)
{
gint rx, ry;
gtk_window_get_position(w->window, &rx, &ry);
*x = rx;
*y = ry;
}
int Fenetre::coordEnY() const {
if (!existe) return -1;
else {
gint x,y;
gtk_window_get_position(GTK_WINDOW(fenetre),&x,&y);
return y;
}
}
