static int
ToolsCoreRunLoop(ToolsServiceState *state)
{
if (!ToolsCore_InitRpc(state)) {
return 1;
}
/*
* Start the RPC channel if it's been created. The channel may be NULL if this is
* not running in the context of a VM.
*/
if (state->ctx.rpc && !RpcChannel_Start(state->ctx.rpc)) {
return 1;
}
if (!ToolsCore_LoadPlugins(state)) {
return 1;
}
#if defined(__linux__)
/*
* Init a reference to vSocket family in the main service.
*/
if (state->mainService) {
ToolsCore_InitVsockFamily(state);
}
#endif
/*
* The following criteria needs to hold for the main loop to be run:
*
* . no plugin has requested the service to shut down during initialization.
* . we're either on a VMware hypervisor, or running an unknown service name.
* . we're running in debug mode.
*
* In the non-VMware hypervisor case, just exit with a '0' return status (see
* bug 297528 for why '0').
*/
if (state->ctx.errorCode == 0 &&
(state->ctx.isVMware ||
ToolsCore_GetTcloName(state) == NULL ||
state->debugPlugin != NULL)) {
ToolsCore_RegisterPlugins(state);
/*
* Listen for the I/O freeze signal. We have to disable the config file
* check when I/O is frozen or the (Win32) sync driver may cause the service
* to hang (and make the VM unusable until it times out).
*/
if (g_signal_lookup(TOOLS_CORE_SIG_IO_FREEZE,
G_OBJECT_TYPE(state->ctx.serviceObj)) != 0) {
g_signal_connect(state->ctx.serviceObj,
TOOLS_CORE_SIG_IO_FREEZE,
G_CALLBACK(ToolsCoreIOFreezeCb),
state);
}
state->configCheckTask = g_timeout_add(CONF_POLL_TIME * 1000,
ToolsCoreConfFileCb,
state);
#if defined(__APPLE__)
ToolsCore_CFRunLoop(state);
#else
g_main_loop_run(state->ctx.mainLoop);
#endif
}
ToolsCoreCleanup(state);
return state->ctx.errorCode;
}
void dt_control_signal_raise(const dt_control_signal_t *ctlsig, dt_signal_t signal, ...)
{
// ignore all signals on shutdown
if(!dt_control_running()) return;
dt_signal_description *signal_description = &_signal_description[signal];
_signal_param_t *params = (_signal_param_t *)malloc(sizeof(_signal_param_t));
if(!params) return;
GValue *instance_and_params = calloc(1 + signal_description->n_params, sizeof(GValue));
if(!instance_and_params)
{
free(params);
return;
}
// 0th element has to be the instance to call
g_value_init(instance_and_params, _signal_type);
g_value_set_object(instance_and_params, ctlsig->sink);
// the rest of instance_and_params will be the params for the callback
va_list extra_args;
va_start(extra_args, signal);
for(int i = 1; i <= signal_description->n_params; i++)
{
GType type = signal_description->param_types[i-1];
g_value_init(&instance_and_params[i], type);
switch(type)
{
case G_TYPE_UINT:
g_value_set_uint(&instance_and_params[i], va_arg(extra_args, guint));
break;
case G_TYPE_STRING:
g_value_set_string(&instance_and_params[i], va_arg(extra_args, const char *));
break;
case G_TYPE_POINTER:
g_value_set_pointer(&instance_and_params[i], va_arg(extra_args, void *));
break;
default:
fprintf(stderr, "error: unsupported parameter type `%s' for signal `%s'\n", g_type_name(type), signal_description->name);
va_end(extra_args);
for(int j = 0; j <= i; j++) g_value_unset(&instance_and_params[j]);
free(instance_and_params);
free(params);
return;
}
}
va_end(extra_args);
params->instance_and_params = instance_and_params;
params->signal_id = g_signal_lookup(_signal_description[signal].name, _signal_type);
params->n_params = signal_description->n_params;
if(!signal_description->synchronous)
{
g_main_context_invoke(NULL, _signal_raise, params);
} else {
if(pthread_equal(darktable.control->gui_thread, pthread_self())) {
_signal_raise(params);
} else {
async_com_data communication;
g_mutex_init(&communication.end_mutex);
g_cond_init(&communication.end_cond);
g_mutex_lock(&communication.end_mutex);
communication.user_data = params;
g_main_context_invoke(NULL,_async_com_callback,&communication);
g_cond_wait(&communication.end_cond,&communication.end_mutex);
g_mutex_unlock(&communication.end_mutex);
g_mutex_clear(&communication.end_mutex);
}
}
}
static void
update_thumbnail_popup_process (GtkWidget *widget, GdkEventMotion *event)
{
//g_message ("Doing %s, event = %p", __func__, event);
static gboolean witn = FALSE; /* "Was in thumbnail". */
static GtkTreePath *otp = NULL;
static GtkTreeViewColumn *otc = NULL;
static GTimer *hover_timer = NULL;
if ( hover_timer == NULL ) {
hover_timer = g_timer_new ();
}
/* Fos some crazy reason, drawing the popup image changes the result
of in_thumbnail (I suspect because gdk is reusing event
structures in some strange way). So memorize in_thumbnail up
front. */
// Also, this assertion should pass, but doesn't... synthesizing
// motion events is apparently a bit harder than I realized.
// g_assert (event->type == GDK_MOTION_NOTIFY);
//g_message ("event x: %lf, event y: %lf", event->x, event->y);
gboolean event_in_thumbnail = in_thumbnail (widget, event);
/* Hover time in milliseconds required before a popup image is
displayed. */
const gint hover_time = 70;
// FIXME: It would be nice to allow popup images of both the input
// and output thumbnails, but it requires more hassle keeping track
// of where we were, where we are now, etc., so its not going to
// happen until someone asks.
if ( !witn && in_input_thumbnail (widget, event) ) {
witn = TRUE;
otp = thumbnail_path (widget, event);
g_assert (gtk_tree_path_get_depth (otp) == 1);
otc = thumbnail_column (widget, event);
g_timer_start (hover_timer);
//g_message ("Adding timeout from !with && in_input_thumbnail");
fake_motion_signal_args_t *fmsa = g_new (fake_motion_signal_args_t, 1);
fmsa->widget = widget;
fmsa->event = event;
fmsa->is_valid = TRUE;
g_timeout_add (hover_time, (GSourceFunc) emit_fake_motion_signal, fmsa);
}
if ( witn && in_input_thumbnail (widget, event) ) {
//g_message ("in_thumbnail: %d", in_thumbnail (widget, event));
GtkTreePath *ctp = thumbnail_path (widget, event);
g_assert (gtk_tree_path_get_depth (ctp) == 1);
GtkTreeViewColumn *ctc = thumbnail_column (widget, event);
if ( gtk_tree_path_compare (ctp, otp) == 0 && ctc == otc ) {
/* Sometimes the timeout handler seems to go off a bit before
timer has measured the correct amount of time, so we add a
small margin here. */
const gint slop_time = 5;
const gint seconds_to_mseconds_factor = 1000;
/* If we hover for this long or longer, we should show the popup. */
if ( g_timer_elapsed (hover_timer, NULL) * seconds_to_mseconds_factor
>= hover_time - slop_time) {
//g_message ("elapsed time: %lf\n", g_timer_elapsed (hover_timer, NULL));
//g_message ("Do popup!!!");
//g_message ("in_thumbnail: %d", in_thumbnail (widget, event));
GdkRegion *tr = thumbnail_region (widget, event);
//g_message ("bpw in_thumbnail: %d", in_thumbnail (widget, event));
//g_message ("widget: %p", widget);
GdkWindow *popup_window = draw_popup_image (widget, ctp, ctc, tr);
//g_message ("apw in_thumbnail: %d", in_thumbnail (widget, event));
//g_message ("widget: %p", widget);
/* We don't want continuous redrawing of the popup, so we
disable the handler that triggers it until the popup is
removed. */
if (popup_window)
{
guint signal_id = g_signal_lookup ("motion-notify-event",
GTK_WIDGET_TYPE (widget));
gulong handler_id
= g_signal_handler_find (widget,
G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC
| G_SIGNAL_MATCH_DATA,
signal_id,
(GQuark) 0,
NULL,
files_list_motion_notify_event_handler,
NULL);
g_assert (handler_id != 0);
g_signal_handler_block (widget, handler_id);
/* We want to get rid of the popup window as soon as the user
moves the mouse outside of the original thumbnail
space. */
maybe_clear_popup_image_args.popup = popup_window;
maybe_clear_popup_image_args.tree_view = GTK_TREE_VIEW (widget);
if ( maybe_clear_popup_image_args.thumbnail_region != NULL ) {
gdk_region_destroy (maybe_clear_popup_image_args.thumbnail_region);
}
//g_message ("in_thumbnail: %d", in_thumbnail (widget, event));
maybe_clear_popup_image_args.thumbnail_region = tr;
g_signal_connect (widget, "motion-notify-event",
G_CALLBACK (maybe_clear_popup_image),
&maybe_clear_popup_image_args);
//g_message ("in_thumbnail: %d", in_thumbnail (widget, event));
}
}
else {
gtk_tree_path_free (ctp);
}
}
else {
gtk_tree_path_free (otp);
otp = ctp;
otc = ctc;
g_timer_start (hover_timer);
//g_message ("Adding timeout from 'different thumbnails'");
fake_motion_signal_args_t *fmsa = g_new (fake_motion_signal_args_t, 1);
fmsa->widget = widget;
fmsa->event = event;
fmsa->is_valid = TRUE;
g_timeout_add (hover_time, (GSourceFunc) emit_fake_motion_signal, fmsa);
}
}
if ( witn && !event_in_thumbnail ) {
//g_message ("in_thumbnail: %d", in_thumbnail (widget, event));
//g_message ("Setting witn false");
witn = FALSE;
}
}
static void
impl_activate (RBPlugin *plugin,
RBShell *shell)
{
RBAudioCdPlugin *pi = RB_AUDIOCD_PLUGIN (plugin);
RBRemovableMediaManager *rmm;
gboolean scanned;
GObject *shell_player;
RBPlayer *player_backend;
GtkUIManager *uimanager;
char *filename;
pi->sources = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
g_object_unref,
g_object_unref);
pi->shell = shell;
g_object_get (shell,
"removable-media-manager", &rmm,
"ui-manager", &uimanager,
NULL);
filename = rb_plugin_find_file (plugin, "audiocd-ui.xml");
if (filename != NULL) {
pi->ui_merge_id = gtk_ui_manager_add_ui_from_file (uimanager,
filename,
NULL);
} else {
g_warning ("Unable to find file: audiocd-ui.xml");
}
g_free (filename);
g_object_unref (uimanager);
/* watch for new removable media. use connect_after so
* plugins for more specific device types can get in first.
*/
g_signal_connect_after (rmm,
"create-source-mount", G_CALLBACK (create_source_cb),
pi);
/* only scan if we're being loaded after the initial scan has been done */
g_object_get (G_OBJECT (rmm), "scanned", &scanned, NULL);
if (scanned) {
rb_removable_media_manager_scan (rmm);
}
g_object_unref (rmm);
/* player backend hooks: specify the device, limit read speed, and disable paranoia
* in source elements, and when changing between tracks on the same CD, just seek
* between them, rather than closing and reopening the device.
*/
shell_player = rb_shell_get_player (shell);
g_object_get (shell_player, "player", &player_backend, NULL);
if (player_backend) {
GObjectClass *klass = G_OBJECT_GET_CLASS (player_backend);
if (g_signal_lookup ("prepare-source", G_OBJECT_CLASS_TYPE (klass)) != 0) {
g_signal_connect_object (player_backend,
"prepare-source",
G_CALLBACK (rb_audiocd_plugin_prepare_player_source_cb),
plugin, 0);
}
if (g_signal_lookup ("reuse-stream", G_OBJECT_CLASS_TYPE (klass)) != 0) {
g_signal_connect_object (player_backend,
"can-reuse-stream",
G_CALLBACK (rb_audiocd_plugin_can_reuse_stream_cb),
plugin, 0);
g_signal_connect_object (player_backend,
"reuse-stream",
G_CALLBACK (rb_audiocd_plugin_reuse_stream_cb),
plugin, 0);
}
}
/* encoder hooks: specify the device and set the paranoia level (if available) on
* source elements.
*/
g_signal_connect_object (rb_encoder_factory_get (),
"prepare-source",
G_CALLBACK (rb_audiocd_plugin_prepare_encoder_source_cb),
plugin, 0);
g_signal_connect_object (shell_player, "playing-uri-changed",
G_CALLBACK (rb_audiocd_plugin_playing_uri_changed_cb),
plugin, 0);
}
bool wxTopLevelWindowGTK::Show( bool show )
{
wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
#ifdef GDK_WINDOWING_X11
bool deferShow = show && !m_isShown && m_deferShow;
if (deferShow)
{
deferShow = m_deferShowAllowed && gs_requestFrameExtentsStatus != 2 &&
!gtk_widget_get_realized(m_widget) &&
g_signal_handler_find(m_widget,
GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
0, NULL, NULL, this);
if (deferShow)
{
GdkScreen* screen = gtk_widget_get_screen(m_widget);
GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
// If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
// to m_decorSize, it breaks saving/restoring window size with
// GetSize()/SetSize() because it makes window bigger between each
// restore and save.
m_updateDecorSize = deferShow;
}
m_deferShow = deferShow;
}
if (deferShow)
{
// Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
// calling gtk_widget_show() until _NET_FRAME_EXTENTS property
// notification is received, so correct frame extents are known.
// This allows resizing m_widget to keep the overall size in sync with
// what wxWidgets expects it to be without an obvious change in the
// window size immediately after it becomes visible.
// Realize m_widget, so m_widget->window can be used. Realizing normally
// causes the widget tree to be size_allocated, which generates size
// events in the wrong order. However, the size_allocates will not be
// done if the allocation is not the default (1,1).
GtkAllocation alloc;
gtk_widget_get_allocation(m_widget, &alloc);
const int alloc_width = alloc.width;
if (alloc_width == 1)
{
alloc.width = 2;
gtk_widget_set_allocation(m_widget, &alloc);
}
gtk_widget_realize(m_widget);
if (alloc_width == 1)
{
alloc.width = 1;
gtk_widget_set_allocation(m_widget, &alloc);
}
// send _NET_REQUEST_FRAME_EXTENTS
XClientMessageEvent xevent;
memset(&xevent, 0, sizeof(xevent));
xevent.type = ClientMessage;
GdkWindow* window = gtk_widget_get_window(m_widget);
xevent.window = GDK_WINDOW_XID(window);
xevent.message_type = gdk_x11_atom_to_xatom_for_display(
gdk_window_get_display(window),
gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
xevent.format = 32;
Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
XSendEvent(display, DefaultRootWindow(display), false,
SubstructureNotifyMask | SubstructureRedirectMask,
(XEvent*)&xevent);
if (gs_requestFrameExtentsStatus == 0)
{
// if WM does not respond to request within 1 second,
// we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
m_netFrameExtentsTimerId =
g_timeout_add(1000, request_frame_extents_timeout, this);
}
// defer calling gtk_widget_show()
m_isShown = true;
return true;
}
#endif // GDK_WINDOWING_X11
if (show && !gtk_widget_get_realized(m_widget))
{
// size_allocate signals occur in reverse order (bottom to top).
// Things work better if the initial wxSizeEvents are sent (from the
// top down), before the initial size_allocate signals occur.
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
}
bool change = base_type::Show(show);
if (change && !show)
{
// make sure window has a non-default position, so when it is shown
// again, it won't be repositioned by WM as if it were a new window
// Note that this must be done _after_ the window is hidden.
gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
}
return change;
}
static int
_object_signal_connect(ClipMachine *cm, gboolean after)
{
C_object *cobj = _fetch_co_arg(cm);
SignalTable *sig_table = NULL;
int ret=-1;
CHECKCOBJ(cobj,GTK_IS_OBJECT(cobj->object));
CHECKARG2(2,CHARACTER_t,NUMERIC_t);
CHECKARG2(3,PCODE_t,CCODE_t);
if (_clip_parinfo(cm,2) == CHARACTER_t)
{
sig_table = _sig_table_by_name(cobj->type, _clip_parc(cm,2));
}
else
sig_table = _sig_table_by_id(cobj->type, _clip_parni(cm,2));
if (sig_table && sig_table->sigfunction)
{
GtkSignalFunc sfunc = sig_table->sigfunction;
gchar *signame = sig_table->signame;
long sid = sig_table->sigid;
int sigfound = g_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object));
int extra_sigfound = _extra_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object));
C_signal *cs = 0;
//printf ("object %s signame %s \n", cobj->type_name, signame);
if (sigfound || extra_sigfound || sid < 1000) /* sid<1000 - event */
{
if (!cobj->siglist)
{
cobj->siglist = NEW(C_signal);
cs = cobj->siglist;
}
else
{
for (cs = cobj->siglist; cs && cs->next; cs = cs->next);
cs->next = NEW(C_signal);
cs = cs->next;
}
cs->co = cobj;
cs->signame = sig_table->signame;
cs->sigid = sig_table->sigid;
_clip_mclone(cm, &cs->cfunc, _clip_spar(cm,3));
}
if (sigfound)
{
if (after)
{
ret = g_signal_connect_after(GTK_OBJECT(cobj->object),
signame,GSF(sfunc),cs);
}
else
{
ret = g_signal_connect(GTK_OBJECT(cobj->object),
signame,GSF(sfunc),cs);
}
}
}
_clip_retni(cm,ret);
return 0;
err:
_clip_retni(cm,ret);
return 1;
}
nsresult
nsAccessibleWrap::FirePlatformEvent(AccEvent* aEvent)
{
nsAccessible *accessible = aEvent->GetAccessible();
NS_ENSURE_TRUE(accessible, NS_ERROR_FAILURE);
PRUint32 type = aEvent->GetEventType();
AtkObject *atkObj = nsAccessibleWrap::GetAtkObject(accessible);
// We don't create ATK objects for nsIAccessible plain text leaves,
// just return NS_OK in such case
if (!atkObj) {
NS_ASSERTION(type == nsIAccessibleEvent::EVENT_SHOW ||
type == nsIAccessibleEvent::EVENT_HIDE,
"Event other than SHOW and HIDE fired for plain text leaves");
return NS_OK;
}
nsAccessibleWrap *accWrap = GetAccessibleWrap(atkObj);
if (!accWrap) {
return NS_OK; // Node is shut down
}
switch (type) {
case nsIAccessibleEvent::EVENT_STATE_CHANGE:
return FireAtkStateChangeEvent(aEvent, atkObj);
case nsIAccessibleEvent::EVENT_TEXT_REMOVED:
case nsIAccessibleEvent::EVENT_TEXT_INSERTED:
return FireAtkTextChangedEvent(aEvent, atkObj);
case nsIAccessibleEvent::EVENT_FOCUS:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_FOCUS\n"));
nsRefPtr<nsRootAccessible> rootAccWrap = accWrap->GetRootAccessible();
if (rootAccWrap && rootAccWrap->mActivated) {
atk_focus_tracker_notify(atkObj);
// Fire state change event for focus
nsRefPtr<AccEvent> stateChangeEvent =
new AccStateChangeEvent(accessible,
nsIAccessibleStates::STATE_FOCUSED,
PR_FALSE, PR_TRUE);
return FireAtkStateChangeEvent(stateChangeEvent, atkObj);
}
} break;
case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_VALUE_CHANGE\n"));
nsCOMPtr<nsIAccessibleValue> value(do_QueryObject(accessible));
if (value) { // Make sure this is a numeric value
// Don't fire for MSAA string value changes (e.g. text editing)
// ATK values are always numeric
g_object_notify( (GObject*)atkObj, "accessible-value" );
}
} break;
case nsIAccessibleEvent::EVENT_SELECTION_CHANGED:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_SELECTION_CHANGED\n"));
g_signal_emit_by_name(atkObj, "selection_changed");
break;
case nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TEXT_SELECTION_CHANGED\n"));
g_signal_emit_by_name(atkObj, "text_selection_changed");
break;
case nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TEXT_CARET_MOVED\n"));
AccCaretMoveEvent* caretMoveEvent = downcast_accEvent(aEvent);
NS_ASSERTION(caretMoveEvent, "Event needs event data");
if (!caretMoveEvent)
break;
PRInt32 caretOffset = caretMoveEvent->GetCaretOffset();
MAI_LOG_DEBUG(("\n\nCaret postion: %d", caretOffset));
g_signal_emit_by_name(atkObj,
"text_caret_moved",
// Curent caret position
caretOffset);
} break;
case nsIAccessibleEvent::EVENT_TEXT_ATTRIBUTE_CHANGED:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TEXT_ATTRIBUTE_CHANGED\n"));
g_signal_emit_by_name(atkObj,
"text-attributes-changed");
break;
case nsIAccessibleEvent::EVENT_TABLE_MODEL_CHANGED:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_MODEL_CHANGED\n"));
g_signal_emit_by_name(atkObj, "model_changed");
break;
case nsIAccessibleEvent::EVENT_TABLE_ROW_INSERT:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_ROW_INSERT\n"));
AccTableChangeEvent* tableEvent = downcast_accEvent(aEvent);
NS_ENSURE_TRUE(tableEvent, NS_ERROR_FAILURE);
PRInt32 rowIndex = tableEvent->GetIndex();
PRInt32 numRows = tableEvent->GetCount();
g_signal_emit_by_name(atkObj,
"row_inserted",
// After which the rows are inserted
rowIndex,
// The number of the inserted
numRows);
} break;
case nsIAccessibleEvent::EVENT_TABLE_ROW_DELETE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_ROW_DELETE\n"));
AccTableChangeEvent* tableEvent = downcast_accEvent(aEvent);
NS_ENSURE_TRUE(tableEvent, NS_ERROR_FAILURE);
PRInt32 rowIndex = tableEvent->GetIndex();
PRInt32 numRows = tableEvent->GetCount();
g_signal_emit_by_name(atkObj,
"row_deleted",
// After which the rows are deleted
rowIndex,
// The number of the deleted
numRows);
} break;
case nsIAccessibleEvent::EVENT_TABLE_ROW_REORDER:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_ROW_REORDER\n"));
g_signal_emit_by_name(atkObj, "row_reordered");
break;
}
case nsIAccessibleEvent::EVENT_TABLE_COLUMN_INSERT:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_COLUMN_INSERT\n"));
AccTableChangeEvent* tableEvent = downcast_accEvent(aEvent);
NS_ENSURE_TRUE(tableEvent, NS_ERROR_FAILURE);
PRInt32 colIndex = tableEvent->GetIndex();
PRInt32 numCols = tableEvent->GetCount();
g_signal_emit_by_name(atkObj,
"column_inserted",
// After which the columns are inserted
colIndex,
// The number of the inserted
numCols);
} break;
case nsIAccessibleEvent::EVENT_TABLE_COLUMN_DELETE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_COLUMN_DELETE\n"));
AccTableChangeEvent* tableEvent = downcast_accEvent(aEvent);
NS_ENSURE_TRUE(tableEvent, NS_ERROR_FAILURE);
PRInt32 colIndex = tableEvent->GetIndex();
PRInt32 numCols = tableEvent->GetCount();
g_signal_emit_by_name(atkObj,
"column_deleted",
// After which the columns are deleted
colIndex,
// The number of the deleted
numCols);
} break;
case nsIAccessibleEvent::EVENT_TABLE_COLUMN_REORDER:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_TABLE_COLUMN_REORDER\n"));
g_signal_emit_by_name(atkObj, "column_reordered");
break;
case nsIAccessibleEvent::EVENT_SECTION_CHANGED:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_SECTION_CHANGED\n"));
g_signal_emit_by_name(atkObj, "visible_data_changed");
break;
case nsIAccessibleEvent::EVENT_SHOW:
return FireAtkShowHideEvent(aEvent, atkObj, PR_TRUE);
case nsIAccessibleEvent::EVENT_HIDE:
return FireAtkShowHideEvent(aEvent, atkObj, PR_FALSE);
/*
* Because dealing with menu is very different between nsIAccessible
* and ATK, and the menu activity is important, specially transfer the
* following two event.
* Need more verification by AT test.
*/
case nsIAccessibleEvent::EVENT_MENU_START:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_MENU_START\n"));
break;
case nsIAccessibleEvent::EVENT_MENU_END:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_MENU_END\n"));
break;
case nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_WINDOW_ACTIVATED\n"));
nsRootAccessible *rootAcc =
static_cast<nsRootAccessible *>(accessible);
rootAcc->mActivated = PR_TRUE;
guint id = g_signal_lookup ("activate", MAI_TYPE_ATK_OBJECT);
g_signal_emit(atkObj, id, 0);
// Always fire a current focus event after activation.
rootAcc->FireCurrentFocusEvent();
} break;
case nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_WINDOW_DEACTIVATED\n"));
nsRootAccessible *rootAcc =
static_cast<nsRootAccessible *>(accessible);
rootAcc->mActivated = PR_FALSE;
guint id = g_signal_lookup ("deactivate", MAI_TYPE_ATK_OBJECT);
g_signal_emit(atkObj, id, 0);
} break;
case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_DOCUMENT_LOAD_COMPLETE\n"));
g_signal_emit_by_name (atkObj, "load_complete");
} break;
case nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_DOCUMENT_RELOAD\n"));
g_signal_emit_by_name (atkObj, "reload");
} break;
case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED:
{
MAI_LOG_DEBUG(("\n\nReceived: EVENT_DOCUMENT_LOAD_STOPPED\n"));
g_signal_emit_by_name (atkObj, "load_stopped");
} break;
case nsIAccessibleEvent::EVENT_MENUPOPUP_START:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_MENUPOPUP_START\n"));
atk_focus_tracker_notify(atkObj); // fire extra focus event
atk_object_notify_state_change(atkObj, ATK_STATE_VISIBLE, PR_TRUE);
atk_object_notify_state_change(atkObj, ATK_STATE_SHOWING, PR_TRUE);
break;
case nsIAccessibleEvent::EVENT_MENUPOPUP_END:
MAI_LOG_DEBUG(("\n\nReceived: EVENT_MENUPOPUP_END\n"));
atk_object_notify_state_change(atkObj, ATK_STATE_VISIBLE, PR_FALSE);
atk_object_notify_state_change(atkObj, ATK_STATE_SHOWING, PR_FALSE);
break;
}
return NS_OK;
}
static void
print_signal_info (GstElement * element)
{
/* Signals/Actions Block */
guint *signals;
guint nsignals;
gint i = 0, j, k;
GSignalQuery *query = NULL;
GType type;
GSList *found_signals, *l;
for (k = 0; k < 2; k++) {
found_signals = NULL;
/* For elements that have sometimes pads, also list a few useful GstElement
* signals. Put these first, so element-specific ones come later. */
if (k == 0 && has_sometimes_template (element)) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-added", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-removed", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("no-more-pads", GST_TYPE_ELEMENT),
query);
found_signals = g_slist_append (found_signals, query);
}
for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)
break;
if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)
continue;
signals = g_signal_list_ids (type, &nsignals);
for (i = 0; i < nsignals; i++) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
(k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))
found_signals = g_slist_append (found_signals, query);
else
g_free (query);
}
g_free (signals);
signals = NULL;
}
if (found_signals) {
n_print ("\n");
if (k == 0)
n_print ("Element Signals:\n");
else
n_print ("Element Actions:\n");
} else {
continue;
}
for (l = found_signals; l; l = l->next) {
gchar *indent;
int indent_len;
query = (GSignalQuery *) l->data;
indent_len = strlen (query->signal_name) +
strlen (g_type_name (query->return_type)) + 24;
indent = g_new0 (gchar, indent_len + 1);
memset (indent, ' ', indent_len);
n_print (" \"%s\" : %s user_function (%s* object",
query->signal_name,
g_type_name (query->return_type), g_type_name (type));
for (j = 0; j < query->n_params; j++) {
if (_name)
g_print ("%s", _name);
if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else if (G_TYPE_IS_ENUM (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else {
g_print (",\n%s%s* arg%d", indent,
g_type_name (query->param_types[j]), j);
}
}
if (k == 0) {
if (_name)
g_print ("%s", _name);
g_print (",\n%sgpointer user_data);\n", indent);
} else
g_print (");\n");
g_free (indent);
}
if (found_signals) {
g_slist_foreach (found_signals, (GFunc) g_free, NULL);
g_slist_free (found_signals);
}
}
}
static void
on_glade_drop (IAnjutaEditor* editor,
IAnjutaIterable* iterator,
const gchar* signal_data,
PythonPlugin* lang_plugin)
{
GSignalQuery query;
GType type;
guint id;
const gchar* widget;
const gchar* signal;
const gchar* handler;
const gchar* user_data;
gboolean swapped;
GList* names = NULL;
GString* str = g_string_new (NULL);
int i;
IAnjutaIterable* start, * end;
GStrv data = g_strsplit(signal_data, ":", 5);
widget = data[0];
signal = data[1];
handler = data[2];
user_data = data[3];
swapped = g_str_equal (data[4], "1");
type = g_type_from_name (widget);
id = g_signal_lookup (signal, type);
g_signal_query (id, &query);
g_string_append_printf (str, "\ndef %s (self", handler);
for (i = 0; i < query.n_params; i++)
{
const gchar* type_name = g_type_name (query.param_types[i]);
const gchar* param_name = language_support_get_signal_parameter (type_name,
&names);
g_string_append_printf (str, ", %s", param_name);
}
g_string_append (str, "):\n");
ianjuta_editor_insert (editor, iterator,
str->str, -1, NULL);
/* Indent code correctly */
start = iterator;
end = ianjuta_iterable_clone (iterator, NULL);
ianjuta_iterable_set_position (end,
ianjuta_iterable_get_position (iterator, NULL)
+ g_utf8_strlen (str->str, -1),
NULL);
ianjuta_indenter_indent (IANJUTA_INDENTER (lang_plugin),
start, end, NULL);
g_object_unref (end);
g_string_free (str, TRUE);
anjuta_util_glist_strings_free (names);
g_strfreev (data);
}
static void
parasite_actionlist_init(ParasiteActionList *actionlist,
ParasiteActionListClass *klass)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GTypeClass *uimanager_type;
guint uimanager_signal;
actionlist->priv = PARASITE_ACTIONLIST_GET_PRIVATE(actionlist);
actionlist->priv->uimanagers = NULL;
actionlist->priv->model =
gtk_tree_store_new(NUM_COLUMNS,
G_TYPE_STRING, // ACTION_LABEL
G_TYPE_STRING, // ACTION_NAME
G_TYPE_STRING, // ACTION_ICON
G_TYPE_STRING, // ROW_COLOR,
G_TYPE_STRING, // SORT_NAME
G_TYPE_POINTER); // ADDRESS
gtk_tree_view_set_model(GTK_TREE_VIEW(actionlist),
GTK_TREE_MODEL(actionlist->priv->model));
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column);
gtk_tree_view_column_set_title(column, "Label");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"stock-id", ACTION_ICON,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", ACTION_LABEL,
"foreground", ROW_COLOR,
NULL);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Action",
renderer,
"text", ACTION_NAME,
"foreground", ROW_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column);
gtk_tree_sortable_set_sort_column_id(
GTK_TREE_SORTABLE(actionlist->priv->model),
SORT_NAME, GTK_SORT_ASCENDING);
// Listen to all "actions-changed" signal emissions
uimanager_type = g_type_class_ref(GTK_TYPE_UI_MANAGER);
uimanager_signal = g_signal_lookup("actions-changed", GTK_TYPE_UI_MANAGER);
g_signal_add_emission_hook(uimanager_signal, 0,
actions_changed_cb,
actionlist,
NULL);
g_type_class_unref(uimanager_type);
}
static void
fcitx_im_context_class_init(FcitxIMContextClass *klass)
{
GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS(klass);
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
parent_class = (GtkIMContextClass *) g_type_class_peek_parent (klass);
im_context_class->set_client_window = fcitx_im_context_set_client_window;
im_context_class->filter_keypress = fcitx_im_context_filter_keypress;
im_context_class->reset = fcitx_im_context_reset;
im_context_class->get_preedit_string = fcitx_im_context_get_preedit_string;
im_context_class->focus_in = fcitx_im_context_focus_in;
im_context_class->focus_out = fcitx_im_context_focus_out;
im_context_class->set_cursor_location = fcitx_im_context_set_cursor_location;
im_context_class->set_use_preedit = fcitx_im_context_set_use_preedit;
im_context_class->set_surrounding = fcitx_im_context_set_surrounding;
gobject_class->finalize = fcitx_im_context_finalize;
_signal_commit_id =
g_signal_lookup("commit", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_commit_id != 0);
_signal_preedit_changed_id =
g_signal_lookup("preedit-changed", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_preedit_changed_id != 0);
_signal_preedit_start_id =
g_signal_lookup("preedit-start", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_preedit_start_id != 0);
_signal_preedit_end_id =
g_signal_lookup("preedit-end", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_preedit_end_id != 0);
_signal_delete_surrounding_id =
g_signal_lookup("delete-surrounding", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_delete_surrounding_id != 0);
_signal_retrieve_surrounding_id =
g_signal_lookup("retrieve-surrounding", G_TYPE_FROM_CLASS(klass));
g_assert(_signal_retrieve_surrounding_id != 0);
_use_key_snooper = !_get_boolean_env ("IBUS_DISABLE_SNOOPER", !(_ENABLE_SNOOPER))
&& !_get_boolean_env("FCITX_DISABLE_SNOOPER", !(_ENABLE_SNOOPER));
/* env IBUS_DISABLE_SNOOPER does not exist */
if (_use_key_snooper) {
/* disable snooper if app is in _no_snooper_apps */
const gchar * prgname = g_get_prgname ();
if (g_getenv ("IBUS_NO_SNOOPER_APPS")) {
_no_snooper_apps = g_getenv ("IBUS_NO_SNOOPER_APPS");
}
if (g_getenv ("FCITX_NO_SNOOPER_APPS")) {
_no_snooper_apps = g_getenv ("FCITX_NO_SNOOPER_APPS");
}
gchar **p;
gchar ** apps = g_strsplit (_no_snooper_apps, ",", 0);
for (p = apps; *p != NULL; p++) {
if (g_regex_match_simple (*p, prgname, 0, 0)) {
_use_key_snooper = FALSE;
break;
}
}
g_strfreev (apps);
}
/* make ibus fix benefits us */
_use_sync_mode = _get_boolean_env("IBUS_ENABLE_SYNC_MODE", FALSE)
|| _get_boolean_env("FCITX_ENABLE_SYNC_MODE", FALSE);
/* always install snooper */
if (_key_snooper_id == 0)
_key_snooper_id = gtk_key_snooper_install (_key_snooper_cb, NULL);
}
static gboolean region_labels_mouse_enter(GtkWidget *w, GdkEventCrossing *ev, gpointer data)
{
g_signal_stop_emission(GTK_OBJECT(w), g_signal_lookup("enter_notify_event", G_OBJECT_TYPE(GTK_OBJECT(w))), 0);
return(false);
}
static void
gail_finish_select (GtkWidget *widget)
{
if (GTK_IS_MENU_ITEM (widget))
{
GtkMenuItem* menu_item;
menu_item = GTK_MENU_ITEM (widget);
if (menu_item->submenu &&
!GTK_WIDGET_MAPPED (menu_item->submenu))
{
/*
* If the submenu is not visble, wait until it is before
* reporting focus on the menu item.
*/
gulong handler_id;
handler_id = g_signal_handler_find (menu_item->submenu,
G_SIGNAL_MATCH_FUNC,
g_signal_lookup ("map",
GTK_TYPE_WINDOW),
0,
NULL,
(gpointer) gail_map_submenu_cb,
NULL);
if (!handler_id)
g_signal_connect (menu_item->submenu, "map",
G_CALLBACK (gail_map_submenu_cb),
NULL);
return;
}
/*
* If we are waiting to report focus on a menubar or a menu item
* because of a previous deselect, cancel it.
*/
if (was_deselect &&
focus_notify_handler &&
next_focus_widget &&
(GTK_IS_MENU_BAR (next_focus_widget) ||
GTK_IS_MENU_ITEM (next_focus_widget)))
{
void *vp_next_focus_widget = &next_focus_widget;
g_source_remove (focus_notify_handler);
g_object_remove_weak_pointer (G_OBJECT (next_focus_widget), vp_next_focus_widget);
next_focus_widget = NULL;
focus_notify_handler = 0;
was_deselect = FALSE;
}
}
/*
* If previously focused widget is not a GtkMenuItem or a GtkMenu,
* keep track of it so we can return to it after menubar is deactivated
*/
if (focus_widget &&
!GTK_IS_MENU_ITEM (focus_widget) &&
!GTK_IS_MENU (focus_widget))
{
void *vp_focus_before_menu = &focus_before_menu;
focus_before_menu = focus_widget;
g_object_add_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
}
gail_focus_notify_when_idle (widget);
return;
}
static void g_udisks_volume_monitor_class_init(GUDisksVolumeMonitorClass *klass)
{
GObjectClass *g_object_class = G_OBJECT_CLASS(klass);
GNativeVolumeMonitorClass *parent_class = G_NATIVE_VOLUME_MONITOR_CLASS(klass);
GVolumeMonitorClass *monitor_class = G_VOLUME_MONITOR_CLASS (klass);
g_object_class->finalize = g_udisks_volume_monitor_finalize;
parent_class->get_mount_for_mount_path = get_mount_for_mount_path;
monitor_class->get_mounts = get_mounts;
monitor_class->get_volumes = get_volumes;
monitor_class->get_connected_drives = get_connected_drives;
monitor_class->get_volume_for_uuid = get_volume_for_uuid;
monitor_class->get_mount_for_uuid = get_mount_for_uuid;
monitor_class->is_supported = is_supported;
monitor_class->drive_eject_button = drive_eject_button;
sig_drive_changed = g_signal_lookup("drive-changed", G_TYPE_VOLUME_MONITOR);
sig_drive_connected = g_signal_lookup("drive-connected", G_TYPE_VOLUME_MONITOR);
sig_drive_disconnected = g_signal_lookup("drive-disconnected", G_TYPE_VOLUME_MONITOR);
sig_drive_eject_button = g_signal_lookup("drive-eject-button", G_TYPE_VOLUME_MONITOR);
sig_mount_added = g_signal_lookup("mount-added", G_TYPE_VOLUME_MONITOR);
sig_mount_changed = g_signal_lookup("mount-changed", G_TYPE_VOLUME_MONITOR);
sig_mount_premount = g_signal_lookup("mount-premount", G_TYPE_VOLUME_MONITOR);
sig_mount_removed = g_signal_lookup("mount-removed", G_TYPE_VOLUME_MONITOR);
sig_volume_added = g_signal_lookup("volume-added", G_TYPE_VOLUME_MONITOR);
sig_volume_changed = g_signal_lookup("volume-changed", G_TYPE_VOLUME_MONITOR);
sig_volume_removed = g_signal_lookup("volume-removed", G_TYPE_VOLUME_MONITOR);
}
int wxDialog::ShowModal()
{
WX_HOOK_MODAL_DIALOG();
wxASSERT_MSG( !IsModal(), "ShowModal() can't be called twice" );
// release the mouse if it's currently captured as the window having it
// will be disabled when this dialog is shown -- but will still keep the
// capture making it impossible to do anything in the modal dialog itself
wxWindow * const win = wxWindow::GetCapture();
if ( win )
win->GTKReleaseMouseAndNotify();
wxWindow * const parent = GetParentForModalDialog();
if ( parent )
{
gtk_window_set_transient_for( GTK_WINDOW(m_widget),
GTK_WINDOW(parent->m_widget) );
}
#if GTK_CHECK_VERSION(2,10,0)
unsigned sigId = 0;
gulong hookId = 0;
#ifndef __WXGTK3__
// Ubuntu overlay scrollbar uses at least GTK 2.24
if (gtk_check_version(2,24,0) == NULL)
#endif
{
sigId = g_signal_lookup("realize", GTK_TYPE_WIDGET);
hookId = g_signal_add_emission_hook(sigId, 0, realize_hook, NULL, NULL);
}
#endif
// NOTE: this will cause a gtk_grab_add() during Show()
gtk_window_set_modal(GTK_WINDOW(m_widget), true);
Show( true );
m_modalShowing = true;
wxOpenModalDialogLocker modalLock;
// Prevent the widget from being destroyed if the user closes the window.
// Needed for derived classes which bypass wxTLW::Create(), and therefore
// the wxTLW "delete-event" handler is not connected
gulong handler_id = g_signal_connect(
m_widget, "delete-event", G_CALLBACK(gtk_true), this);
// Run modal dialog event loop.
{
wxGUIEventLoopTiedPtr modal(&m_modalLoop, new wxGUIEventLoop());
m_modalLoop->Run();
}
g_signal_handler_disconnect(m_widget, handler_id);
#if GTK_CHECK_VERSION(2,10,0)
if (sigId)
g_signal_remove_emission_hook(sigId, hookId);
#endif
gtk_window_set_modal(GTK_WINDOW(m_widget), FALSE);
return GetReturnCode();
}
/*
* "Adds" app window to the set of managed windows.
* Actually, no data structures involved. The only thing we do is save app state
* and register ourselves us listeners.
* Note: User's callback is called
*/
void
xkl_engine_add_toplevel_window(XklEngine * engine, Window toplevel_win,
Window parent,
gboolean ignore_existing_state,
XklState * init_state)
{
XklState state = *init_state;
gint default_group_to_use = -1;
GValue params[3];
GValue rv;
guint signal_id;
if (toplevel_win == xkl_engine_priv(engine, root_window))
xkl_debug(150, "??? root app win ???\n");
xkl_debug(150,
"Trying to add window " WINID_FORMAT
"/%s with group %d\n", toplevel_win,
xkl_get_debug_window_title(engine, toplevel_win),
init_state->group);
if (!ignore_existing_state) {
gboolean have_state =
xkl_engine_get_toplevel_window_state(engine,
toplevel_win,
&state);
if (have_state) {
xkl_debug(150,
"The window " WINID_FORMAT
" does not require to be added, it already has the xklavier state \n",
toplevel_win);
return;
}
}
memset(params, 0, sizeof(params));
g_value_init(params, XKL_TYPE_ENGINE);
g_value_set_object(params, engine);
g_value_init(params + 1, G_TYPE_LONG);
g_value_set_long(params + 1, toplevel_win);
g_value_init(params + 2, G_TYPE_LONG);
g_value_set_long(params + 2, parent);
memset(&rv, 0, sizeof(rv));
g_value_init(&rv, G_TYPE_INT);
g_value_set_int(&rv, default_group_to_use);
signal_id =
g_signal_lookup("new-toplevel-window", xkl_engine_get_type());
g_signal_emitv(params, signal_id, 0, &rv);
default_group_to_use = g_value_get_int(&rv);
if (default_group_to_use == -1) {
Window transient_for = 0;
if (XGetTransientForHint(xkl_engine_get_display(engine), toplevel_win, &transient_for)) {
if (transient_for) {
XklState trans_state;
gboolean have_state =
xkl_engine_get_toplevel_window_state(engine,
transient_for,
&trans_state);
if (have_state) {
default_group_to_use = trans_state.group;
}
}
}
}
if (default_group_to_use == -1)
default_group_to_use =
xkl_engine_priv(engine, default_group);
if (default_group_to_use != -1)
state.group = default_group_to_use;
xkl_engine_save_toplevel_window_state(engine, toplevel_win,
&state);
xkl_engine_select_input_merging(engine, toplevel_win,
FocusChangeMask |
PropertyChangeMask);
if (default_group_to_use != -1) {
if (xkl_engine_priv(engine, curr_toplvl_win) ==
toplevel_win) {
if ((xkl_engine_priv(engine, secondary_groups_mask)
& (1 << default_group_to_use)) != 0)
xkl_engine_allow_one_switch_to_secondary_group
(engine);
xkl_engine_lock_group(engine,
default_group_to_use);
}
}
if (parent == (Window) NULL)
parent =
xkl_engine_get_registered_parent(engine, toplevel_win);
xkl_debug(150, "done\n");
}
int wxDialog::ShowModal()
{
WX_TESTING_SHOW_MODAL_HOOK();
wxASSERT_MSG( !IsModal(), "ShowModal() can't be called twice" );
// release the mouse if it's currently captured as the window having it
// will be disabled when this dialog is shown -- but will still keep the
// capture making it impossible to do anything in the modal dialog itself
wxWindow * const win = wxWindow::GetCapture();
if ( win )
win->GTKReleaseMouseAndNotify();
wxWindow * const parent = GetParentForModalDialog();
if ( parent )
{
gtk_window_set_transient_for( GTK_WINDOW(m_widget),
GTK_WINDOW(parent->m_widget) );
}
wxBusyCursorSuspender cs; // temporarily suppress the busy cursor
#if GTK_CHECK_VERSION(2,10,0)
unsigned sigId = 0;
gulong hookId = 0;
#ifndef __WXGTK3__
// Ubuntu overlay scrollbar uses at least GTK 2.24
if (gtk_check_version(2,24,0) == NULL)
#endif
{
sigId = g_signal_lookup("realize", GTK_TYPE_WIDGET);
hookId = g_signal_add_emission_hook(sigId, 0, realize_hook, NULL, NULL);
}
#endif
Show( true );
m_modalShowing = true;
wxOpenModalDialogsCount++;
// NOTE: gtk_window_set_modal internally calls gtk_grab_add() !
gtk_window_set_modal(GTK_WINDOW(m_widget), TRUE);
// Run modal dialog event loop.
{
wxGUIEventLoopTiedPtr modal(&m_modalLoop, new wxGUIEventLoop());
m_modalLoop->Run();
}
#if GTK_CHECK_VERSION(2,10,0)
if (sigId)
g_signal_remove_emission_hook(sigId, hookId);
#endif
gtk_window_set_modal(GTK_WINDOW(m_widget), FALSE);
wxOpenModalDialogsCount--;
return GetReturnCode();
}
void nsAccessNodeWrap::InitAccessibility()
{
nsAccessNode::InitXPAccessibility();
gHaveNewTextSignals = g_signal_lookup("text-insert", ATK_TYPE_TEXT);
}
static void
cockpit_fake_manager_class_init (CockpitFakeManagerClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->constructed = cockpit_fake_manager_constructed;
gobject_class->get_property = cockpit_fake_manager_get_property;
gobject_class->set_property = cockpit_fake_manager_set_property;
gobject_class->dispose = cockpit_fake_manager_dispose;
gobject_class->finalize = cockpit_fake_manager_finalize;
sig_manager__object_added = g_signal_lookup ("object-added", G_TYPE_DBUS_OBJECT_MANAGER);
g_assert (sig_manager__object_added);
sig_manager__object_removed = g_signal_lookup ("object-removed", G_TYPE_DBUS_OBJECT_MANAGER);
g_assert (sig_manager__object_removed);
sig_manager__interface_added = g_signal_lookup ("interface-added", G_TYPE_DBUS_OBJECT_MANAGER);
g_assert (sig_manager__interface_added != 0);
sig_manager__interface_removed = g_signal_lookup ("interface-removed", G_TYPE_DBUS_OBJECT_MANAGER);
g_assert (sig_manager__interface_removed != 0);
/* Same signature as equivalent signal on GDBusObjectManagerClient */
sig_manager__interface_proxy_signal = g_signal_new ("interface-proxy-signal",
COCKPIT_TYPE_FAKE_MANAGER,
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 5,
G_TYPE_DBUS_OBJECT_PROXY,
G_TYPE_DBUS_PROXY,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_VARIANT);
/* Same signature as equivalent signal on GDBusObjectManagerClient */
sig_manager__interface_proxy_properties_changed = g_signal_new ("interface-proxy-properties-changed",
COCKPIT_TYPE_FAKE_MANAGER,
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 4,
G_TYPE_DBUS_OBJECT_PROXY,
G_TYPE_DBUS_PROXY,
G_TYPE_VARIANT,
G_TYPE_STRV);
g_object_class_install_property (gobject_class, PROP_CONNECTION,
g_param_spec_object ("connection", "Connection", "Connection", G_TYPE_DBUS_CONNECTION,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_BUS_TYPE,
g_param_spec_enum ("bus-type", "Bus Type", "Bus type", G_TYPE_BUS_TYPE, G_BUS_TYPE_NONE,
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_FLAGS,
g_param_spec_flags ("flags", "Flags", "Flags",
G_TYPE_DBUS_OBJECT_MANAGER_CLIENT_FLAGS, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_OBJECT_PATHS,
g_param_spec_boxed ("object-paths", "Object Paths", "Object Paths", G_TYPE_STRV,
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_NAME,
g_param_spec_string ("name", "Bus name", "Bus name", NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_NAME_OWNER,
g_param_spec_string ("name-owner", "Bus Name Owner", "The owner of the name", NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
}
bool wxGLCanvas::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name,
const int *attribList,
const wxPalette& palette)
{
#if wxUSE_PALETTE
wxASSERT_MSG( !palette.IsOk(), wxT("palettes not supported") );
#endif // wxUSE_PALETTE
wxUnusedVar(palette); // Unused when wxDEBUG_LEVEL==0
m_exposed = false;
m_noExpose = true;
m_nativeSizeEvent = true;
#ifdef __WXGTK3__
m_cairoPaintContext = NULL;
m_backgroundStyle = wxBG_STYLE_PAINT;
#endif
if ( !InitVisual(attribList) )
return false;
// watch for the "parent-set" signal on m_wxwindow so we can set colormap
// before m_wxwindow is realized (which will occur before
// wxWindow::Create() returns if parent is already visible)
unsigned sig_id = g_signal_lookup("parent-set", GTK_TYPE_WIDGET);
g_signal_add_emission_hook(sig_id, 0, parent_set_hook, this, NULL);
wxWindow::Create( parent, id, pos, size, style, name );
gtk_widget_set_double_buffered(m_wxwindow, false);
#if WXWIN_COMPATIBILITY_2_8
g_signal_connect(m_wxwindow, "realize", G_CALLBACK(gtk_glwindow_realized_callback), this);
#endif // WXWIN_COMPATIBILITY_2_8
#ifdef __WXGTK3__
g_signal_connect(m_wxwindow, "draw", G_CALLBACK(draw), this);
#else
g_signal_connect(m_wxwindow, "map", G_CALLBACK(gtk_glwindow_map_callback), this);
g_signal_connect(m_wxwindow, "expose_event", G_CALLBACK(gtk_glwindow_expose_callback), this);
#endif
g_signal_connect(m_widget, "size_allocate", G_CALLBACK(gtk_glcanvas_size_callback), this);
#if WXWIN_COMPATIBILITY_2_8
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (gtk_widget_get_realized(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
#endif // WXWIN_COMPATIBILITY_2_8
#ifndef __WXGTK3__
if (gtk_widget_get_mapped(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
#endif
return true;
}
static int
_signal_connect(ClipMachine *cm, gboolean after)
{
C_widget *cwid = _fetch_cw_arg(cm);
SignalTable *sig_table = NULL;
int ret=-1;
CHECKCWID(cwid,GTK_IS_OBJECT);
CHECKARG2(2,CHARACTER_t,NUMERIC_t);
CHECKARG2(3,PCODE_t,CCODE_t);
if (_clip_parinfo(cm,2) == CHARACTER_t)
{
//sig_table = _sig_table_by_name(cwid, _clip_parc(cm,2));
sig_table = _sig_table_by_name(cwid->type, _clip_parc(cm,2));
}
else
sig_table = _sig_table_by_id(cwid->type, _clip_parni(cm,2));
//sig_table = _sig_table_by_id(cwid, _clip_parni(cm,2));
if (sig_table && sig_table->sigfunction)
{
GtkSignalFunc sfunc = sig_table->sigfunction;
gchar *signame = sig_table->signame;
long sid = sig_table->sigid;
//int sigfound = gtk_signal_lookup(signame, GTK_WIDGET_TYPE(cwid->widget));
int sigfound = g_signal_lookup(signame, GTK_WIDGET_TYPE(cwid->widget));
int extra_sigfound = _extra_signal_lookup(signame, GTK_WIDGET_TYPE(cwid->widget));
C_signal *cs = 0;
if (sigfound || extra_sigfound || sid < 1000) /* sid<1000 - event */
{
if (!cwid->siglist)
{
cwid->siglist = NEW(C_signal);
cs = cwid->siglist;
}
else
{
for (cs = cwid->siglist; cs && cs->next; cs = cs->next);
cs->next = NEW(C_signal);
cs = cs->next;
}
cs->cw = cwid;
cs->signame = sig_table->signame;
cs->sigid = sig_table->sigid;
_clip_mclone(cm, &cs->cfunc, _clip_spar(cm,3));
}
if ( (sid == GTK_BUTTON_PRESS ||
sid == GTK_2BUTTON_PRESS || sid == GTK_3BUTTON_PRESS))
{
//cwid->event_connected = TRUE;
if (after)
ret = g_signal_connect_after(GTK_OBJECT(cwid->widget),
"button-press-event",GSF(sfunc),cs);
//ret = gtk_signal_connect_after(GTK_OBJECT(cwid->widget),
// "button-press-event",GSF(sfunc),cs);
else
ret = g_signal_connect(GTK_OBJECT(cwid->widget),
"button-press-event",GSF(sfunc),cs);
//ret = gtk_signal_connect(GTK_OBJECT(cwid->widget),
// "button-press-event",GSF(sfunc),cs);
}
if (sigfound && sid != GTK_BUTTON_PRESS)
{
if (after)
{
ret = g_signal_connect_after(GTK_OBJECT(cwid->widget),
signame,GSF(sfunc),cs);
//ret = gtk_signal_connect_after(GTK_OBJECT(cwid->widget),
// signame,GSF(sfunc),cs);
}
else
{
ret = g_signal_connect(GTK_OBJECT(cwid->widget),
signame,GSF(sfunc),cs);
//ret = gtk_signal_connect(GTK_OBJECT(cwid->widget),
// signame,GSF(sfunc),cs);
}
}
}
_clip_retni(cm,ret);
return 0;
err:
_clip_retni(cm,ret);
return 1;
}
