int iupdrvSetGlobal(const char *name, const char *value)
{
if (iupStrEqual(name, "INPUTCALLBACKS"))
{
if (iupStrBoolean(value))
gdk_event_handler_set(iGdkEventFunc, NULL, NULL);
else
gdk_event_handler_set((GdkEventFunc)gtk_main_do_event, NULL, NULL);
return 1;
}
if (iupStrEqual(name, "UTF8MODE"))
{
iupgtkStrSetUTF8Mode(iupStrBoolean(value));
return 1;
}
if (iupStrEqual(name, "UTF8AUTOCONVERT"))
{
iupgtkStrSetUTF8Mode(!iupStrBoolean(value));
return 0;
}
if (iupStrEqual(name, "SHOWMENUIMAGES"))
{
#if !GTK_CHECK_VERSION(3, 10, 0) /* deprecated since 3.10 */
/* make sure the type is realized */
g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM));
#endif
if (iupStrBoolean(value))
g_object_set (gtk_settings_get_default (), "gtk-menu-images", TRUE, NULL);
else
g_object_set (gtk_settings_get_default (), "gtk-menu-images", FALSE, NULL);
}
return 1;
}
static PyObject *
_wrap_gdk_event_handler_set(PyObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *pyfunc, *pyarg = NULL;
PyGtkCustomNotify *cunote;
if (!PyArg_ParseTuple(args, "O|O:event_handler_set",
&pyfunc, &pyarg))
return NULL;
if (pyfunc == Py_None) {
gdk_event_handler_set(NULL, NULL, NULL);
} else {
cunote = g_new0(PyGtkCustomNotify, 1);
cunote->func = pyfunc;
cunote->data = pyarg;
Py_INCREF(cunote->func);
Py_XINCREF(cunote->data);
gdk_event_handler_set(pygdk_event_handler_marshal,
cunote,
pygtk_custom_destroy_notify);
}
Py_INCREF(Py_None);
return Py_None;
}
static VALUE
gdkevent_s_handler_set(VALUE self)
{
volatile VALUE func = rb_block_proc();
G_RELATIVE(self, func);
gdk_event_handler_set((GdkEventFunc)handler_func, (gpointer)func, NULL);
return self;
}
gint
gtk_module_init (gint argc,
gchar *argv[])
{
GIOChannel *channel = NULL;
channel = g_io_channel_unix_new(0);
gdk_event_handler_set(gdkevent_dispatcher, channel,
(GDestroyNotify)g_io_channel_unref);
return 0;
}
static void
check_for_draw (GdkEvent *event, gpointer loop)
{
if (event->type == GDK_EXPOSE)
{
g_idle_add (quit_when_idle, loop);
gdk_event_handler_set ((GdkEventFunc) gtk_main_do_event, NULL, NULL);
}
gtk_main_do_event (event);
}
void
sp_kde_init (int argc, char **argv, const char *appName, const char *programName, const char *version, const char *shortDescription, const char *copyrightStatement, const char *homePageAddress, const char *bugsEmailAddress)
{
KDEAbout = new KAboutData(appName, programName, version, shortDescription, KAboutData::License_GPL, copyrightStatement, NULL, homePageAddress, bugsEmailAddress);
KCmdLineArgs::init(argc, argv, KDEAbout);
KDESodipodi = new KApplication;
Bridge = new SPKDEBridge ("KDE Bridge");
DCOPInterface = new TiEmuDCOP ();
QObject::connect (KDESodipodi, SIGNAL (guiThreadAwake ()), Bridge, SLOT (EventHook ()));
gdk_event_handler_set ((GdkEventFunc) sp_kde_gdk_event_handler, NULL, NULL);
}
CaptureEvents::CaptureEvents()
{
#if wxUSE_LOG
// disable log flushing from here because a call to wxTheApp->Yield() shouldn't
// normally result in message boxes popping up &c
wxLog::Suspend();
#endif
// temporarily replace the global GDK event handler with our function
gdk_event_handler_set((GdkEventFunc)main_do_event, &queue, NULL);
// temporarily suspend idle callbacks
wxTheApp->SuspendIdleCallback();
}
G_MODULE_EXPORT void theme_exit()
{
MT_LIBRARY *lib;
gtk_widget_destroy(comm_window);
mt_gtk2_uninstall_patches();
lib = mt_default_engine->library;
mt_default_engine->exit(mt_default_engine);
metatheme_unload_engine(mt_default_engine);
metatheme_library_exit(lib);
gdk_event_handler_set((GdkEventFunc)gtk_main_do_event, 0, NULL);
}
void
_clutter_backend_gdk_events_init (ClutterBackend *backend)
{
ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend);
CLUTTER_NOTE (EVENT, "initialising the event loop");
backend->device_manager =
g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_GDK,
"backend", backend,
"gdk-display", backend_gdk->display,
NULL);
if (!disable_event_retrieval)
gdk_event_handler_set (gdk_event_handler, NULL, NULL);
}
CaptureEvents::~CaptureEvents()
{
gdk_event_handler_set((GdkEventFunc)gtk_main_do_event, NULL, NULL);
// put all unprocessed GDK events back in the queue
GdkDisplay* disp = gtk_widget_get_display(wxGetRootWindow());
size_t cnt = queue.GetCount();
for (size_t i = 0; i < cnt; i++) {
GdkEvent* event = (GdkEvent*)queue[i];
// NOTE: gdk_display_put_event makes a copy of the event passed to it
gdk_display_put_event(disp, event);
gdk_event_free(event);
}
#if wxUSE_LOG
// let the logs be flashed again
wxLog::Resume();
#endif
}
G_MODULE_EXPORT void theme_init(GTypeModule *module)
{
/* prevent unloading of this theme: */
g_type_module_use(module);
metatheme_toolkit_init(&metatheme_toolkit);
metatheme_rc_style_register_type (module);
metatheme_style_register_type (module);
gdk_event_handler_set(_event_handler, 0, NULL);
mt_default_engine = NULL;
mt_first_engine = mt_get_engine();
/* create window for retrieving messages: */
comm_window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_default_size(GTK_WINDOW(comm_window), 0, 0);
gtk_widget_set_uposition(comm_window, 32000, 32000);
gtk_widget_show(comm_window);
}
gint
gtk_module_init (gint argc,
gchar *argv[])
{
GDBusConnection *dbus;
gchar *address;
const gchar *socket;
GError *error = NULL;
ENTRY;
if (!(socket = g_getenv("GDKEVENT_SOCKET"))) {
CRITICAL(Gdk, "Failed to load gdkevent socket.");
RETURN(-1);
}
address = g_strdup_printf("unix:path=%s", socket);
dbus = g_dbus_connection_new_for_address_sync(address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL, NULL, &error);
g_free(address);
if (!dbus) {
CRITICAL(Gdk, "Failed to load IPC socket: %s", error->message);
g_error_free(error);
RETURN(-1);
}
connection = dbus;
gdk_event_handler_set(gdkevent_dispatcher, dbus,
gdkevent_module_unloaded);
g_get_current_time(&last_time);
poll_func = g_main_context_get_poll_func(g_main_context_default());
g_main_context_set_poll_func(g_main_context_default(), gdkevent_poll);
RETURN(0);
}
/*
* Parse argc/argv for lowlevel stuff (display ...)
*/
void
MUI_Init (int *argc, char ***argv)
{
__global_MUI_Init_called = 1;
gdk_init(argc, argv);
#ifdef WITH_IMLIB
gdk_imlib_init();
#endif
zune_check_iptr();
zune_check_varargs();
gdk_event_handler_set ((GdkEventFunc)__zune_main_do_event, NULL, NULL);
__zune_clipping_init();
__zune_imspec_init();
__zune_images_init();
/*
* init prefs before loading from files - in case there's no file
*/
__zune_prefs_init(&__zprefs);
zune_signals_setup();
}
gint
gtk_module_init (gint argc,
gchar *argv[])
{
gchar *filename;
GError *error = NULL;
/* get our destination filename */
if (g_getenv ("GDKRECORD_FILENAME"))
filename = g_strdup (g_getenv ("GDKRECORD_FILENAME"));
else
filename = g_strdup_printf ("%d-%s.gdkrecord",
getpid (),
g_get_prgname ());
/* open the file for writing */
if (!(channel = g_io_channel_new_file (filename, "w", &error))) {
g_warning ("Could not initialize gdkrecord: %s",
error->message);
g_error_free (error);
g_free (filename);
return -1;
}
g_free (filename);
/* setup our timer for event timings */
timer = g_timer_new ();
/* register our event handler to record and then pass to gtk */
gdk_event_handler_set (gdkrecord_event_handler,
channel,
gdkrecord_event_destroy);
return 0;
}
gint
main (gint argc, /* IN */
gchar *argv[]) /* IN */
{
gdouble dashes[] = { 1.0, 4.0 };
UberRange cpu_range = { 0., 100., 100. };
UberRange net_range = { 0., 512., 512. };
UberRange ui_range = { 0., 10., 10. };
GtkWidget *window;
GtkWidget *cpu;
GtkWidget *net;
GtkWidget *line;
GtkWidget *map;
GtkWidget *scatter;
GtkWidget *label;
GtkAccelGroup *ag;
GdkColor color;
gint lineno;
gint nprocs;
gint i;
gint mod;
g_thread_init(NULL);
gtk_init(&argc, &argv);
nprocs = get_nprocs();
/*
* Check for blktrace hack.
*/
if (argc > 1 && (g_strcmp0(argv[1], "--i-can-haz-blktrace") == 0)) {
want_blktrace = TRUE;
}
/*
* Warm up differential samplers.
*/
smon_next_cpu_info();
smon_next_cpu_freq_info();
if (want_blktrace) {
uber_blktrace_init();
}
/*
* Install event hook to track how many X events we are doing.
*/
gdk_event_handler_set(smon_gdk_event_hook, NULL, NULL);
/*
* Create window and graphs.
*/
window = uber_window_new();
cpu = uber_line_graph_new();
net = uber_line_graph_new();
line = uber_line_graph_new();
map = uber_heat_map_new();
scatter = uber_scatter_new();
/*
* Configure CPU graph.
*/
uber_line_graph_set_autoscale(UBER_LINE_GRAPH(cpu), FALSE);
uber_graph_set_format(UBER_GRAPH(cpu), UBER_GRAPH_FORMAT_PERCENT);
uber_line_graph_set_range(UBER_LINE_GRAPH(cpu), &cpu_range);
uber_line_graph_set_data_func(UBER_LINE_GRAPH(cpu),
smon_get_cpu_info, NULL, NULL);
for (i = 0; i < nprocs; i++) {
mod = i % G_N_ELEMENTS(default_colors);
gdk_color_parse(default_colors[mod], &color);
label = uber_label_new();
uber_label_set_color(UBER_LABEL(label), &color);
uber_line_graph_add_line(UBER_LINE_GRAPH(cpu), &color,
UBER_LABEL(label));
cpu_info.labels[i] = label;
/*
* XXX: Add the line regardless. Just dont populate it if we don't
* have data.
*/
lineno = uber_line_graph_add_line(UBER_LINE_GRAPH(cpu), &color, NULL);
if (smon_cpu_has_freq_scaling(i)) {
uber_line_graph_set_line_dash(UBER_LINE_GRAPH(cpu), lineno,
dashes, G_N_ELEMENTS(dashes), 0);
uber_line_graph_set_line_alpha(UBER_LINE_GRAPH(cpu), lineno, 1.);
}
}
/*
* Add lines for GDK/X events.
*/
uber_line_graph_set_range(UBER_LINE_GRAPH(line), &ui_range);
label = uber_label_new();
uber_label_set_text(UBER_LABEL(label), "GDK Events");
gdk_color_parse("#729fcf", &color);
uber_line_graph_add_line(UBER_LINE_GRAPH(line), &color, UBER_LABEL(label));
label = uber_label_new();
uber_label_set_text(UBER_LABEL(label), "X Events");
gdk_color_parse("#a40000", &color);
uber_line_graph_add_line(UBER_LINE_GRAPH(line), &color, UBER_LABEL(label));
uber_line_graph_set_data_func(UBER_LINE_GRAPH(line),
smon_get_xevent_info, NULL, NULL);
/*
* Add lines for bytes in/out.
*/
uber_line_graph_set_range(UBER_LINE_GRAPH(net), &net_range);
uber_line_graph_set_data_func(UBER_LINE_GRAPH(net),
smon_get_net_info, NULL, NULL);
uber_graph_set_format(UBER_GRAPH(net), UBER_GRAPH_FORMAT_DIRECT1024);
label = uber_label_new();
uber_label_set_text(UBER_LABEL(label), "Bytes In");
gdk_color_parse("#a40000", &color);
uber_line_graph_add_line(UBER_LINE_GRAPH(net), &color, UBER_LABEL(label));
label = uber_label_new();
uber_label_set_text(UBER_LABEL(label), "Bytes Out");
gdk_color_parse("#4e9a06", &color);
uber_line_graph_add_line(UBER_LINE_GRAPH(net), &color, UBER_LABEL(label));
/*
* Configure heat map.
*/
uber_graph_set_show_ylines(UBER_GRAPH(map), FALSE);
gdk_color_parse(default_colors[0], &color);
uber_heat_map_set_fg_color(UBER_HEAT_MAP(map), &color);
uber_heat_map_set_data_func(UBER_HEAT_MAP(map),
(UberHeatMapFunc)dummy_scatter_func, NULL, NULL);
uber_window_add_graph(UBER_WINDOW(window), UBER_GRAPH(map), "IO Latency");
uber_graph_set_show_xlabels(UBER_GRAPH(map), FALSE);
gtk_widget_show(map);
/*
* Configure scatter.
*/
if (want_blktrace) {
uber_graph_set_show_ylines(UBER_GRAPH(scatter), FALSE);
gdk_color_parse(default_colors[3], &color);
uber_scatter_set_fg_color(UBER_SCATTER(scatter), &color);
uber_scatter_set_data_func(UBER_SCATTER(scatter),
(UberScatterFunc)uber_blktrace_get, NULL, NULL);
uber_window_add_graph(UBER_WINDOW(window), UBER_GRAPH(scatter), "IOPS By Size");
uber_graph_set_show_xlabels(UBER_GRAPH(scatter), TRUE);
gtk_widget_show(scatter);
}
/*
* Add graphs.
*/
uber_window_add_graph(UBER_WINDOW(window), UBER_GRAPH(cpu), "CPU");
uber_window_add_graph(UBER_WINDOW(window), UBER_GRAPH(net), "Network");
uber_window_add_graph(UBER_WINDOW(window), UBER_GRAPH(line), "UI Events");
/*
* Disable X tick labels by default (except last).
*/
uber_graph_set_show_xlabels(UBER_GRAPH(cpu), FALSE);
uber_graph_set_show_xlabels(UBER_GRAPH(net), FALSE);
uber_graph_set_show_xlabels(UBER_GRAPH(line), FALSE);
/*
* Show widgets.
*/
gtk_widget_show(net);
gtk_widget_show(line);
gtk_widget_show(cpu);
gtk_widget_show(window);
/*
* Show cpu labels by default.
*/
uber_window_show_labels(UBER_WINDOW(window), UBER_GRAPH(cpu));
/*
* Setup accelerators.
*/
ag = gtk_accel_group_new();
gtk_accel_group_connect(ag, GDK_KEY_w, GDK_CONTROL_MASK, GTK_ACCEL_MASK,
g_cclosure_new(gtk_main_quit, NULL, NULL));
gtk_window_add_accel_group(GTK_WINDOW(window), ag);
/*
* Attach signals.
*/
g_signal_connect(window,
"delete-event",
G_CALLBACK(gtk_main_quit),
NULL);
/*
* Start sampling thread.
*/
g_thread_create((GThreadFunc)sample_thread, NULL, FALSE, NULL);
gtk_main();
/*
* Cleanup after blktrace.
*/
if (want_blktrace) {
uber_blktrace_shutdown();
}
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
GOptionContext *ctx;
GError *error = NULL;
CinnamonSessionType session_type;
int ecode;
TpDebugSender *sender;
g_type_init ();
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
ctx = meta_get_option_context ();
g_option_context_add_main_entries (ctx, gnome_cinnamon_options, GETTEXT_PACKAGE);
if (!g_option_context_parse (ctx, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
exit (1);
}
g_option_context_free (ctx);
meta_plugin_type_register (gnome_cinnamon_plugin_get_type ());
/* Prevent meta_init() from causing gtk to load gail and at-bridge */
g_setenv ("NO_GAIL", "1", TRUE);
g_setenv ("NO_AT_BRIDGE", "1", TRUE);
meta_init ();
g_unsetenv ("NO_GAIL");
g_unsetenv ("NO_AT_BRIDGE");
/* FIXME: Add gjs API to set this stuff and don't depend on the
* environment. These propagate to child processes.
*/
g_setenv ("GJS_DEBUG_OUTPUT", "stderr", TRUE);
g_setenv ("GJS_DEBUG_TOPICS", "JS ERROR;JS LOG", TRUE);
cinnamon_dbus_init (meta_get_replace_current_wm ());
cinnamon_a11y_init ();
cinnamon_fonts_init ();
cinnamon_perf_log_init ();
cinnamon_prefs_init ();
gdk_event_handler_set (gnome_cinnamon_gdk_event_handler, NULL, NULL);
g_irepository_prepend_search_path (CINNAMON_PKGLIBDIR);
#if HAVE_BLUETOOTH
g_irepository_prepend_search_path (BLUETOOTH_DIR);
#endif
/* Disable debug spew from various libraries */
g_log_set_handler ("Gvc", G_LOG_LEVEL_DEBUG,
muted_log_handler, NULL);
g_log_set_handler ("AccountsService", G_LOG_LEVEL_DEBUG,
muted_log_handler, NULL);
g_log_set_handler ("Bluetooth", G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_MESSAGE,
muted_log_handler, NULL);
g_log_set_handler ("tp-glib/proxy", G_LOG_LEVEL_DEBUG,
muted_log_handler, NULL);
/* Turn on telepathy-glib debugging but filter it out in
* default_log_handler. This handler also exposes all the logs over D-Bus
* using TpDebugSender. */
tp_debug_set_flags ("all");
sender = tp_debug_sender_dup ();
g_log_set_default_handler (default_log_handler, sender);
/* Initialize the global object */
if (is_gdm_mode)
session_type = CINNAMON_SESSION_GDM;
else
session_type = CINNAMON_SESSION_USER;
_cinnamon_global_init ("session-type", session_type, NULL);
ecode = meta_run ();
if (g_getenv ("CINNAMON_ENABLE_CLEANUP"))
{
g_printerr ("Doing final cleanup...\n");
g_object_unref (cinnamon_global_get ());
}
g_object_unref (sender);
return ecode;
}
static cairo_surface_t *
snapshot_widget (GtkWidget *widget, SnapshotMode mode)
{
cairo_surface_t *surface;
cairo_pattern_t *bg;
GMainLoop *loop;
cairo_t *cr;
g_assert (gtk_widget_get_realized (widget));
surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
loop = g_main_loop_new (NULL, FALSE);
/* We wait until the widget is drawn for the first time.
* We can not wait for a GtkWidget::draw event, because that might not
* happen if the window is fully obscured by windowed child widgets.
* Alternatively, we could wait for an expose event on widget's window.
* Both of these are rather hairy, not sure what's best. */
gdk_event_handler_set (check_for_draw, loop, NULL);
g_main_loop_run (loop);
cr = cairo_create (surface);
switch (mode)
{
case SNAPSHOT_WINDOW:
{
GdkWindow *window = gtk_widget_get_window (widget);
if (gdk_window_get_window_type (window) == GDK_WINDOW_TOPLEVEL ||
gdk_window_get_window_type (window) == GDK_WINDOW_FOREIGN)
{
/* give the WM/server some time to sync. They need it.
* Also, do use popups instead of toplevls in your tests
* whenever you can. */
gdk_display_sync (gdk_window_get_display (window));
g_timeout_add (500, quit_when_idle, loop);
g_main_loop_run (loop);
}
gdk_cairo_set_source_window (cr, window, 0, 0);
cairo_paint (cr);
}
break;
case SNAPSHOT_DRAW:
bg = gdk_window_get_background_pattern (gtk_widget_get_window (widget));
if (bg)
{
cairo_set_source (cr, bg);
cairo_paint (cr);
}
gtk_widget_draw (widget, cr);
break;
default:
g_assert_not_reached();
break;
}
cairo_destroy (cr);
g_main_loop_unref (loop);
gtk_widget_destroy (widget);
return surface;
}
bool wxGUIEventLoop::YieldFor(long eventsToProcess)
{
#if wxUSE_THREADS
if ( !wxThread::IsMain() )
{
// can't call gtk_main_iteration() from other threads like this
return true;
}
#endif // wxUSE_THREADS
m_isInsideYield = true;
m_eventsToProcessInsideYield = eventsToProcess;
#if wxUSE_LOG
// disable log flushing from here because a call to wxYield() shouldn't
// normally result in message boxes popping up &c
wxLog::Suspend();
#endif
// temporarily replace the global GDK event handler with our function, which
// categorizes the events and using m_eventsToProcessInsideYield decides
// if an event should be processed immediately or not
// NOTE: this approach is better than using gdk_display_get_event() because
// gtk_main_iteration() does more than just calling gdk_display_get_event()
// and then call gtk_main_do_event()!
// In particular in this way we also process input from sources like
// GIOChannels (this is needed for e.g. wxGUIAppTraits::WaitForChild).
gdk_event_handler_set ((GdkEventFunc)wxgtk_main_do_event, this, NULL);
while (Pending()) // avoid false positives from our idle source
gtk_main_iteration();
gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);
if (eventsToProcess != wxEVT_CATEGORY_CLIPBOARD)
{
// It's necessary to call ProcessIdle() to update the frames sizes which
// might have been changed (it also will update other things set from
// OnUpdateUI() which is a nice (and desired) side effect). But we
// call ProcessIdle() only once since this is not meant for longish
// background jobs (controlled by wxIdleEvent::RequestMore() and the
// return value of Processidle().
ProcessIdle(); // ProcessIdle() also calls ProcessPendingEvents()
}
//else: if we are inside ~wxClipboardSync() and we call ProcessIdle() and
// the user app contains an UI update handler which calls wxClipboard::IsSupported,
// then we fall into a never-ending loop...
// put all unprocessed GDK events back in the queue
GdkDisplay* disp = gtk_widget_get_display(wxGetRootWindow());
for (size_t i=0; i<m_arrGdkEvents.GetCount(); i++)
{
GdkEvent* ev = (GdkEvent*)m_arrGdkEvents[i];
// NOTE: gdk_display_put_event makes a copy of the event passed to it
gdk_display_put_event(disp, ev);
gdk_event_free(ev);
}
m_arrGdkEvents.Clear();
#if wxUSE_LOG
// let the logs be flashed again
wxLog::Resume();
#endif
m_isInsideYield = false;
return true;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkMainThread_gtkInit (JNIEnv *env, jclass clazz)
{
int argc = 1;
char **argv;
char *homedir, *rcpath = NULL;
/* jclass gtkgenericpeer; */
jclass gtkcomponentpeer, gtkchoicepeer, gtkwindowpeer, gtkscrollbarpeer, gtklistpeer,
gtkmenuitempeer, gtktextcomponentpeer, window;
NSA_INIT (env, clazz);
/* GTK requires a program's argc and argv variables, and requires that they
be valid. */
argv = (char **) malloc (sizeof (char *) * 2);
argv[0] = "";
argv[1] = NULL;
/* until we have JDK 1.2 JNI, assume we have a VM with threads that
match what GLIB was compiled for */
#ifdef PORTABLE_NATIVE_SYNC
(*env)->GetJavaVM( env, &gdk_vm );
g_thread_init ( &g_thread_jni_functions );
printf("called gthread init\n");
#else
g_thread_init ( NULL );
#endif
/* From GDK 2.0 onwards we have to explicitly call gdk_threads_init */
gdk_threads_init();
gtk_init (&argc, &argv);
gdk_rgb_init ();
gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
gtk_widget_set_default_visual (gdk_rgb_get_visual ());
/* Make sure queued calls don't get sent to GTK/GDK while
we're shutting down. */
atexit (gdk_threads_enter);
gdk_env = env;
gdk_event_handler_set ((GdkEventFunc)awt_event_handler, NULL, NULL);
if ((homedir = getenv ("HOME")))
{
rcpath = (char *) malloc (strlen (homedir) + strlen (RC_FILE) + 2);
sprintf (rcpath, "%s/%s", homedir, RC_FILE);
}
gtk_rc_parse ((rcpath) ? rcpath : RC_FILE);
if (rcpath)
free (rcpath);
free (argv);
/* setup cached IDs for posting GTK events to Java */
/* gtkgenericpeer = (*env)->FindClass (env, */
/* "gnu/java/awt/peer/gtk/GtkGenericPeer"); */
window = (*env)->FindClass (env, "java/awt/Window");
gtkcomponentpeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkComponentPeer");
gtkchoicepeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkChoicePeer");
gtkwindowpeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkWindowPeer");
gtkscrollbarpeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkScrollbarPeer");
gtklistpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkListPeer");
gtkmenuitempeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkMenuItemPeer");
gtktextcomponentpeer = (*env)->FindClass (env,
"gnu/java/awt/peer/gtk/GtkTextComponentPeer");
/* gdkColor = (*env)->FindClass (env, */
/* "gnu/java/awt/peer/gtk/GdkColor"); */
/* gdkColorID = (*env)->GetMethodID (env, gdkColor, "<init>", "(III)V"); */
/* postActionEventID = (*env)->GetMethodID (env, gtkgenericpeer, */
/* "postActionEvent", */
/* "(Ljava/lang/String;I)V"); */
setBoundsCallbackID = (*env)->GetMethodID (env, window,
"setBoundsCallback",
"(IIII)V");
postMenuActionEventID = (*env)->GetMethodID (env, gtkmenuitempeer,
"postMenuActionEvent",
"()V");
postMouseEventID = (*env)->GetMethodID (env, gtkcomponentpeer,
"postMouseEvent", "(IJIIIIZ)V");
postConfigureEventID = (*env)->GetMethodID (env, gtkwindowpeer,
"postConfigureEvent", "(IIII)V");
postWindowEventID = (*env)->GetMethodID (env, gtkwindowpeer,
"postWindowEvent",
"(ILjava/awt/Window;I)V");
postExposeEventID = (*env)->GetMethodID (env, gtkcomponentpeer,
"postExposeEvent", "(IIII)V");
postKeyEventID = (*env)->GetMethodID (env, gtkcomponentpeer,
"postKeyEvent", "(IJIICI)V");
postFocusEventID = (*env)->GetMethodID (env, gtkcomponentpeer,
"postFocusEvent", "(IZ)V");
postAdjustmentEventID = (*env)->GetMethodID (env, gtkscrollbarpeer,
"postAdjustmentEvent",
"(II)V");
postItemEventID = (*env)->GetMethodID (env, gtkcomponentpeer,
"postItemEvent",
"(Ljava/lang/Object;I)V");
choicePostItemEventID = (*env)->GetMethodID (env, gtkchoicepeer,
"choicePostItemEvent",
"(Ljava/lang/String;I)V");
postListItemEventID = (*env)->GetMethodID (env, gtklistpeer,
"postItemEvent",
"(II)V");
postTextEventID = (*env)->GetMethodID (env, gtktextcomponentpeer,
"postTextEvent",
"()V");
global_gtk_window_group = gtk_window_group_new ();
}
/*============================================================================*
* API *
*============================================================================*/
EAPI Egueb_Dom_Window * gegueb_window_new(Egueb_Dom_Node *doc,
int x, int y, int w, int h)
{
Gegueb_Window *thiz;
Egueb_Dom_Window *ret = NULL;
Egueb_Dom_Node *topmost;
Egueb_Dom_Feature *f;
GdkWindowAttr attr;
gint event_mask;
if (!doc) return NULL;
topmost = egueb_dom_document_document_element_get(doc);
if (!topmost)
{
ERR("The document does not have a topmost element");
goto no_topmost;
}
/* check it it has the render feature */
f = egueb_dom_node_feature_get(topmost, EGUEB_DOM_FEATURE_RENDER_NAME, NULL);
if (!f)
{
ERR("The topmost element does not have a render feature");
goto no_feature;
}
egueb_dom_feature_unref(f);
f = egueb_dom_node_feature_get(topmost, EGUEB_DOM_FEATURE_WINDOW_NAME, NULL);
if (!f)
{
ERR("The topmost element does not have a window feature");
goto no_feature;
}
/* sanitize the width/height */
/* in case the user does not provide a size */
if (w <= 0 || h <= 0)
{
Egueb_Dom_Feature_Window_Hint_Data wdata;
int whints;
whints = egueb_dom_feature_window_hints_get(f, &wdata);
if (whints & EGUEB_DOM_FEATURE_WINDOW_HINT_PREFERRED)
{
if (wdata.pref_width != -1 && w == -1)
w = wdata.pref_width;
if (wdata.pref_height != -1 && h == -1)
h = wdata.pref_height;
}
if (whints & EGUEB_DOM_FEATURE_WINDOW_HINT_MIN_MAX)
{
if (wdata.min_width != -1 && w < wdata.min_width)
w = wdata.min_width;
if (wdata.min_height != -1 && h < wdata.min_height)
h = wdata.min_height;
if (wdata.max_width != -1 && w > wdata.max_width)
w = wdata.max_width;
if (wdata.max_height != -1 && h > wdata.max_height)
h = wdata.max_height;
}
}
if (w <= 0 || h <= 0)
{
ERR("Invalid size of the window %d %d", w, h);
egueb_dom_feature_unref(f);
goto no_feature;
}
egueb_dom_feature_unref(f);
egueb_dom_feature_window_size_set(f, w, h);
thiz = g_new0(Gegueb_Window, 1);
/* set the event mask */
event_mask = GDK_EXPOSURE_MASK;
f = egueb_dom_node_feature_get(topmost,
EGUEB_DOM_FEATURE_UI_NAME, NULL);
if (f)
{
event_mask |= GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK;
egueb_dom_feature_unref(f);
}
/* set the window attributes */
attr.width = w;
attr.height = h;
attr.window_type = GDK_WINDOW_TOPLEVEL;
attr.event_mask = event_mask;
thiz->doc = gegueb_document_new();
gegueb_document_document_set(thiz->doc, doc);
gegueb_document_damage_cb_set(thiz->doc, _gegueb_window_damages, thiz);
thiz->regions = gdk_region_new();
thiz->win = gdk_window_new(NULL, &attr, 0);
thiz->ewin = egueb_dom_window_new(&_dom_descriptor, thiz);
egueb_dom_window_document_set(thiz->ewin, doc);
gdk_event_handler_set(_gegueb_event_cb, thiz, NULL);
gdk_window_show(thiz->win);
egueb_dom_node_unref(topmost);
return thiz->ewin;
no_feature:
egueb_dom_node_unref(topmost);
no_topmost:
egueb_dom_node_unref(doc);
return NULL;
}
int main (int argc, char **argv)
{
GdkWindow *rootwindow; /* RootWindow of X11*/
GMainLoop *loop; /* the event loop */
char *pw_dir;
char *xml_file;
uid_t uid;
struct passwd *pass;
/* inits some gdk stuff */
gdk_init(&argc, &argv);
#ifdef ENABLE_LIBWNCK
screen = wnck_screen_get_default ();
wnck_screen_force_update (screen);
#endif
parse_options(&argc, &argv);
uid = getuid();
pass = getpwuid (uid);
pw_dir = pass->pw_dir;
xml_file = (char*) malloc (sizeof (char) * (strlen (XML_FILE) + strlen (pw_dir) + 1));
sprintf (xml_file, "%s%s", pw_dir, XML_FILE);
eventlist = parseDoc (xml_file);
if (eventlist == NULL)
{
g_print ("xml error or no elements in list\n");
exit (1);
}
free (xml_file);
rootwindow = gdk_window_foreign_new (gdk_x11_get_default_root_xwindow());
/*rootwindow = gdk_window_foreign_new (0x1200002); */
if (rootwindow == NULL)
{
g_print ("rootwindow == NULL\n");
exit (1);
}
/* check if GDK_BUTTON_PRESS_MASK is available */
gdk_error_trap_push ();
/* ... Call the X function which may cause an error here ... */
gdk_window_set_events (rootwindow, GDK_BUTTON_PRESS_MASK);
gdk_window_set_events (rootwindow, GDK_SCROLL_MASK);
/* Flush the X queue to catch errors now. */
gdk_flush ();
if (gdk_error_trap_pop ())
{
char error[] = "grootevent: an error occured while querying the X server.\n"
"A window manager or an application is already grapping\n"
"the buttons from the root window.\n\n"
"Please read the documentation to get more help about this.\n";
g_print (error);
exit (1);
}
gdk_event_handler_set (event_func, NULL, NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
return 0;
}
static void
glade_app_class_init (GladeAppClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
object_class->constructor = glade_app_constructor;
object_class->dispose = glade_app_dispose;
object_class->finalize = glade_app_finalize;
/**
* GladeApp::doc-search:
* @gladeeditor: the #GladeEditor which received the signal.
* @arg1: the (#gchar *) book to search or %NULL
* @arg2: the (#gchar *) page to search or %NULL
* @arg3: the (#gchar *) search string or %NULL
*
* Emitted when the glade core requests that a doc-search be performed.
*/
glade_app_signals[DOC_SEARCH] =
g_signal_new ("doc-search",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
_glade_marshal_VOID__STRING_STRING_STRING,
G_TYPE_NONE, 3,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
/**
* GladeApp::signal-editor-created:
* @gladeapp: the #GladeApp which received the signal.
* @signal_editor: the new #GladeSignalEditor.
*
* Emitted when a new signal editor created.
* A tree view is created in the default handler.
* Connect your handler before the default handler for setting a custom column or renderer
* and after it for connecting to the tree view signals
*/
glade_app_signals[SIGNAL_EDITOR_CREATED] =
g_signal_new ("signal-editor-created",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_glade_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
/**
* GladeApp::widget-adaptor-registered:
* @gladeapp: the #GladeApp which received the signal.
* @adaptor: the newlly registered #GladeWidgetAdaptor.
*
* Emitted when a new widget adaptor is registered.
*/
glade_app_signals[WIDGET_ADAPTOR_REGISTERED] =
g_signal_new ("widget-adaptor-registered",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_glade_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, G_TYPE_OBJECT);
gdk_event_handler_set (glade_app_event_handler, NULL, NULL);
}