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; } }