EAPI Ecore_X_Sync_Alarm
ecore_x_sync_alarm_new(Ecore_X_Sync_Counter counter)
{
Ecore_X_Sync_Alarm alarm;
XSyncAlarmAttributes values;
XSyncValue init;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
XSyncIntToValue(&init, 0);
XSyncSetCounter(_ecore_x_disp, counter, init);
values.trigger.counter = counter;
values.trigger.value_type = XSyncAbsolute;
XSyncIntToValue(&values.trigger.wait_value, 1);
values.trigger.test_type = XSyncPositiveComparison;
XSyncIntToValue(&values.delta, 1);
values.events = True;
alarm = XSyncCreateAlarm(_ecore_x_disp,
XSyncCACounter |
XSyncCAValueType |
XSyncCAValue |
XSyncCATestType |
XSyncCADelta |
XSyncCAEvents,
&values);
ecore_x_sync();
return alarm;
} /* ecore_x_sync_alarm_new */
EAPI void
ecore_x_sync_counter_set(Ecore_X_Sync_Counter counter,
int val)
{
XSyncValue v;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
XSyncIntToValue(&v, val);
XSyncSetCounter(_ecore_x_disp, counter, v);
}
EAPI void
ecore_x_sync_counter_2_set(Ecore_X_Sync_Counter counter,
int val_hi,
unsigned int val_lo)
{
XSyncValue v;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
XSyncIntsToValue(&v, val_lo, val_hi);
XSyncSetCounter(_ecore_x_disp, counter, v);
}
static void
async_waiter_set_and_wait (AsyncWaiter *waiter)
{
Display *xdisplay = meta_get_display ()->xdisplay;
int wait_value = async_waiter_next_value (waiter);
XSyncValue sync_value;
XSyncIntToValue (&sync_value, wait_value);
XSyncSetCounter (xdisplay, waiter->counter, sync_value);
async_waiter_wait (waiter, wait_value);
}
static void
meta_sync_reset (MetaSync *self)
{
XSyncAlarmAttributes attrs;
int overflow;
g_return_if_fail (self->state == META_SYNC_STATE_DONE);
XSyncResetFence (self->xdisplay, self->xfence);
attrs.trigger.wait_value = self->next_counter_value;
XSyncChangeAlarm (self->xdisplay, self->xalarm, XSyncCAValue, &attrs);
XSyncSetCounter (self->xdisplay, self->xcounter, self->next_counter_value);
XSyncValueAdd (&self->next_counter_value,
self->next_counter_value,
SYNC_VALUE_ONE,
&overflow);
self->state = META_SYNC_STATE_RESET_PENDING;
}
void moveresize_start(ObClient *c, gint x, gint y, guint b, guint32 cnr)
{
ObCursor cur;
gboolean mv = (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE) ||
cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD));
gint up = 1;
gint left = 1;
if (moveresize_in_progress || !c->frame->visible ||
!(mv ?
(c->functions & OB_CLIENT_FUNC_MOVE) :
(c->functions & OB_CLIENT_FUNC_RESIZE)))
return;
if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT)) {
cur = OB_CURSOR_NORTHWEST;
up = left = -1;
}
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP)) {
cur = OB_CURSOR_NORTH;
up = -1;
}
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT)) {
cur = OB_CURSOR_NORTHEAST;
up = -1;
}
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT))
cur = OB_CURSOR_EAST;
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT))
cur = OB_CURSOR_SOUTHEAST;
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM))
cur = OB_CURSOR_SOUTH;
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT)) {
cur = OB_CURSOR_SOUTHWEST;
left = -1;
}
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT)) {
cur = OB_CURSOR_WEST;
left = -1;
}
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD))
cur = OB_CURSOR_SOUTHEAST;
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE))
cur = OB_CURSOR_MOVE;
else if (cnr == OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD))
cur = OB_CURSOR_MOVE;
else
g_assert_not_reached();
/* keep the pointer bounded to the screen for move/resize */
if (!grab_pointer(FALSE, TRUE, cur))
return;
if (!grab_keyboard()) {
ungrab_pointer();
return;
}
frame_end_iconify_animation(c->frame);
moving = mv;
moveresize_client = c;
start_cx = c->area.x;
start_cy = c->area.y;
start_cw = c->area.width;
start_ch = c->area.height;
/* these adjustments for the size_inc make resizing a terminal more
friendly. you essentially start the resize in the middle of the
increment instead of at 0, so you have to move half an increment
either way instead of a full increment one and 1 px the other. */
start_x = x - (mv ? 0 : left * c->size_inc.width / 2);
start_y = y - (mv ? 0 : up * c->size_inc.height / 2);
corner = cnr;
button = b;
key_resize_edge = -1;
/* default to not putting max back on cancel */
was_max_horz = was_max_vert = FALSE;
/*
have to change start_cx and start_cy if going to do this..
if (corner == prop_atoms.net_wm_moveresize_move_keyboard ||
corner == prop_atoms.net_wm_moveresize_size_keyboard)
XWarpPointer(ob_display, None, c->window, 0, 0, 0, 0,
c->area.width / 2, c->area.height / 2);
*/
cur_x = start_cx;
cur_y = start_cy;
cur_w = start_cw;
cur_h = start_ch;
moveresize_in_progress = TRUE;
waiting_for_sync = 0;
#ifdef SYNC
if (config_resize_redraw && !moving && obt_display_extension_sync &&
moveresize_client->sync_request && moveresize_client->sync_counter &&
!moveresize_client->not_responding)
{
/* Initialize values for the resize syncing, and create an alarm for
the client's xsync counter */
XSyncValue val;
XSyncAlarmAttributes aa;
/* set the counter to an initial value */
XSyncIntToValue(&val, 0);
XSyncSetCounter(obt_display, moveresize_client->sync_counter, val);
/* this will be incremented when we tell the client what we're
looking for */
moveresize_client->sync_counter_value = 0;
/* the next sequence we're waiting for with the alarm */
XSyncIntToValue(&val, 1);
/* set an alarm on the counter */
aa.trigger.counter = moveresize_client->sync_counter;
aa.trigger.wait_value = val;
aa.trigger.value_type = XSyncAbsolute;
aa.trigger.test_type = XSyncPositiveTransition;
aa.events = True;
XSyncIntToValue(&aa.delta, 1);
moveresize_alarm = XSyncCreateAlarm(obt_display,
XSyncCACounter |
XSyncCAValue |
XSyncCAValueType |
XSyncCATestType |
XSyncCADelta |
XSyncCAEvents,
&aa);
}
#endif
}
