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