static void
position_action_menu (GtkMenu *menu,
gint *x,
gint *y,
gboolean *push_in,
gpointer user_data)
{
WnckWindow *win = (WnckWindow *) user_data;
decor_frame_t *frame = gwd_get_decor_frame (get_frame_type (win));
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
gint bx, by, width, height;
wnck_window_get_client_window_geometry (win, x, y, &width, &height);
if (d->decorated)
{
if ((*theme_get_button_position) (d, BUTTON_MENU, width, height,
&bx, &by, &width, &height))
*x = *x - frame->win_extents.left + bx;
}
gwd_decor_frame_unref (frame);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
{
GtkRequisition req;
gtk_widget_size_request (GTK_WIDGET (menu), &req);
*x = MAX (0, *x - req.width + width);
}
*push_in = TRUE;
}
/* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
return 1. In addition, set IS_THUMB depending on whether we
will return to ARM or Thumb code. Return 0 if it is not a
rt_sigreturn/sigreturn syscall. */
static int
arm_linux_sigreturn_return_addr (struct frame_info *frame,
unsigned long svc_number,
CORE_ADDR *pc, int *is_thumb)
{
/* Is this a sigreturn or rt_sigreturn syscall? */
if (svc_number == 119 || svc_number == 173)
{
if (get_frame_type (frame) == SIGTRAMP_FRAME)
{
ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
CORE_ADDR cpsr
= frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);
*is_thumb = (cpsr & t_bit) != 0;
*pc = frame_unwind_caller_pc (frame);
return 1;
}
}
return 0;
}
GdkFilterReturn
event_filter_func (GdkXEvent *gdkxevent,
GdkEvent *event,
gpointer data)
{
GdkDisplay *gdkdisplay;
XEvent *xevent = gdkxevent;
gulong xid = 0;
Window select = 0;
gdkdisplay = gdk_display_get_default ();
switch (xevent->type) {
case CreateNotify:
{
if (!wnck_window_get (xevent->xcreatewindow.window))
{
GdkWindow *toplevel = create_foreign_window (xevent->xcreatewindow.window);
if (toplevel)
{
gdk_window_set_events (toplevel,
gdk_window_get_events (toplevel) |
GDK_PROPERTY_CHANGE_MASK);
/* check if the window is a switcher and update accordingly */
if (get_window_prop (xevent->xcreatewindow.window, select_window_atom, &select))
update_switcher_window (xevent->xcreatewindow.window, select);
}
}
}
break;
case ButtonPress:
case ButtonRelease:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xbutton.window));
break;
case EnterNotify:
case LeaveNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xcrossing.window));
break;
case MotionNotify:
xid = (gulong)
g_hash_table_lookup (frame_table,
GINT_TO_POINTER (xevent->xmotion.window));
break;
case PropertyNotify:
if (xevent->xproperty.atom == frame_input_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_input_window_atom, &frame))
add_frame_window (win, frame, FALSE);
else
remove_frame_window (win);
}
}
}
if (xevent->xproperty.atom == frame_output_window_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
Window frame;
if (!get_window_prop (xid, select_window_atom, &select))
{
if (get_window_prop (xid, frame_output_window_atom, &frame))
add_frame_window (win, frame, TRUE);
else
remove_frame_window (win);
}
}
}
else if (xevent->xproperty.atom == compiz_shadow_info_atom ||
xevent->xproperty.atom == compiz_shadow_color_atom)
{
GdkScreen *g_screen = gdk_display_get_default_screen (gdkdisplay);
Window root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (g_screen));
WnckScreen *screen;
screen = wnck_screen_get_for_root (root);
if (screen)
{
if (gwd_process_decor_shadow_property_update ())
decorations_changed (screen);
}
}
else if (xevent->xproperty.atom == mwm_hints_atom)
{
WnckWindow *win;
xid = xevent->xproperty.window;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
gboolean decorated = FALSE;
/* Only decorations that are actually bound to windows can be decorated
* ignore cases where a broken application which shouldn't be decorated
* sets the decoration hint */
if (get_mwm_prop (xid) & (MWM_DECOR_ALL | MWM_DECOR_TITLE) && d->win)
decorated = TRUE;
if (decorated != d->decorated)
{
d->decorated = decorated;
if (decorated)
{
d->context = NULL;
d->width = d->height = 0;
d->frame = gwd_get_decor_frame (get_frame_type (win));
update_window_decoration_state (win);
update_window_decoration_actions (win);
update_window_decoration_icon (win);
request_update_window_decoration_size (win);
update_event_windows (win);
}
else
{
remove_frame_window (win);
}
}
}
}
else if (xevent->xproperty.atom == select_window_atom)
{
Window select;
if (get_window_prop (xevent->xproperty.window, select_window_atom, &select))
update_switcher_window (xevent->xproperty.window, select);
}
break;
case DestroyNotify:
g_hash_table_remove (frame_table,
GINT_TO_POINTER (xevent->xproperty.window));
break;
case ClientMessage:
if (xevent->xclient.message_type == toolkit_action_atom)
{
long action;
action = xevent->xclient.data.l[0];
if (action == toolkit_action_window_menu_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
action_menu_map (win,
xevent->xclient.data.l[2],
xevent->xclient.data.l[1]);
}
}
else if (action == toolkit_action_force_quit_dialog_atom)
{
WnckWindow *win;
win = wnck_window_get (xevent->xclient.window);
if (win)
{
if (xevent->xclient.data.l[2])
show_force_quit_dialog (win,
xevent->xclient.data.l[1]);
else
hide_force_quit_dialog (win);
}
}
}
else if (xevent->xclient.message_type == decor_request_atom)
{
WnckWindow *win = wnck_window_get (xevent->xclient.window);
if (win)
update_window_decoration_size (win);
}
default:
break;
}
if (xid)
{
WnckWindow *win;
win = wnck_window_get (xid);
if (win)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
if (d->decorated)
{
gint i, j;
event_callback cb = NULL;
Window w = xevent->xany.window;
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j)
if (d->event_windows[i][j].window == w)
cb = d->event_windows[i][j].callback;
if (!cb)
{
for (i = 0; i < BUTTON_NUM; ++i)
if (d->button_windows[i].window == w)
cb = d->button_windows[i].callback;
}
if (cb)
{
decor_event gtkwd_event;
decor_event_type gtkwd_type;
gtkwd_event.window = w;
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
if (xevent->type == ButtonPress)
gtkwd_type = GButtonPress;
else
gtkwd_type = GButtonRelease;
gtkwd_event.button = xevent->xbutton.button;
gtkwd_event.x = xevent->xbutton.x;
gtkwd_event.y = xevent->xbutton.y;
gtkwd_event.x_root = xevent->xbutton.x_root;
gtkwd_event.y_root = xevent->xbutton.y_root;
gtkwd_event.time = xevent->xbutton.time;
break;
case EnterNotify:
case LeaveNotify:
if (xevent->type == EnterNotify)
gtkwd_type = GEnterNotify;
else
gtkwd_type = GLeaveNotify;
gtkwd_event.x = xevent->xcrossing.x;
gtkwd_event.y = xevent->xcrossing.y;
gtkwd_event.x_root = xevent->xcrossing.x_root;
gtkwd_event.y_root = xevent->xcrossing.y_root;
gtkwd_event.time = xevent->xcrossing.time;
break;
default:
cb = NULL;
break;
}
if (cb)
(*cb) (win, >kwd_event, gtkwd_type);
}
}
}
}
return GDK_FILTER_CONTINUE;
}
static int
bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *keywords[] = { "frame", "internal", NULL };
struct finish_breakpoint_object *self_bpfinish =
(struct finish_breakpoint_object *) self;
PyObject *frame_obj = NULL;
int thread;
struct frame_info *frame = NULL; /* init for gcc -Wall */
struct frame_info *prev_frame = NULL;
struct frame_id frame_id;
PyObject *internal = NULL;
int internal_bp = 0;
CORE_ADDR pc;
struct symbol *function;
if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|OO", keywords,
&frame_obj, &internal))
return -1;
TRY
{
/* Default frame to newest frame if necessary. */
if (frame_obj == NULL)
frame = get_current_frame ();
else
frame = frame_object_to_frame_info (frame_obj);
if (frame == NULL)
{
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
else
{
prev_frame = get_prev_frame (frame);
if (prev_frame == 0)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" not "
"meaningful in the outermost "
"frame."));
}
else if (get_frame_type (prev_frame) == DUMMY_FRAME)
{
PyErr_SetString (PyExc_ValueError,
_("\"FinishBreakpoint\" cannot "
"be set on a dummy frame."));
}
else
{
frame_id = get_frame_id (prev_frame);
if (frame_id_eq (frame_id, null_frame_id))
PyErr_SetString (PyExc_ValueError,
_("Invalid ID for the `frame' object."));
}
}
}
CATCH (except, RETURN_MASK_ALL)
{
gdbpy_convert_exception (except);
return -1;
}
static int
arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
struct regcache *regs, struct displaced_step_closure *dsc)
{
CORE_ADDR from = dsc->insn_addr;
struct frame_info *frame;
unsigned int svc_number = displaced_read_reg (regs, from, 7);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: copying Linux svc insn %.8lx\n",
(unsigned long) insn);
frame = get_current_frame ();
/* Is this a sigreturn or rt_sigreturn syscall? Note: these are only useful
for EABI. */
if (svc_number == 119 || svc_number == 173)
{
if (get_frame_type (frame) == SIGTRAMP_FRAME)
{
CORE_ADDR return_to;
struct symtab_and_line sal;
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: found "
"sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
(unsigned long) get_frame_pc (frame));
return_to = frame_unwind_caller_pc (frame);
if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
"Setting momentary breakpoint.\n", (unsigned long) return_to);
gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
sal = find_pc_line (return_to, 0);
sal.pc = return_to;
sal.section = find_pc_overlay (return_to);
sal.explicit_pc = 1;
frame = get_prev_frame (frame);
if (frame)
{
inferior_thread ()->step_resume_breakpoint
= set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
bp_step_resume);
/* We need to make sure we actually insert the momentary
breakpoint set above. */
insert_breakpoints ();
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
"frame to set momentary breakpoint for "
"sigreturn/rt_sigreturn\n");
}
else if (debug_displaced)
fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
"SVC call not in signal trampoline frame\n");
}
/* Preparation: If we detect sigreturn, set momentary breakpoint at resume
location, else nothing.
Insn: unmodified svc.
Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
else leave pc alone. */
dsc->modinsn[0] = insn;
dsc->cleanup = &arm_linux_cleanup_svc;
/* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
instruction. */
dsc->wrote_to_pc = 1;
return 0;
}
