int main (int argc, char **argv) { gtk_init_check(&argc, &argv); GMainLoop *loop; loop = g_main_loop_new(NULL, TRUE); GtkListStore *store_library = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT, G_TYPE_FLOAT); GSocketListener *listener; GSocketListener *listener_next_song; GSocketListener *listener_quit; gsize i; listener = g_socket_listener_new(); listener_next_song = g_socket_listener_new(); listener_quit = g_socket_listener_new(); g_socket_listener_add_inet_port(listener_next_song, 12512, NULL, NULL); g_socket_listener_add_inet_port(listener, 1292, NULL, NULL); g_socket_listener_add_inet_port(listener_quit, 11912, NULL, NULL); g_socket_listener_accept_async(listener, NULL, lllp_connected_cb, store_library); g_socket_listener_accept_async(listener_next_song, NULL, lllp_next_song_cb, store_library); g_socket_listener_accept_async(listener_quit, NULL, lllp_quit_cb, store_library); // g_timeout_add(4000, test, lllp_array); gtk_main(); return 0; }
/* * prepare GTK, create the menu/messages window, enter the first loop */ static void gtkui_init(void) { DEBUG_MSG("gtk_init"); // g_thread_init has been deprecated since version 2.32 and should not be used in newly-written code. This function is no longer necessary. The GLib threading system is automatically initialized at the start of your program. #if !(GLIB_CHECK_VERSION(2,32,0)) g_thread_init(NULL); #endif if(!gtk_init_check(0, NULL)) { FATAL_ERROR("GTK+ failed to initialize. Is X running?"); return; } gtkui_conf_read(); gtkui_setup(); /* initialize timer */ progress_timer = g_timer_new(); /* gui init loop, calling gtk_main_quit will cause * this to exit so we can proceed to the main loop * later. */ gtk_main(); /* remove the keyboard shortcuts for the setup menus */ gtk_window_remove_accel_group(GTK_WINDOW (window), accel_group); GBL_UI->initialized = 1; }
static BOOL do_ask_dialog(void) { #if LL_GTK gtk_disable_setlocale(); if (!gtk_init_check(NULL, NULL)) { llinfos << "Could not initialize GTK for 'ask to send crash report' dialog; not sending report." << llendl; return FALSE; } GtkWidget *win = NULL; GtkDialogFlags flags = GTK_DIALOG_MODAL; GtkMessageType messagetype = GTK_MESSAGE_QUESTION; GtkButtonsType buttons = GTK_BUTTONS_YES_NO; gint response = GTK_RESPONSE_NONE; win = gtk_message_dialog_new(NULL, flags, messagetype, buttons, "%s", dialog_text); gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title(GTK_WINDOW(win), dialog_title); g_signal_connect (win, "response", G_CALLBACK (response_callback), &response); gtk_widget_show_all (win); gtk_main(); return (GTK_RESPONSE_OK == response || GTK_RESPONSE_YES == response || GTK_RESPONSE_APPLY == response); #else return FALSE; #endif // LL_GTK }
struct OsecpuWindow* window_create(int width, int height) { struct OsecpuWindow* window; cairo_t* cr; if (!gtk_init_check(NULL, NULL)) { gtk_init(NULL, NULL); } window = (struct OsecpuWindow*)malloc(sizeof(struct OsecpuWindow)); if (!window) return NULL; memset(window, 0, sizeof(struct OsecpuWindow)); window->initial_width = width; window->initial_height = height; pthread_create(&window->thread, NULL, create_window_thread, window); // Initialize a surface window->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); cr = cairo_create(window->surface); cairo_set_source_rgb(cr, 255, 255, 255); cairo_rectangle(cr, 0, 0, width, height); cairo_fill(cr); cairo_destroy(cr); // Initialize a mutex for a surface pthread_mutex_init(&window->surface_mutex, NULL); // Wait for creating a winodw and queue while (!window->window); while (!window->queue); return window; }
int iupdrvOpen(int *argc, char ***argv) { char* value; if (!gtk_init_check(argc, argv)) return IUP_ERROR; #if defined(IUPGTK_DEBUG) g_log_set_default_handler(iupgtk_log, NULL); #endif IupSetGlobal("DRIVER", "GTK"); IupStoreGlobal("SYSTEMLANGUAGE", pango_language_to_string(gtk_get_default_language())); /* driver system version */ IupSetfAttribute(NULL, "GTKVERSION", "%d.%d.%d", gtk_major_version, gtk_minor_version, gtk_micro_version); IupSetfAttribute(NULL, "GTKDEVVERSION", "%d.%d.%d", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); gtkSetGlobalAttrib(); gtkSetGlobalColors(); IupSetGlobal("SHOWMENUIMAGES", "YES"); value = getenv("UBUNTU_MENUPROXY"); /* for now only in Ubuntu */ if (value && (iupStrEqualNoCase(value, "libappmenu.so") || iupStrEqualNoCase(value, "1"))) IupSetGlobal("GLOBALMENU", "Yes"); return IUP_NOERROR; }
/* * prepare GTK, create the menu/messages window, enter the first loop */ static void gtkui_init(void) { DEBUG_MSG("gtk_init"); g_thread_init(NULL); if(!gtk_init_check(0, NULL)) { FATAL_ERROR("GTK+ failed to initialize. Is X running?"); return; } gtkui_conf_read(); gtkui_setup(); /* gui init loop, calling gtk_main_quit will cause * this to exit so we can proceed to the main loop * later. */ gtk_main(); /* remove the keyboard shortcuts for the setup menus */ gtk_window_remove_accel_group(GTK_WINDOW (window), accel_group); GBL_UI->initialized = 1; }
Bool prima_gtk_init(void) { int argc = 0; gboolean r; switch ( gtk_initialized) { case -1: return false; case 1: return true; } r = gtk_init_check( &argc, NULL); if ( r == gtk_true()) { XSetErrorHandler( guts. main_error_handler); gtk_initialized = 1; return true; } else { gtk_initialized = -1; warn("** Cannot initialize GTK"); return false; } }
int main(int argc, char * argv[]) { char buf[1024]; char * args; int len; gtk_init_check(&argc,&argv); setlocale(LC_NUMERIC,"C"); while (fgets(buf,sizeof(buf),stdin)) { len=strlen(buf); if (len>0 && buf[len-1]=='\n') buf[--len]=0; args=strchr(buf,' '); if (args) *args++=0; else args=buf+len; if (strcmp(buf,"open")==0) emPdfOpen(args); else if (strcmp(buf,"close")==0) emPdfClose(args); else if (strcmp(buf,"render")==0) emPdfRender(args); else { fprintf(stderr,"emPdfServerProc: illegal command.\n"); exit(1); } fflush(stdout); } return 0; }
void loadEveBrowser() { int argc = 0; printf("%s:%d\n", __func__, __LINE__); gtk_init_check(&argc, NULL); if (!g_thread_supported ()) g_thread_init (NULL); printf("%s:%d\n", __func__, __LINE__); GtkWidget* fixed = gtk_fixed_new(); g_vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (g_vbox), create_toolbar (), FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (g_vbox), GTK_WIDGET (create_browser ()), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (g_vbox), create_statusbar (), FALSE, FALSE, 0); g_window = create_window (); gtk_fixed_put(GTK_FIXED(fixed), g_vbox, 0, 0); gtk_widget_set_size_request(g_vbox, g_framebuffer_width, g_framebuffer_height); GtkWidget* statusLabel = gtk_label_new ("Status"); gtk_fixed_put(GTK_FIXED(fixed), statusLabel, g_framebuffer_width - 200, 0); gtk_widget_set_size_request(statusLabel, 200, 100); gtk_container_add (GTK_CONTAINER (g_window), fixed); }
int main (int argc, char **argv) { GtkClipboard *clipboard; if (!gtk_init_check (&argc, &argv)) { g_print ("X was not found. Cannot paste.\n"); return 255; } if (argc!=2) { g_print ("Please give a single argument, which " "will be copied to the clipboard.\n"); return 1; } clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD); if (!clipboard) { g_print ("Clipboard could not be found. Cannot paste.\n"); return 255; } gtk_clipboard_set_text (clipboard, argv[1], -1); gtk_clipboard_store (clipboard); return 0; }
int iupdrvOpen(int *argc, char ***argv) { GtkStyle* style; if (!gtk_init_check(argc, argv)) return IUP_ERROR; IupSetGlobal("DRIVER", "GTK"); IupStoreGlobal("SYSTEMLANGUAGE", pango_language_to_string(gtk_get_default_language())); /* driver system version */ IupSetfAttribute(NULL, "GTKVERSION", "%d.%d.%d", gtk_major_version, gtk_minor_version, gtk_micro_version); IupSetfAttribute(NULL, "GTKDEVVERSION", "%d.%d.%d", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); gtkSetDrvGlobalAttrib(); style = gtk_style_new(); iupgtkUpdateGlobalColors(style); IupSetGlobal("_IUP_RESET_GLOBALCOLORS", "YES"); /* will update the global colors when the first dialog is mapped */ g_object_unref(style); return IUP_NOERROR; }
int main (int argc, char **argv) { GList *toplevels; GList *node; /* If there's no DISPLAY, we silently error out. We don't want to break * headless builds. */ if (! gtk_init_check (&argc, &argv)) return 0; toplevels = get_all_widgets (); for (node = toplevels; node; node = g_list_next (node)) { WidgetInfo *info; char *filename; cairo_surface_t *surface; info = node->data; gtk_widget_show (info->window); surface = snapshot_widget (info->window, info->include_decorations ? SNAPSHOT_WINDOW : SNAPSHOT_DRAW); filename = g_strdup_printf ("./%s.png", info->name); g_assert (cairo_surface_write_to_png (surface, filename) == CAIRO_STATUS_SUCCESS); g_free (filename); cairo_surface_destroy (surface); } return 0; }
static gboolean list_modes (const char *option_name, const char *value, gpointer data, GError **error) { ShellGlobal *global; GjsContext *context; const char *script; int status; /* Many of our imports require global to be set, so rather than * tayloring our imports carefully here to avoid that dependency, * we just set it. * ShellGlobal has some GTK+ dependencies, so initialize GTK+; we * don't really care if it fails though (e.g. when running from a tty), * so we mute all warnings */ g_log_set_default_handler (shut_up, NULL); gtk_init_check (NULL, NULL); _shell_global_init (NULL); global = shell_global_get (); context = _shell_global_get_gjs_context (global); shell_introspection_init (); script = "imports.ui.environment.init();" "imports.ui.sessionMode.listModes();"; if (!gjs_context_eval (context, script, -1, "<main>", &status, NULL)) g_message ("Retrieving list of available modes failed."); exit (status); }
void System::Init(int requested_log_level) { if(requested_log_level == -1) { #ifdef BUILD_VERBOSE log_level = 3; #else log_level = 2; #endif } else log_level = requested_log_level; LOGINFO << "CN24 version " STRING_SHA1; LOGINFO << "Copyright (C) 2015 Clemens-Alexander Brust"; LOGINFO << "For licensing information, see the LICENSE" << " file included with this project."; std::string binary_path; GetExecutablePath(binary_path); LOGDEBUG << "Executable path: " << binary_path; unsigned int platform_number = 0; unsigned int device_number = 0; // Look for configuration file std::string config_path = binary_path + "config"; if(!std::ifstream(config_path, std::ios::in).good()) { config_path = binary_path + "../config"; } // Load and parse config file std::ifstream config_file(config_path, std::ios::in); if(config_file.good()) { LOGINFO << "Loading config file: " << config_path; while (!config_file.eof()) { std::string line; std::getline (config_file, line); ParseUIntIfPossible(line, "opencl_platform", platform_number); ParseUIntIfPossible(line, "opencl_device", device_number); } } else { #ifdef BUILD_OPENCL LOGINFO << "Could not find a config file, using default OpenCL settings."; #endif } CLHelper::Init(platform_number, device_number); #ifdef BUILD_GUI if(!gtk_init_check ( nullptr, nullptr )) { LOGWARN << "Could not initialize GTK!"; } #endif // Initialize global TensorViewer viewer = new TensorViewer(); // Initialize global StatAggregator stat_aggregator = new StatAggregator(); }
int InitProgressUI(int *pargc, char ***pargv) { sProgramPath = (*pargv)[0]; sEnableUI = gtk_init_check(pargc, pargv); return 0; }
void meta_ui_init (int *argc, char ***argv) { if (!gtk_init_check (argc, argv)) meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL)); meta_stock_icons_init (); }
bool ll_try_gtk_init(void) { static BOOL done_gtk_diag = FALSE; static BOOL gtk_is_good = FALSE; static BOOL done_setlocale = FALSE; static BOOL tried_gtk_init = FALSE; if (!done_setlocale) { PLS_INFOS << "Starting GTK Initialization." << PLS_ENDL; //maybe_lock_display(); gtk_disable_setlocale(); //maybe_unlock_display(); done_setlocale = TRUE; } if (!tried_gtk_init) { tried_gtk_init = TRUE; #if !GLIB_CHECK_VERSION(2, 32, 0) if (!g_thread_supported ()) g_thread_init (NULL); #endif //maybe_lock_display(); gtk_is_good = gtk_init_check(NULL, NULL); //maybe_unlock_display(); if (!gtk_is_good) PLS_WARNS << "GTK Initialization failed." << PLS_ENDL; } if (gtk_is_good && !done_gtk_diag) { PLS_INFOS << "GTK Initialized." << PLS_ENDL; PLS_INFOS << "- Compiled against GTK version " << GTK_MAJOR_VERSION << "." << GTK_MINOR_VERSION << "." << GTK_MICRO_VERSION << PLS_ENDL; PLS_INFOS << "- Running against GTK version " << gtk_major_version << "." << gtk_minor_version << "." << gtk_micro_version << PLS_ENDL; //maybe_lock_display(); const gchar* gtk_warning = gtk_check_version( GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION); //maybe_unlock_display(); if (gtk_warning) { PLS_WARNS << "- GTK COMPATIBILITY WARNING: " << gtk_warning << PLS_ENDL; gtk_is_good = FALSE; } else { PLS_INFOS << "- GTK version is good." << PLS_ENDL; } done_gtk_diag = TRUE; } return gtk_is_good; }
void StartFrontend(int argc, char **argv) { if (gtk_init_check(&argc, &argv) == FALSE) throw Exceptions::CExFrontend("Failed to initialize GTK"); pInterface = new CInstaller(); pInterface->Init(argc, argv); pInterface->Run(); }
gboolean c_gtk_init_tool_kit_check () { gboolean result; if (result = gtk_init_check (&eif_argc, &eif_argv)) { gtk_signal_set_funcs(callback_entry_func, NULL); } return (result); }
void sys_set_clipboard_text(void *user, const char *text) { GtkClipboard *cb; gtk_init_check(NULL, NULL); cb = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); gtk_clipboard_set_can_store(cb, NULL, 0); gtk_clipboard_set_text(cb, text, -1); gtk_clipboard_store(cb); }
int perf_gtk__init(void) { perf_error__register(&perf_gtk_eops); perf_gtk__init_helpline(); perf_gtk__init_progress(); perf_gtk__init_hpp(); return gtk_init_check(NULL, NULL) ? 0 : -1; }
void gtk_init_with_empty_args() { int argc = 0; char ** argv = malloc(sizeof(char*)); argv[0] = ""; if (gtk_init_check (&argc, &argv) == FALSE) { fprintf(stderr, "Failed to start GTK\n"); } }
int main (int argc, gchar* argv[]) { GtkWidget* window; GtkWidget* vbox; GtkWidget* scrolled; GtkWidget* web_view; GtkWidget* button_box; WebKitWebFrame* web_frame; JSGlobalContextRef js_context; JSObjectRef js_global; JSStringRef js_function_name; JSObjectRef js_set_can_register; if (!g_thread_supported ()) g_thread_init (NULL); gtk_init_check (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "WebKitGTK+ API Demo"); gtk_window_set_default_size (GTK_WINDOW (window), 640, 240); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_vbox_new (FALSE, 4); gtk_container_add (GTK_CONTAINER (window), vbox); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0); web_view = webkit_web_view_new (); gtk_container_add (GTK_CONTAINER (scrolled), web_view); webkit_web_view_load_string (WEBKIT_WEB_VIEW (web_view), form_markup, "text/html", "UTF-8", ""); g_signal_connect (web_view, "create-plugin-widget", G_CALLBACK (web_view_create_plugin_widget_cb), NULL); button_box = gtk_hbutton_box_new (); gtk_box_pack_start (GTK_BOX (vbox), button_box, FALSE, FALSE, 0); register_button = gtk_button_new_with_mnemonic ("Send _Registration"); gtk_widget_set_sensitive (register_button, FALSE); gtk_box_pack_start (GTK_BOX (button_box), register_button, FALSE, FALSE, 0); web_frame = webkit_web_view_get_main_frame (WEBKIT_WEB_VIEW (web_view)); js_context = webkit_web_frame_get_global_context (web_frame); js_global = JSContextGetGlobalObject (js_context); js_function_name = JSStringCreateWithUTF8CString ("setCanRegister"); js_set_can_register = JSObjectMakeFunctionWithCallback (js_context, js_function_name, (JSObjectCallAsFunctionCallback)set_can_register_cb); JSObjectSetProperty (js_context, js_global, js_function_name, js_set_can_register, 0, NULL); JSStringRelease (js_function_name); gtk_widget_show_all (window); gtk_main (); return 0; }
int xepgui_init ( void ) { if (!gtk_init_check(NULL, NULL)) { ERROR_WINDOW("Cannot initialize GTK"); return 1; } xepgui_iteration(); // consume possible peding (if any?) GTK stuffs after initialization - maybe not needed at all? return 0; }
static void set_gtk_available(status_t *stats) { #ifdef HAVE_LIBGTK char *argv[] = { "vifm", NULL }; int argc = ARRAY_LEN(argv) - 1; char **ptr = argv; stats->gtk_available = gtk_init_check(&argc, &ptr); #endif }
const char *sys_get_clipboard_text(void* user) { GtkClipboard *cb; static gchar *text = NULL; gtk_init_check(NULL, NULL); g_free(text); cb = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); text = gtk_clipboard_wait_for_text(cb); return text; }
bool dialog_open(int flags, const char *filters, char **out) { GtkWidget *dialog; GtkFileFilter *filter; GtkFileChooser *chooser; GtkFileChooserAction action; gint res; const char *extension; char default_name[128]; action = flags & DIALOG_FLAG_SAVE ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN; if (flags & DIALOG_FLAG_DIR) action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; gtk_init_check(NULL, NULL); dialog = gtk_file_chooser_dialog_new( flags & DIALOG_FLAG_SAVE ? "Save File" : "Open File", NULL, action, "_Cancel", GTK_RESPONSE_CANCEL, flags & DIALOG_FLAG_SAVE ? "_Save" : "_Open", GTK_RESPONSE_ACCEPT, NULL ); chooser = GTK_FILE_CHOOSER(dialog); gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE); if ((flags & DIALOG_FLAG_SAVE) && filters) { extension = filters + strlen(filters) + 3; sprintf(default_name, "untitled.%s", extension); gtk_file_chooser_set_current_name(chooser, default_name); } while (filters && *filters) { filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, filters); filters += strlen(filters) + 1; gtk_file_filter_add_pattern(filter, filters); gtk_file_chooser_add_filter(chooser, filter); filters += strlen(filters) + 1; } // Add a default 'any' file pattern. filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "*"); gtk_file_filter_add_pattern(filter, "*"); gtk_file_chooser_add_filter(chooser, filter); res = gtk_dialog_run(GTK_DIALOG(dialog)); if (res == GTK_RESPONSE_ACCEPT) { *out = gtk_file_chooser_get_filename(chooser); } gtk_widget_destroy(dialog); while (gtk_events_pending()) gtk_main_iteration(); return res == GTK_RESPONSE_ACCEPT; }
nfdresult_t NFD_SaveDialog( const nfdchar_t *filterList, const nfdchar_t *defaultPath, nfdchar_t **outPath ) { GtkWidget *dialog; nfdresult_t result; if ( !gtk_init_check( NULL, NULL ) ) { NFDi_SetError(INIT_FAIL_MSG); return NFD_ERROR; } dialog = gtk_file_chooser_dialog_new( "Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, "_Cancel", GTK_RESPONSE_CANCEL, "_Save", GTK_RESPONSE_ACCEPT, NULL ); gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER(dialog), TRUE ); /* Build the filter list */ AddFiltersToDialog(dialog, filterList); /* Set the default path */ SetDefaultPath(dialog, defaultPath); result = NFD_CANCEL; if ( gtk_dialog_run( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) { char *filename; filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(dialog) ); { size_t len = strlen(filename); *outPath = NFDi_Malloc( len + 1 ); memcpy( *outPath, filename, len + 1 ); if ( !*outPath ) { g_free( filename ); gtk_widget_destroy(dialog); return NFD_ERROR; } } g_free(filename); result = NFD_OKAY; } WaitForCleanup(); gtk_widget_destroy(dialog); WaitForCleanup(); return result; }
int main(int argc, char **argv) { if (!gtk_init_check(&argc, &argv)) { g_message("Could not init gtk. Skipping test"); return 77; /* magic value to ignore test */ } g_print ("Testing string to enum... "); if (glade_enum_from_string(GTK_TYPE_ANCHOR_TYPE, "GTK_ANCHOR_NORTH_WEST") != GTK_ANCHOR_NORTH_WEST) { g_print("failed\n"); return 1; } g_print("passed\n"); g_print ("Testing nickname string to enum... "); if (glade_enum_from_string(GTK_TYPE_ANCHOR_TYPE, "north-west") != GTK_ANCHOR_NORTH_WEST) { g_print("failed\n"); return 1; } g_print("passed\n"); g_print ("Testing string to enum (single component)... "); if (glade_flags_from_string(GTK_TYPE_ATTACH_OPTIONS, "GTK_EXPAND") != GTK_EXPAND) { g_print("failed\n"); return 1; } g_print("passed\n"); g_print ("Testing nicknamestring to enum (single component)... "); if (glade_flags_from_string(GTK_TYPE_ATTACH_OPTIONS, "expand") != GTK_EXPAND) { g_print("failed\n"); return 1; } g_print("passed\n"); g_print ("Testing string to flag component ordering... "); if ((glade_flags_from_string(GTK_TYPE_ATTACH_OPTIONS, "expand|fill") != (GTK_EXPAND | GTK_FILL)) || (glade_flags_from_string(GTK_TYPE_ATTACH_OPTIONS, "fill|expand") != (GTK_EXPAND | GTK_FILL))) { g_print("failed\n"); return 1; } g_print("passed\n"); g_print ("All tests passed\n"); return 0; }
void meta_ui_init (void) { if (!gtk_init_check (NULL, NULL)) meta_fatal ("Unable to open X display %s\n", XDisplayName (NULL)); /* We need to be able to fully trust that the window and monitor sizes that Gdk reports corresponds to the X ones, so we disable the automatic scale handling */ gdk_x11_display_set_window_scale (gdk_display_get_default (), 1); }