void moveresize_end(gboolean cancel) { ungrab_keyboard(); ungrab_pointer(); popup_hide(popup); if (!moving) { #ifdef SYNC /* turn off the alarm */ if (moveresize_alarm != None) { XSyncDestroyAlarm(obt_display, moveresize_alarm); moveresize_alarm = None; } if (sync_timer) g_source_remove(sync_timer); sync_timer = 0; #endif } /* don't use client_move() here, use the same width/height as we've been using during the move, otherwise we get different results when moving maximized windows between monitors of different sizes ! */ client_configure(moveresize_client, (cancel ? start_cx : cur_x), (cancel ? start_cy : cur_y), (cancel ? start_cw : cur_w), (cancel ? start_ch : cur_h), TRUE, TRUE, FALSE); /* restore the client's maximized state. do this after putting the window back in its original spot to minimize visible flicker */ if (cancel && (was_max_horz || was_max_vert)) { const gboolean h = moveresize_client->max_horz; const gboolean v = moveresize_client->max_vert; client_maximize(moveresize_client, TRUE, was_max_horz && was_max_vert ? 0 : (was_max_horz ? 1 : 2)); /* replace the premax values with the ones we had saved if the client doesn't have any already set */ if (was_max_horz && !h) { moveresize_client->pre_max_area.x = pre_max_area.x; moveresize_client->pre_max_area.width = pre_max_area.width; } if (was_max_vert && !v) { moveresize_client->pre_max_area.y = pre_max_area.y; moveresize_client->pre_max_area.height = pre_max_area.height; } } /* dont edge warp after its ended */ cancel_edge_warp(); moveresize_in_progress = FALSE; moveresize_client = NULL; }
void grab_shutdown(gboolean reconfig) { if (reconfig) return; while (ungrab_keyboard()); while (ungrab_pointer()); while (grab_server(FALSE)); }
static void menu_frame_hide(ObMenuFrame *self) { ObMenu *const menu = self->menu; GList *it = g_list_find(menu_frame_visible, self); gulong ignore_start; if (!it) return; if (menu->hide_func) menu->hide_func(self, menu->data); if (self->child) menu_frame_hide(self->child); if (self->parent) { remove_submenu_hide_timeout(self); self->parent->child = NULL; self->parent->child_entry = NULL; } self->parent = NULL; self->parent_entry = NULL; menu_frame_visible = g_list_delete_link(menu_frame_visible, it); if (menu_frame_visible == NULL) { /* last menu shown */ ungrab_pointer(); ungrab_keyboard(); } ignore_start = event_start_ignore_all_enters(); XUnmapWindow(obt_display, self->window); event_end_ignore_all_enters(ignore_start); menu_frame_free(self); if (menu->cleanup_func) menu->cleanup_func(menu, menu->data); }
static gboolean menu_frame_show(ObMenuFrame *self) { GList *it; /* determine if the underlying menu is already visible */ for (it = menu_frame_visible; it; it = g_list_next(it)) { ObMenuFrame *f = it->data; if (f->menu == self->menu) break; } if (!it) { if (self->menu->update_func) if (!self->menu->update_func(self, self->menu->data)) return FALSE; } if (menu_frame_visible == NULL) { /* no menus shown yet */ /* grab the pointer in such a way as to pass through "owner events" so that we can get enter/leave notifies in the menu. */ if (!grab_pointer(TRUE, FALSE, OB_CURSOR_POINTER)) return FALSE; if (!grab_keyboard()) { ungrab_pointer(); return FALSE; } } menu_frame_update(self); menu_frame_visible = g_list_prepend(menu_frame_visible, self); if (self->menu->show_func) self->menu->show_func(self, self->menu->data); return TRUE; }
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 }