static gboolean on_parallel_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) { gchar layout[10]; gint x; gint y; gdk_window_get_root_origin(GDK_WINDOW(gtk_widget_get_window(dialog_parallel)), &x, &y); settings.parallel_width = event->width; settings.parallel_height = event->height; settings.parallel_x = x; settings.parallel_y = y; sprintf(layout, "%d", settings.parallel_width); xml_set_value("Xiphos", "layout", "parallel_width", layout); sprintf(layout, "%d", settings.parallel_height); xml_set_value("Xiphos", "layout", "parallel_height", layout); sprintf(layout, "%d", settings.parallel_x); xml_set_value("Xiphos", "layout", "parallel_x", layout); sprintf(layout, "%d", settings.parallel_y); xml_set_value("Xiphos", "layout", "parallel_y", layout); xml_save_settings_doc(settings.fnconfigure); return FALSE; }
gint layout_geometry_get_tools(LayoutWindow *lw, gint *x, gint *y, gint *w, gint *h, gint *divider_pos) { if (!layout_valid(&lw)) return FALSE; if (!lw->tools || !GTK_WIDGET_VISIBLE(lw->tools)) { /* use the stored values (sort of breaks success return value) */ *divider_pos = lw->div_float; return FALSE; } gdk_window_get_root_origin(lw->tools->window, x, y); gdk_drawable_get_size(lw->tools->window, w, h); if (GTK_IS_VPANED(lw->tools_pane)) { *divider_pos = GTK_PANED(lw->tools_pane)->child1->allocation.height; } else { *divider_pos = GTK_PANED(lw->tools_pane)->child1->allocation.width; } return TRUE; }
static VALUE gdkwin_get_root_origin(VALUE self) { int x, y; gdk_window_get_root_origin(_SELF(self), &x, &y); return rb_assoc_new(INT2FIX(x), INT2FIX(y)); }
gint title_motion_event(GtkWidget *widget, GdkEventMotion *event) { gint mov_x, mov_y; gint win_x, win_y; gint xp, yp; GdkModifierType mask; static GdkWindow *root_win = NULL; //LOG(LOG_DEBUG, "IN : title_motion_event()"); if((event->state & GDK_BUTTON1_MASK) && bbutton_down){ root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ()); gdk_window_get_pointer (root_win, &xp, &yp, &mask); mov_x = xp - prev_x; mov_y = yp - prev_y; gdk_window_get_root_origin(popup->window, &win_x, &win_y); gtk_window_move(GTK_WINDOW(popup), win_x + mov_x, win_y + mov_y); prev_x = xp; prev_y = yp; } //LOG(LOG_DEBUG, "OUT : title_motion_event()"); return(FALSE); }
static gboolean on_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) { gchar layout[80]; gint x; gint y; gdk_window_get_root_origin(gtk_widget_get_window(widgets.app), &x, &y); settings.gs_width = event->width; settings.gs_height = event->height; settings.app_x = x; settings.app_y = y; #ifdef HAVE_GTK_312 sprintf(layout, "%d", gtk_window_is_maximized(GTK_WINDOW(widgets.app))); xml_set_value("Xiphos", "layout", "maximized", layout); #endif sprintf(layout, "%d", settings.gs_width); xml_set_value("Xiphos", "layout", "width", layout); sprintf(layout, "%d", settings.gs_height); xml_set_value("Xiphos", "layout", "height", layout); sprintf(layout, "%d", settings.app_x); xml_set_value("Xiphos", "layout", "app_x", layout); sprintf(layout, "%d", settings.app_y); xml_set_value("Xiphos", "layout", "app_y", layout); xml_save_settings_doc(settings.fnconfigure); return FALSE; }
static void gtkDialogGetWindowDecor(Ihandle* ih, int *win_border, int *win_caption) { int x, y, frame_x, frame_y; gdk_window_get_origin(iupgtkGetWindow(ih->handle), &x, &y); gdk_window_get_root_origin(iupgtkGetWindow(ih->handle), &frame_x, &frame_y); *win_border = x-frame_x; *win_caption = y-frame_y-*win_border; }
static int gtkDialogGetWindowDecor(Ihandle* ih, int *win_border, int *win_caption) { int x, y, frame_x, frame_y; gdk_window_get_origin(ih->handle->window, &x, &y); gdk_window_get_root_origin(ih->handle->window, &frame_x, &frame_y); *win_border = x-frame_x; *win_caption = y-frame_y-*win_border; return 1; /* just for compatibility with iupdrvGetWindowDecor */ }
gint layout_geometry_get(LayoutWindow *lw, gint *x, gint *y, gint *w, gint *h) { if (!layout_valid(&lw)) return FALSE; gdk_window_get_root_origin(lw->window->window, x, y); gdk_drawable_get_size(lw->window->window, w, h); return TRUE; }
static void fftscope_hide() { gint x, y; if (scope_win) { gdk_window_get_root_origin(scope_win->window, &x, &y); gtk_widget_hide(scope_win); gtk_widget_set_uposition(scope_win, x, y); } }
void ShowDialog(UIDialog* dialog, gchar* default_widget) { gint sw, sh; gint px, py; gint pw, ph; gint cw, ch; gint ox, oy; if( dialog->parent != NULL ) { sw = gdk_screen_width(); sh = gdk_screen_height(); gtk_widget_realize(dialog->window); gtk_window_set_transient_for(GTK_WINDOW(dialog->window), GTK_WINDOW(dialog->parent->window)); gdk_window_get_root_origin(dialog->parent->window->window, &px, &py); gdk_window_get_size(dialog->parent->window->window, &pw, &ph); gdk_window_get_size(dialog->window->window, &cw, &ch); ox = (pw - cw) / 2; if( ox < 20 ) ox = 20; oy = (ph - ch) / 2; if( oy < 20 ) oy = 20; if( px + ox + cw > sw ) ox = sw - cw - px - 20; if( py + oy + ch > sh ) oy = sh - ch - py - 20; if( dialog->pos_x == 0 ) dialog->pos_x = px + ox; if( dialog->pos_y == 0 ) dialog->pos_y = py + oy; } gtk_widget_set_uposition(dialog->window, dialog->pos_x, dialog->pos_y); if( default_widget ) { GtkWidget* widget = LookupWidget(dialog->window, default_widget); if( widget ) { gtk_widget_grab_focus(widget); gtk_widget_grab_default(widget); } } gtk_widget_show(dialog->window); gtk_main(); }
void HideDialog(UIDialog* dialog) { gint pos_x, pos_y; gdk_window_get_root_origin(dialog->window->window, &pos_x, &pos_y); dialog->pos_x = pos_x; dialog->pos_y = pos_y; gtk_widget_hide(GetTopWidget(dialog->window)); gtk_main_quit(); }
void tasks_add_edit_window_close_cb (GtkWidget *widget, GdkEvent *event, gpointer user_data) { GUI *appGUI = (GUI *)user_data; gtk_window_get_size (GTK_WINDOW(appGUI->tsk->tasks_add_window), &config.tasks_addedit_win_w, &config.tasks_addedit_win_h); gdk_window_get_root_origin (GDK_WINDOW(appGUI->tsk->tasks_add_window->window), &config.tasks_addedit_win_x, &config.tasks_addedit_win_y); gtk_widget_destroy(appGUI->tsk->tasks_add_window); }
char *iupdrvGetGlobal(const char *name) { if (iupStrEqual(name, "VIRTUALSCREEN")) { GdkScreen *screen = gdk_screen_get_default(); GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default()); int x = 0; int y = 0; int w = gdk_screen_get_width(screen); int h = gdk_screen_get_height(screen); gdk_window_get_root_origin(root, &x, &y); return iupStrReturnStrf("%d %d %d %d", x, y, w, h); } if (iupStrEqual(name, "MONITORSINFO")) { int i; GdkScreen *screen = gdk_screen_get_default(); int monitors_count = gdk_screen_get_n_monitors(screen); char *str = iupStrGetMemory(monitors_count*50); char* pstr = str; GdkRectangle rect; for (i=0; i < monitors_count; i++) { gdk_screen_get_monitor_geometry(screen, i, &rect); pstr += sprintf(pstr, "%d %d %d %d\n", rect.x, rect.y, rect.width, rect.height); } return str; } if (iupStrEqual(name, "TRUECOLORCANVAS")) { return iupStrReturnBoolean(gdk_visual_get_best_depth() > 8); } if (iupStrEqual(name, "UTF8MODE")) { return iupStrReturnBoolean(iupgtkStrGetUTF8Mode()); } if (iupStrEqual(name, "UTF8AUTOCONVERT")) { return iupStrReturnBoolean(!iupgtkStrGetUTF8Mode()); } if (iupStrEqual(name, "SHOWMENUIMAGES")) { gboolean menu_images; g_object_get (gtk_settings_get_default (), "gtk-menu-images", &menu_images, NULL); return iupStrReturnBoolean(menu_images); } return NULL; }
/* "borrowed" from http://mail.gnome.org/archives/gtk-app-devel-list/2004-November/msg00028.html */ static void widget_get_rect_in_screen( GtkWidget *widget, GdkRectangle *r ) { gint x,y,w,h; GdkRectangle extents; GdkWindow *window; window = gtk_widget_get_parent_window(widget); /* getting parent window */ gdk_window_get_root_origin(window, &x,&y); /* parent's left-top screen coordinates */ gdk_drawable_get_size(window, &w,&h); /* parent's width and height */ gdk_window_get_frame_extents(window, &extents); /* parent's extents (including decorations) */ r->x = x + (extents.width-w)/2 + widget->allocation.x; /* calculating x (assuming: left border size == right border size) */ r->y = y + (extents.height-h)-(extents.width-w)/2 + widget->allocation.y; /* calculating y (assuming: left border size == right border size == bottom border size) */ r->width = widget->allocation.width; r->height = widget->allocation.height; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWindowGetLocationOnScreenUnlocked (JNIEnv * env, jobject obj, jintArray jpoint) { void *ptr; jint *point; ptr = gtkpeer_get_widget (env, obj); point = (*env)->GetIntArrayElements (env, jpoint, 0); gdk_window_get_root_origin (get_widget(GTK_WIDGET (ptr))->window, point, point+1); (*env)->ReleaseIntArrayElements(env, jpoint, point, 0); }
void export_window_close_cb (GtkWidget *widget, GdkEvent *event, gpointer user_data) { GUI *appGUI = (GUI *)user_data; gtk_window_get_size (GTK_WINDOW(appGUI->cnt->export_window), &config.contacts_export_win_w, &config.contacts_export_win_h); gdk_window_get_root_origin (GDK_WINDOW(appGUI->cnt->export_window->window), &config.contacts_export_win_x, &config.contacts_export_win_y); gtk_widget_destroy(appGUI->cnt->export_window); appGUI->cnt->output_file_entry = NULL; appGUI->cnt->export_button = NULL; }
static gboolean configure_callback(GtkWidget * w, GdkEventConfigure *event, gpointer data) { visualizer_t * win; win = (visualizer_t*)data; win->x = event->x; win->y = event->y; win->width = event->width; win->height = event->height; gdk_window_get_root_origin(win->current_window->window->window, &win->x, &win->y); return FALSE; }
static gboolean list_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { gint mx,my; gint wx,wy,ww,wh; gdk_window_get_root_origin(widget->window,&wx,&wy); gdk_window_get_size(widget->window,&ww,&wh); mx = (gint) (event->x_root); my = (gint) (event->y_root); /*printf("mouse: <%d,%d>, window: <%d,%d>+<%d,%d>\n",mx,my,wx,wy,ww,wh);*/ if (mx < wx || mx > wx+ww || my < wy || my > wy+wh) gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "motion-notify-event"); return FALSE; }
static gboolean popup_button_press_event_cb (GtkWidget *popup_window, GdkEventButton *event, PlannerPopupButton *popup_button) { GtkAllocation alloc; gdouble x, y; gint xoffset, yoffset; gint x1, y1; gint x2, y2; /* Popdown the window if the click is outside of it. */ if (event->button != 1) { return FALSE; } x = event->x_root; y = event->y_root; gdk_window_get_root_origin (popup_window->window, &xoffset, &yoffset); xoffset += popup_window->allocation.x; yoffset += popup_window->allocation.y; alloc = popup_window->allocation; x1 = alloc.x + xoffset; y1 = alloc.y + yoffset; x2 = x1 + alloc.width; y2 = y1 + alloc.height; if (x > x1 && x < x2 && y > y1 && y < y2) { return FALSE; } planner_popup_button_popdown (popup_button, FALSE); return FALSE; }
JNIEXPORT void JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1get_1root_1origin ( 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_root_origin(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); }
static gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win ) { if (g_isIdle) wxapp_install_idle_handler(); if (!win->m_hasVMT || !win->IsShown()) return FALSE; int x = 0; int y = 0; gdk_window_get_root_origin( win->m_widget->window, &x, &y ); win->m_x = x; win->m_y = y; wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() ); mevent.SetEventObject( win ); win->HandleWindowEvent( mevent ); return FALSE; }
static gboolean gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win ) { // don't need to install idle handler, its done from "event" signal if (!win->m_hasVMT || !win->IsShown()) return FALSE; int x = 0; int y = 0; gdk_window_get_root_origin( win->m_widget->window, &x, &y ); win->m_x = x; win->m_y = y; wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() ); mevent.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( mevent ); return FALSE; }
void gui_window_close_cb (GtkWidget *widget, gpointer data) { gui_url_remove_links (&about_links_list, &about_link_index); gui_url_remove_links (&contacts_links_list, &contacts_link_index); if (calendar_only == FALSE) { if (current_tab == PAGE_CALENDAR || current_tab == PAGE_TASKS || current_tab == PAGE_CONTACTS) { config.latest_tab = current_tab; } config.find_mode = gtk_combo_box_get_active (GTK_COMBO_BOX(contacts_find_combobox)); gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON(notes_button), FALSE); gtk_window_get_size (GTK_WINDOW(main_window), &config.window_size_x, &config.window_size_y); } gdk_window_get_root_origin (main_window->window, &config.window_x, &config.window_y); pango_font_description_free(fd_day_name); pango_font_description_free(fd_calendar); pango_font_description_free(fd_notes); if (calendar_only == FALSE) { calendar_update_note (day, month, year); write_notes (); write_tasks_entries(); write_tasks_entries(); write_contacts_entries(); } gtk_main_quit (); }
/** * gimp_session_info_read_geometry: * @info: A #GimpSessionInfo * @cevent A #GdkEventConfigure. If set, use the size from here * instead of from the window allocation. * * Read geometry related information from the associated widget. **/ void gimp_session_info_read_geometry (GimpSessionInfo *info, GdkEventConfigure *cevent) { GdkWindow *window; g_return_if_fail (GIMP_IS_SESSION_INFO (info)); g_return_if_fail (GTK_IS_WINDOW (info->p->widget)); window = gtk_widget_get_window (info->p->widget); if (window) { gint x, y; gdk_window_get_root_origin (window, &x, &y); /* Don't write negative values to the sessionrc, they are * interpreted as relative to the right, respective bottom edge * of the screen. */ info->p->x = MAX (0, x); info->p->y = MAX (0, y); if (gimp_session_info_get_remember_size (info)) { int width; int height; if (cevent) { width = cevent->width; height = cevent->height; } else { GtkAllocation allocation; gtk_widget_get_allocation (info->p->widget, &allocation); width = allocation.width; height = allocation.height; } info->p->width = width; info->p->height = height; } else { info->p->width = 0; info->p->height = 0; } } info->p->open = FALSE; if (gimp_session_info_get_remember_if_open (info)) { GimpDialogVisibilityState visibility; visibility = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget), GIMP_DIALOG_VISIBILITY_KEY)); switch (visibility) { case GIMP_DIALOG_VISIBILITY_UNKNOWN: info->p->open = gtk_widget_get_visible (info->p->widget); break; case GIMP_DIALOG_VISIBILITY_INVISIBLE: info->p->open = FALSE; break; case GIMP_DIALOG_VISIBILITY_HIDDEN: case GIMP_DIALOG_VISIBILITY_VISIBLE: /* Even if a dialog is hidden (with Windows->Hide docks) it * is still considered open. It will be restored the next * time GIMP starts */ info->p->open = TRUE; break; } } info->p->screen = DEFAULT_SCREEN; if (info->p->open) { GdkDisplay *display = gtk_widget_get_display (info->p->widget); GdkScreen *screen = gtk_widget_get_screen (info->p->widget); if (screen != gdk_display_get_default_screen (display)) info->p->screen = gdk_screen_get_number (screen); } }
char *iupdrvGetGlobal(const char *name) { if (iupStrEqual(name, "VIRTUALSCREEN")) { GdkScreen *screen = gdk_screen_get_default(); GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default()); int x = 0; int y = 0; int w = gdk_screen_get_width(screen); int h = gdk_screen_get_height(screen); gdk_window_get_root_origin(root, &x, &y); return iupStrReturnStrf("%d %d %d %d", x, y, w, h); } if (iupStrEqual(name, "MONITORSINFO")) { int i; #if GTK_CHECK_VERSION(3, 22, 0) GdkDisplay *display = gdk_display_get_default(); int monitors_count = gdk_display_get_n_monitors(display); #else GdkScreen *screen = gdk_screen_get_default(); int monitors_count = gdk_screen_get_n_monitors(screen); #endif char *str = iupStrGetMemory(monitors_count * 50); char* pstr = str; GdkRectangle rect; for (i = 0; i < monitors_count; i++) { #if GTK_CHECK_VERSION(3, 22, 0) GdkMonitor* monitor = gdk_display_get_monitor(display, i); gdk_monitor_get_geometry(monitor, &rect); #else gdk_screen_get_monitor_geometry(screen, i, &rect); #endif pstr += sprintf(pstr, "%d %d %d %d\n", rect.x, rect.y, rect.width, rect.height); } return str; } if (iupStrEqual(name, "MONITORSCOUNT")) { #if GTK_CHECK_VERSION(3, 22, 0) GdkDisplay *display = gdk_display_get_default(); int monitors_count = gdk_display_get_n_monitors(display); #else GdkScreen *screen = gdk_screen_get_default(); int monitors_count = gdk_screen_get_n_monitors(screen); #endif return iupStrReturnInt(monitors_count); } if (iupStrEqual(name, "TRUECOLORCANVAS")) { return iupStrReturnBoolean(gdk_visual_get_best_depth() > 8); } if (iupStrEqual(name, "UTF8MODE")) { return iupStrReturnBoolean(iupgtkStrGetUTF8Mode()); } if (iupStrEqual(name, "UTF8AUTOCONVERT")) { return iupStrReturnBoolean(!iupgtkStrGetUTF8Mode()); } #ifndef WIN32 if (iupStrEqual(name, "EXEFILENAME")) { char* argv0 = IupGetGlobal("ARGV0"); if (argv0) { char* exefilename = realpath(argv0, NULL); if (exefilename) { char* str = iupStrReturnStr(exefilename); free(exefilename); return str; } } } #endif if (iupStrEqual(name, "SHOWMENUIMAGES")) { gboolean menu_images; g_object_get (gtk_settings_get_default (), "gtk-menu-images", &menu_images, NULL); return iupStrReturnBoolean(menu_images); } return NULL; }
void save_config(GtkWidget *widget) { gchar *filename; ConfigFile *cfgfile; gint x; gint y; filename = g_strconcat(g_get_home_dir(), "/.eXtace/config", NULL); cfgfile = cfg_open_file(filename); if (!cfgfile) cfgfile = cfg_new(); cfg_write_int(cfgfile, "Global", "major_ver", _MAJOR_); cfg_write_int(cfgfile, "Global", "minor_ver", _MINOR_); cfg_write_int(cfgfile, "Global", "micro_ver", _MICRO_); if (Color_map.filename) cfg_write_string(cfgfile, "Global", "last_colormap", Color_map.filename); else cfg_write_string(cfgfile, "Global", "last_colormap",g_strconcat(g_get_home_dir(),"/.eXtace/ColorMaps/","Default",NULL)); cfg_write_int(cfgfile, "Global", "mode", mode); cfg_write_int(cfgfile, "Global", "data_source", data_source); cfg_write_int(cfgfile, "Global", "decimation_factor", decimation_factor); cfg_write_int(cfgfile, "Global", "fft_signal_source", fft_signal_source); cfg_write_float(cfgfile, "Global", "scope_zoom", scope_zoom); cfg_write_int(cfgfile, "Global", "refresh_rate", refresh_rate); cfg_write_int(cfgfile, "Global", "landflip", landflip); cfg_write_int(cfgfile, "Global", "spikeflip", spikeflip); cfg_write_boolean(cfgfile, "Global", "outlined", outlined); cfg_write_int(cfgfile, "Global", "sub_mode_3D", sub_mode_3D); cfg_write_int(cfgfile, "Global", "scope_sub_mode", scope_sub_mode); cfg_write_boolean(cfgfile, "Global", "dir_win_present", dir_win_present); cfg_write_int(cfgfile, "Global", "nsamp", nsamp); cfg_write_int(cfgfile, "Global", "window_func", window_func); cfg_write_int(cfgfile, "Global", "win_width", win_width); cfg_write_int(cfgfile, "Global", "axis_type", axis_type); cfg_write_int(cfgfile, "Global", "bands", bands); cfg_write_int(cfgfile, "Global", "lag", lag); cfg_write_float(cfgfile, "Global", "noise_floor", noise_floor); cfg_write_int(cfgfile, "Global", "seg_height", seg_height); cfg_write_int(cfgfile, "Global", "seg_space", seg_space); cfg_write_boolean(cfgfile, "Global", "bar_decay", bar_decay); cfg_write_boolean(cfgfile, "Global", "peak_decay", peak_decay); cfg_write_boolean(cfgfile, "Global", "stabilized", stabilized); cfg_write_boolean(cfgfile, "Global", "show_graticule", show_graticule); cfg_write_int(cfgfile, "Global", "decay_speed", bar_decay_speed); cfg_write_int(cfgfile, "Global", "peak_decay_speed", peak_decay_speed); cfg_write_int(cfgfile, "Global", "peak_hold_time", peak_hold_time); cfg_write_int(cfgfile, "Global", "tape_scroll", tape_scroll); cfg_write_int(cfgfile, "Global", "xdet_scroll", xdet_scroll); cfg_write_int(cfgfile, "Global", "zdet_scroll", zdet_scroll); cfg_write_float(cfgfile, "Global", "xdet_start", xdet_start); cfg_write_float(cfgfile, "Global", "xdet_end", xdet_end); cfg_write_float(cfgfile, "Global", "ydet_start", ydet_start); cfg_write_float(cfgfile, "Global", "ydet_end", ydet_end); cfg_write_float(cfgfile, "Global", "x3d_start", x3d_start); cfg_write_float(cfgfile, "Global", "x3d_end", x3d_end); cfg_write_float(cfgfile, "Global", "y3d_start", y3d_start); cfg_write_float(cfgfile, "Global", "y3d_end", y3d_end); cfg_write_float(cfgfile, "Global", "multiplier", multiplier); cfg_write_int(cfgfile, "Global", "horiz_spec_start", horiz_spec_start); cfg_write_int(cfgfile, "Global", "vert_spec_start", vert_spec_start); cfg_write_int(cfgfile, "Global", "x3d_scroll", x3d_scroll); cfg_write_int(cfgfile, "Global", "z3d_scroll", z3d_scroll); cfg_write_boolean(cfgfile, "Global", "show_leader", show_leader); cfg_write_int(cfgfile, "Global", "scope_sync_source", scope_sync_source); cfg_write_boolean(cfgfile, "Global", "landtilt",landtilt); cfg_write_boolean(cfgfile, "Global", "spiketilt", spiketilt); cfg_write_float(cfgfile, "Global", "low_freq", low_freq); cfg_write_float(cfgfile, "Global", "high_freq", high_freq); cfg_write_int(cfgfile, "Window", "width", width); cfg_write_int(cfgfile, "Window", "height", height+22); gdk_window_get_root_origin(widget->window, &x, &y); cfg_write_int(cfgfile, "Window", "main_x_origin", x); cfg_write_int(cfgfile, "Window", "main_y_origin", y); // cfg_write_boolean(cfgfile, "Window", "grad_win_present", grad_win_present); if (grad_win_present) { gdk_window_get_root_origin((gpointer) grad_win_ptr->window, &x, &y); cfg_write_int(cfgfile, "Window", "grad_x_origin", x); cfg_write_int(cfgfile, "Window", "grad_y_origin", y); } if (dir_win_present) { gdk_window_get_root_origin((gpointer) dir_win_ptr->window, &x, &y); cfg_write_int(cfgfile, "Window", "dir_x_origin", x); cfg_write_int(cfgfile, "Window", "dir_y_origin", y); } cfg_write_file(cfgfile, filename); cfg_free(cfgfile); g_free(filename); }
/* * Import record display and choice. * Put up the record for viewing and ask if it should be imported. */ int import_record_ask(GtkWidget *main_window, GtkWidget *pane, char *text, struct CategoryAppInfo *cai, char *old_cat_name, int priv, int suggested_cat_num, int *new_cat_num) { GtkWidget *button; GtkWidget *vbox; GtkWidget *temp_hbox; GtkWidget *textw; GObject *textw_buffer; GtkWidget *label; GtkWidget *scrolled_window; int pw, ph; gint px, py; char str[100]; char *l; long char_set; /* There is no support yet for changing the suggested category */ /* A menu for selecting cat to be imported into is desirable */ *new_cat_num = suggested_cat_num; glob_import_record_ask_button_pressed = DIALOG_SAID_IMPORT_QUIT; gdk_window_get_size(main_window->window, &pw, &ph); gdk_window_get_root_origin(main_window->window, &px, &py); pw = gtk_paned_get_position(GTK_PANED(pane)); px+=40; import_record_ask_window = gtk_widget_new(GTK_TYPE_WINDOW, "type", GTK_WINDOW_TOPLEVEL, "title", _("Import"), NULL); gtk_window_set_default_size(GTK_WINDOW(import_record_ask_window), pw, ph); gtk_widget_set_uposition(GTK_WIDGET(import_record_ask_window), px, py); gtk_container_set_border_width(GTK_CONTAINER(import_record_ask_window), 5); gtk_window_set_modal(GTK_WINDOW(import_record_ask_window), TRUE); gtk_window_set_transient_for(GTK_WINDOW(import_record_ask_window), GTK_WINDOW(main_window)); gtk_signal_connect(GTK_OBJECT(import_record_ask_window), "destroy", GTK_SIGNAL_FUNC(cb_import_record_ask_destroy), import_record_ask_window); vbox=gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(import_record_ask_window), vbox); /* Private */ if (priv) { g_snprintf(str, sizeof(str), _("Record was marked as private")); } else { g_snprintf(str, sizeof(str), _("Record was not marked as private")); } label = gtk_label_new(str); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); /* Category */ get_pref(PREF_CHAR_SET, &char_set, NULL); l = charset_p2newj(old_cat_name, 16, char_set); g_snprintf(str, sizeof(str), _("Category before import was: [%s]"), l); g_free(l); label = gtk_label_new(str); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); l = charset_p2newj(cai->name[suggested_cat_num], 16, char_set); g_snprintf(str, sizeof(str), _("Record will be put in category [%s]"), l); g_free(l); label = gtk_label_new(str); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); /* Text window with scrollbar to display record */ temp_hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), temp_hbox, TRUE, TRUE, 0); textw = gtk_text_view_new(); textw_buffer = G_OBJECT(gtk_text_view_get_buffer(GTK_TEXT_VIEW(textw))); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textw), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(textw), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textw), GTK_WRAP_WORD); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_set_border_width(GTK_CONTAINER(scrolled_window), 1); gtk_container_add(GTK_CONTAINER(scrolled_window), textw); gtk_box_pack_start_defaults(GTK_BOX(temp_hbox), scrolled_window); if (text) { gtk_text_buffer_set_text(GTK_TEXT_BUFFER(textw_buffer), text, -1); } temp_hbox = gtk_hbutton_box_new(); gtk_button_box_set_spacing(GTK_BUTTON_BOX(temp_hbox), 6); gtk_container_set_border_width(GTK_CONTAINER(temp_hbox), 6); gtk_box_pack_start(GTK_BOX(vbox), temp_hbox, FALSE, FALSE, 0); /* Import button */ button = gtk_button_new_with_label(_("Import")); gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_import_record_ask_quit), GINT_TO_POINTER(DIALOG_SAID_IMPORT_YES)); /* Import All button */ button = gtk_button_new_with_label(_("Import All")); gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_import_record_ask_quit), GINT_TO_POINTER(DIALOG_SAID_IMPORT_ALL)); /* Skip button */ button = gtk_button_new_with_label(_("Skip")); gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_import_record_ask_quit), GINT_TO_POINTER(DIALOG_SAID_IMPORT_SKIP)); /* Quit button */ button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(temp_hbox), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_import_record_ask_quit), GINT_TO_POINTER(DIALOG_SAID_IMPORT_QUIT)); gtk_widget_show_all(import_record_ask_window); gtk_main(); return glob_import_record_ask_button_pressed; }
void import_gui(GtkWidget *main_window, GtkWidget *main_pane, char *type_desc[], int type_int[], int (*import_callback)(GtkWidget *parent_window, const char *file_path, int type)) { GtkWidget *button; GtkWidget *vbox, *hbox; GtkWidget *label; char title[256]; const char *svalue; GSList *group; int i; int pw, ph, px, py; if (filew) return; line_selected = -1; gdk_window_get_size(main_window->window, &pw, &ph); gdk_window_get_root_origin(main_window->window, &px, &py); pw = gtk_paned_get_position(GTK_PANED(main_pane)); px+=40; g_snprintf(title, sizeof(title), "%s %s", PN, _("Import")); filew = gtk_widget_new(GTK_TYPE_FILE_SELECTION, "type", GTK_WINDOW_TOPLEVEL, "title", title, NULL); gtk_window_set_default_size(GTK_WINDOW(filew), pw, ph); gtk_widget_set_uposition(filew, px, py); gtk_window_set_modal(GTK_WINDOW(filew), TRUE); gtk_window_set_transient_for(GTK_WINDOW(filew), GTK_WINDOW(main_window)); get_pref(PREF_MEMO_IMPORT_PATH, NULL, &svalue); if (svalue && svalue[0]) { gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew), svalue); } glob_import_callback=import_callback; /* Set the type to match the first button, which will be set */ glob_type_selected=type_int[0]; gtk_widget_hide((GTK_FILE_SELECTION(filew)->cancel_button)); gtk_signal_connect(GTK_OBJECT(filew), "destroy", GTK_SIGNAL_FUNC(cb_destroy), filew); /* Even though I hide the ok button I still want to connect its signal */ /* because a double click on the file name also calls this callback */ gtk_widget_hide(GTK_WIDGET(GTK_FILE_SELECTION(filew)->ok_button)); gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->ok_button), "clicked", GTK_SIGNAL_FUNC(cb_import), filew); label = gtk_label_new(_("To change to a hidden directory type it below and hit TAB")); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->main_vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); /* Quit/Import buttons */ button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_quit), filew); gtk_widget_show(button); button = gtk_button_new_with_label(_("Import")); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->ok_button->parent), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(cb_import), filew); gtk_widget_show(button); /* File Type radio buttons */ vbox=gtk_vbox_new(FALSE, 0); hbox=gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), vbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); label = gtk_label_new(_("Import File Type")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); group = NULL; for (i=0; i<MAX_IMPORT_TYPES; i++) { if (type_desc[i]==NULL) break; radio_types[i] = gtk_radio_button_new_with_label(group, _(type_desc[i])); radio_file_types[i] = type_int[i]; group = gtk_radio_button_group(GTK_RADIO_BUTTON(radio_types[i])); gtk_box_pack_start(GTK_BOX(vbox), radio_types[i], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(radio_types[i]), "clicked", GTK_SIGNAL_FUNC(cb_type), GINT_TO_POINTER(type_int[i])); } radio_types[i]=NULL; radio_file_types[i]=0; /* This callback is for a file guess algorithm and to pre-push * the type buttons */ gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filew)->file_list), "cursor_changed", GTK_SIGNAL_FUNC(cb_import_select_row), NULL); gtk_widget_show_all(vbox); gtk_widget_show(filew); }
gboolean xmms_fullscreen_enter(GtkWidget * win, gint * w, gint * h) { gint i, close, how_close = -1, t, dummy; gboolean retval = FALSE; fullscreen_window_t *fwin; FULL_LOCK(); fwin = getwindow(win); if (!fwin->display->is_full && !fwin->is_full && fwin->display->can_full) { for (close = 0; close < fwin->display->num_modes; close++) { if ((fwin->display->modes[close]->hdisplay >= *w) && (fwin->display->modes[close]->vdisplay >= *h)) { how_close = fwin->display->modes[close]->hdisplay - *w; break; } } for (i = close + 1; i < fwin->display->num_modes; i++) { if (fwin->display->modes[i]->vdisplay < *h) continue; t = fwin->display->modes[i]->hdisplay - *w; if (t >= 0 && t < how_close) { close = i; how_close = t; } } if (close < fwin->display->num_modes) { *w = fwin->display->modes[close]->hdisplay; *h = fwin->display->modes[close]->vdisplay; /* Save the old position/size */ gdk_window_get_root_origin(fwin->window->window, &fwin->ox, &fwin->oy); gdk_window_get_size(fwin->window->window, &fwin->owidth, &fwin->oheight); /* Move it. */ gdk_window_move_resize(fwin->window->window, 0, 0, fwin->display->modes[close]->hdisplay, fwin->display->modes[close]->vdisplay); /* Tell the WM not to mess with this window (no more decor) */ gdk_window_hide(fwin->window->window); gdk_window_set_override_redirect(fwin->window->window, TRUE); gdk_window_show(fwin->window->window); /* * XXX: HACK * Something is ungrabbing the pointer shortly * after the above unmap/override_redirect=TRUE/map * is done. I don't know what at this time, only * that it's not XMMS, and that it's very very evil. */ gdk_flush(); xmms_usleep(50000); /* Steal the keyboard/mouse */ /* XXX: FIXME, use timeouts.. */ for (t = 0; t < 10; t++) { dummy = gdk_pointer_grab(fwin->window->window, TRUE, 0, fwin->window->window, NULL, GDK_CURRENT_TIME); if (dummy == GrabSuccess) break; gtk_main_iteration_do(FALSE); xmms_usleep(10000); } gdk_keyboard_grab(fwin->window->window, TRUE, GDK_CURRENT_TIME); /* Do the video mode switch.. */ XF86VidModeSwitchToMode(fwin->display->display, DefaultScreen(fwin->display->display), fwin->display->modes[close]); XF86VidModeSetViewPort(fwin->display->display, DefaultScreen(fwin->display->display), 0, 0); retval = TRUE; fwin->is_full = TRUE; fwin->display->is_full = TRUE; } } FULL_UNLOCK(); return retval; }
gint delete_event (GtkWidget *widget, GdkEvent *event, GtkWidget *parent) { static GtkWidget *dialog_window = NULL; GtkWidget *label; GtkWidget *button; gint x, y; if (dialog_window == NULL) { gint flag = TRUE; dialog_window = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (dialog_window), "delete_event", GTK_SIGNAL_FUNC (gtk_false), NULL); gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (dialog_window), "Exit Hello World"); gtk_container_set_border_width ( GTK_CONTAINER (dialog_window), 0); gtk_widget_set_usize (dialog_window, 250, 110); label = gtk_label_new ("真的要退出程序?"); gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog_window)->vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); button = gtk_button_new_with_label ("确认"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (dialog_yes), &flag); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog_window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label ("取消"); gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (dialog_no), &flag); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (dialog_window)); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); //设置窗口锁定状态 gtk_window_set_modal (GTK_WINDOW(dialog_window), TRUE); //设置为临时窗口状态 gtk_window_set_transient_for(GTK_WINDOW (dialog_window), GTK_WINDOW (parent)); //取得根窗口的位置 gdk_window_get_root_origin (parent->window, &x, &y); //设置对话框窗口的位置 gtk_widget_set_uposition (dialog_window, x+40, y+40); gtk_widget_show (dialog_window); gtk_main (); dialog_window = NULL; return flag; } return TRUE; }