Julian Eisel
b2ee1770d4
The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
868 lines
25 KiB
C
868 lines
25 KiB
C
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2008 Blender Foundation.
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/** \file
|
|
* \ingroup edinterface
|
|
*
|
|
* PopUp Region (Generic)
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DNA_userdef_types.h"
|
|
|
|
#include "BLI_math.h"
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_rect.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BKE_context.h"
|
|
#include "BKE_screen.h"
|
|
|
|
#include "WM_api.h"
|
|
#include "WM_types.h"
|
|
|
|
#include "UI_interface.h"
|
|
|
|
#include "ED_screen.h"
|
|
|
|
#include "interface_intern.h"
|
|
#include "interface_regions_intern.h"
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Utility Functions
|
|
* \{ */
|
|
|
|
/**
|
|
* Translate any popup regions (so we can drag them).
|
|
*/
|
|
void ui_popup_translate(ARegion *region, const int mdiff[2])
|
|
{
|
|
uiBlock *block;
|
|
|
|
BLI_rcti_translate(®ion->winrct, UNPACK2(mdiff));
|
|
|
|
ED_region_update_rect(region);
|
|
|
|
ED_region_tag_redraw(region);
|
|
|
|
/* update blocks */
|
|
for (block = region->uiblocks.first; block; block = block->next) {
|
|
uiPopupBlockHandle *handle = block->handle;
|
|
/* Make empty, will be initialized on next use, see T60608. */
|
|
BLI_rctf_init(&handle->prev_block_rect, 0, 0, 0, 0);
|
|
|
|
uiSafetyRct *saferct;
|
|
for (saferct = block->saferct.first; saferct; saferct = saferct->next) {
|
|
BLI_rctf_translate(&saferct->parent, UNPACK2(mdiff));
|
|
BLI_rctf_translate(&saferct->safety, UNPACK2(mdiff));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* position block relative to but, result is in window space */
|
|
static void ui_popup_block_position(wmWindow *window,
|
|
ARegion *butregion,
|
|
uiBut *but,
|
|
uiBlock *block)
|
|
{
|
|
uiPopupBlockHandle *handle = block->handle;
|
|
|
|
/* Compute button position in window coordinates using the source
|
|
* button region/block, to position the popup attached to it. */
|
|
rctf butrct;
|
|
|
|
if (!handle->refresh) {
|
|
ui_block_to_window_rctf(butregion, but->block, &butrct, &but->rect);
|
|
|
|
/* widget_roundbox_set has this correction too, keep in sync */
|
|
if (but->type != UI_BTYPE_PULLDOWN) {
|
|
if (but->drawflag & UI_BUT_ALIGN_TOP) {
|
|
butrct.ymax += U.pixelsize;
|
|
}
|
|
if (but->drawflag & UI_BUT_ALIGN_LEFT) {
|
|
butrct.xmin -= U.pixelsize;
|
|
}
|
|
}
|
|
|
|
handle->prev_butrct = butrct;
|
|
}
|
|
else {
|
|
/* For refreshes, keep same button position so popup doesn't move. */
|
|
butrct = handle->prev_butrct;
|
|
}
|
|
|
|
/* Compute block size in window space, based on buttons contained in it. */
|
|
if (block->rect.xmin == 0.0f && block->rect.xmax == 0.0f) {
|
|
if (block->buttons.first) {
|
|
BLI_rctf_init_minmax(&block->rect);
|
|
|
|
for (uiBut *bt = block->buttons.first; bt; bt = bt->next) {
|
|
if (block->content_hints & UI_BLOCK_CONTAINS_SUBMENU_BUT) {
|
|
bt->rect.xmax += UI_MENU_SUBMENU_PADDING;
|
|
}
|
|
BLI_rctf_union(&block->rect, &bt->rect);
|
|
}
|
|
}
|
|
else {
|
|
/* we're nice and allow empty blocks too */
|
|
block->rect.xmin = block->rect.ymin = 0;
|
|
block->rect.xmax = block->rect.ymax = 20;
|
|
}
|
|
}
|
|
|
|
ui_block_to_window_rctf(butregion, but->block, &block->rect, &block->rect);
|
|
|
|
/* Compute direction relative to button, based on available space. */
|
|
const int size_x = BLI_rctf_size_x(&block->rect) + 0.2f * UI_UNIT_X; /* 4 for shadow */
|
|
const int size_y = BLI_rctf_size_y(&block->rect) + 0.2f * UI_UNIT_Y;
|
|
const int center_x = (block->direction & UI_DIR_CENTER_X) ? size_x / 2 : 0;
|
|
const int center_y = (block->direction & UI_DIR_CENTER_Y) ? size_y / 2 : 0;
|
|
|
|
short dir1 = 0, dir2 = 0;
|
|
|
|
if (!handle->refresh) {
|
|
bool left = 0, right = 0, top = 0, down = 0;
|
|
|
|
const int win_x = WM_window_pixels_x(window);
|
|
const int win_y = WM_window_pixels_y(window);
|
|
|
|
/* Take into account maximum size so we don't have to flip on refresh. */
|
|
const float max_size_x = max_ff(size_x, handle->max_size_x);
|
|
const float max_size_y = max_ff(size_y, handle->max_size_y);
|
|
|
|
/* check if there's space at all */
|
|
if (butrct.xmin - max_size_x + center_x > 0.0f) {
|
|
left = 1;
|
|
}
|
|
if (butrct.xmax + max_size_x - center_x < win_x) {
|
|
right = 1;
|
|
}
|
|
if (butrct.ymin - max_size_y + center_y > 0.0f) {
|
|
down = 1;
|
|
}
|
|
if (butrct.ymax + max_size_y - center_y < win_y) {
|
|
top = 1;
|
|
}
|
|
|
|
if (top == 0 && down == 0) {
|
|
if (butrct.ymin - max_size_y < win_y - butrct.ymax - max_size_y) {
|
|
top = 1;
|
|
}
|
|
else {
|
|
down = 1;
|
|
}
|
|
}
|
|
|
|
dir1 = (block->direction & UI_DIR_ALL);
|
|
|
|
/* Secondary directions. */
|
|
if (dir1 & (UI_DIR_UP | UI_DIR_DOWN)) {
|
|
if (dir1 & UI_DIR_LEFT) {
|
|
dir2 = UI_DIR_LEFT;
|
|
}
|
|
else if (dir1 & UI_DIR_RIGHT) {
|
|
dir2 = UI_DIR_RIGHT;
|
|
}
|
|
dir1 &= (UI_DIR_UP | UI_DIR_DOWN);
|
|
}
|
|
|
|
if ((dir2 == 0) && (dir1 == UI_DIR_LEFT || dir1 == UI_DIR_RIGHT)) {
|
|
dir2 = UI_DIR_DOWN;
|
|
}
|
|
if ((dir2 == 0) && (dir1 == UI_DIR_UP || dir1 == UI_DIR_DOWN)) {
|
|
dir2 = UI_DIR_LEFT;
|
|
}
|
|
|
|
/* no space at all? don't change */
|
|
if (left || right) {
|
|
if (dir1 == UI_DIR_LEFT && left == 0) {
|
|
dir1 = UI_DIR_RIGHT;
|
|
}
|
|
if (dir1 == UI_DIR_RIGHT && right == 0) {
|
|
dir1 = UI_DIR_LEFT;
|
|
}
|
|
/* this is aligning, not append! */
|
|
if (dir2 == UI_DIR_LEFT && right == 0) {
|
|
dir2 = UI_DIR_RIGHT;
|
|
}
|
|
if (dir2 == UI_DIR_RIGHT && left == 0) {
|
|
dir2 = UI_DIR_LEFT;
|
|
}
|
|
}
|
|
if (down || top) {
|
|
if (dir1 == UI_DIR_UP && top == 0) {
|
|
dir1 = UI_DIR_DOWN;
|
|
}
|
|
if (dir1 == UI_DIR_DOWN && down == 0) {
|
|
dir1 = UI_DIR_UP;
|
|
}
|
|
BLI_assert(dir2 != UI_DIR_UP);
|
|
// if (dir2 == UI_DIR_UP && top == 0) { dir2 = UI_DIR_DOWN; }
|
|
if (dir2 == UI_DIR_DOWN && down == 0) {
|
|
dir2 = UI_DIR_UP;
|
|
}
|
|
}
|
|
|
|
handle->prev_dir1 = dir1;
|
|
handle->prev_dir2 = dir2;
|
|
}
|
|
else {
|
|
/* For refreshes, keep same popup direct so popup doesn't move
|
|
* to a totally different position while editing in it. */
|
|
dir1 = handle->prev_dir1;
|
|
dir2 = handle->prev_dir2;
|
|
}
|
|
|
|
/* Compute offset based on direction. */
|
|
float offset_x = 0, offset_y = 0;
|
|
|
|
/* Ensure buttons don't come between the parent button and the popup, see: T63566. */
|
|
const float offset_overlap = max_ff(U.pixelsize, 1.0f);
|
|
|
|
if (dir1 == UI_DIR_LEFT) {
|
|
offset_x = (butrct.xmin - block->rect.xmax) + offset_overlap;
|
|
if (dir2 == UI_DIR_UP) {
|
|
offset_y = butrct.ymin - block->rect.ymin - center_y - UI_MENU_PADDING;
|
|
}
|
|
else {
|
|
offset_y = butrct.ymax - block->rect.ymax + center_y + UI_MENU_PADDING;
|
|
}
|
|
}
|
|
else if (dir1 == UI_DIR_RIGHT) {
|
|
offset_x = (butrct.xmax - block->rect.xmin) - offset_overlap;
|
|
if (dir2 == UI_DIR_UP) {
|
|
offset_y = butrct.ymin - block->rect.ymin - center_y - UI_MENU_PADDING;
|
|
}
|
|
else {
|
|
offset_y = butrct.ymax - block->rect.ymax + center_y + UI_MENU_PADDING;
|
|
}
|
|
}
|
|
else if (dir1 == UI_DIR_UP) {
|
|
offset_y = (butrct.ymax - block->rect.ymin) - offset_overlap;
|
|
if (dir2 == UI_DIR_RIGHT) {
|
|
offset_x = butrct.xmax - block->rect.xmax + center_x;
|
|
}
|
|
else {
|
|
offset_x = butrct.xmin - block->rect.xmin - center_x;
|
|
}
|
|
/* changed direction? */
|
|
if ((dir1 & block->direction) == 0) {
|
|
/* TODO: still do */
|
|
UI_block_order_flip(block);
|
|
}
|
|
}
|
|
else if (dir1 == UI_DIR_DOWN) {
|
|
offset_y = (butrct.ymin - block->rect.ymax) + offset_overlap;
|
|
if (dir2 == UI_DIR_RIGHT) {
|
|
offset_x = butrct.xmax - block->rect.xmax + center_x;
|
|
}
|
|
else {
|
|
offset_x = butrct.xmin - block->rect.xmin - center_x;
|
|
}
|
|
/* changed direction? */
|
|
if ((dir1 & block->direction) == 0) {
|
|
/* TODO: still do */
|
|
UI_block_order_flip(block);
|
|
}
|
|
}
|
|
|
|
/* Center over popovers for eg. */
|
|
if (block->direction & UI_DIR_CENTER_X) {
|
|
offset_x += BLI_rctf_size_x(&butrct) / ((dir2 == UI_DIR_LEFT) ? 2 : -2);
|
|
}
|
|
|
|
/* Apply offset, buttons in window coords. */
|
|
for (uiBut *bt = block->buttons.first; bt; bt = bt->next) {
|
|
ui_block_to_window_rctf(butregion, but->block, &bt->rect, &bt->rect);
|
|
|
|
BLI_rctf_translate(&bt->rect, offset_x, offset_y);
|
|
|
|
/* ui_but_update recalculates drawstring size in pixels */
|
|
ui_but_update(bt);
|
|
}
|
|
|
|
BLI_rctf_translate(&block->rect, offset_x, offset_y);
|
|
|
|
/* Safety calculus. */
|
|
{
|
|
const float midx = BLI_rctf_cent_x(&butrct);
|
|
const float midy = BLI_rctf_cent_y(&butrct);
|
|
|
|
/* when you are outside parent button, safety there should be smaller */
|
|
|
|
/* parent button to left */
|
|
if (midx < block->rect.xmin) {
|
|
block->safety.xmin = block->rect.xmin - 3;
|
|
}
|
|
else {
|
|
block->safety.xmin = block->rect.xmin - 40;
|
|
}
|
|
/* parent button to right */
|
|
if (midx > block->rect.xmax) {
|
|
block->safety.xmax = block->rect.xmax + 3;
|
|
}
|
|
else {
|
|
block->safety.xmax = block->rect.xmax + 40;
|
|
}
|
|
|
|
/* parent button on bottom */
|
|
if (midy < block->rect.ymin) {
|
|
block->safety.ymin = block->rect.ymin - 3;
|
|
}
|
|
else {
|
|
block->safety.ymin = block->rect.ymin - 40;
|
|
}
|
|
/* parent button on top */
|
|
if (midy > block->rect.ymax) {
|
|
block->safety.ymax = block->rect.ymax + 3;
|
|
}
|
|
else {
|
|
block->safety.ymax = block->rect.ymax + 40;
|
|
}
|
|
|
|
/* exception for switched pulldowns... */
|
|
if (dir1 && (dir1 & block->direction) == 0) {
|
|
if (dir2 == UI_DIR_RIGHT) {
|
|
block->safety.xmax = block->rect.xmax + 3;
|
|
}
|
|
if (dir2 == UI_DIR_LEFT) {
|
|
block->safety.xmin = block->rect.xmin - 3;
|
|
}
|
|
}
|
|
block->direction = dir1;
|
|
}
|
|
|
|
/* keep a list of these, needed for pulldown menus */
|
|
uiSafetyRct *saferct = MEM_callocN(sizeof(uiSafetyRct), "uiSafetyRct");
|
|
saferct->parent = butrct;
|
|
saferct->safety = block->safety;
|
|
BLI_freelistN(&block->saferct);
|
|
BLI_duplicatelist(&block->saferct, &but->block->saferct);
|
|
BLI_addhead(&block->saferct, saferct);
|
|
}
|
|
|
|
/** \} */
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Menu Block Creation
|
|
* \{ */
|
|
|
|
static void ui_block_region_refresh(const bContext *C, ARegion *region)
|
|
{
|
|
ScrArea *ctx_area = CTX_wm_area(C);
|
|
ARegion *ctx_region = CTX_wm_region(C);
|
|
uiBlock *block;
|
|
|
|
if (region->do_draw & RGN_REFRESH_UI) {
|
|
ScrArea *handle_ctx_area;
|
|
ARegion *handle_ctx_region;
|
|
uiBlock *block_next;
|
|
|
|
region->do_draw &= ~RGN_REFRESH_UI;
|
|
for (block = region->uiblocks.first; block; block = block_next) {
|
|
block_next = block->next;
|
|
uiPopupBlockHandle *handle = block->handle;
|
|
|
|
if (handle->can_refresh) {
|
|
handle_ctx_area = handle->ctx_area;
|
|
handle_ctx_region = handle->ctx_region;
|
|
|
|
if (handle_ctx_area) {
|
|
CTX_wm_area_set((bContext *)C, handle_ctx_area);
|
|
}
|
|
if (handle_ctx_region) {
|
|
CTX_wm_region_set((bContext *)C, handle_ctx_region);
|
|
}
|
|
|
|
uiBut *but = handle->popup_create_vars.but;
|
|
ARegion *butregion = handle->popup_create_vars.butregion;
|
|
ui_popup_block_refresh((bContext *)C, handle, butregion, but);
|
|
}
|
|
}
|
|
}
|
|
|
|
CTX_wm_area_set((bContext *)C, ctx_area);
|
|
CTX_wm_region_set((bContext *)C, ctx_region);
|
|
}
|
|
|
|
static void ui_block_region_draw(const bContext *C, ARegion *region)
|
|
{
|
|
uiBlock *block;
|
|
|
|
for (block = region->uiblocks.first; block; block = block->next) {
|
|
UI_block_draw(C, block);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Use to refresh centered popups on screen resizing (for splash).
|
|
*/
|
|
static void ui_block_region_popup_window_listener(wmWindow *UNUSED(win),
|
|
ScrArea *UNUSED(sa),
|
|
ARegion *region,
|
|
wmNotifier *wmn,
|
|
const Scene *UNUSED(scene))
|
|
{
|
|
switch (wmn->category) {
|
|
case NC_WINDOW: {
|
|
switch (wmn->action) {
|
|
case NA_EDITED: {
|
|
/* window resize */
|
|
ED_region_tag_refresh_ui(region);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ui_popup_block_clip(wmWindow *window, uiBlock *block)
|
|
{
|
|
uiBut *bt;
|
|
const float xmin_orig = block->rect.xmin;
|
|
const int margin = UI_SCREEN_MARGIN;
|
|
int winx, winy;
|
|
|
|
if (block->flag & UI_BLOCK_NO_WIN_CLIP) {
|
|
return;
|
|
}
|
|
|
|
winx = WM_window_pixels_x(window);
|
|
winy = WM_window_pixels_y(window);
|
|
|
|
/* shift to left if outside of view */
|
|
if (block->rect.xmax > winx - margin) {
|
|
const float xofs = winx - margin - block->rect.xmax;
|
|
block->rect.xmin += xofs;
|
|
block->rect.xmax += xofs;
|
|
}
|
|
/* shift menus to right if outside of view */
|
|
if (block->rect.xmin < margin) {
|
|
const float xofs = (margin - block->rect.xmin);
|
|
block->rect.xmin += xofs;
|
|
block->rect.xmax += xofs;
|
|
}
|
|
|
|
if (block->rect.ymin < margin) {
|
|
block->rect.ymin = margin;
|
|
}
|
|
if (block->rect.ymax > winy - UI_POPUP_MENU_TOP) {
|
|
block->rect.ymax = winy - UI_POPUP_MENU_TOP;
|
|
}
|
|
|
|
/* ensure menu items draw inside left/right boundary */
|
|
const float xofs = block->rect.xmin - xmin_orig;
|
|
for (bt = block->buttons.first; bt; bt = bt->next) {
|
|
bt->rect.xmin += xofs;
|
|
bt->rect.xmax += xofs;
|
|
}
|
|
}
|
|
|
|
void ui_popup_block_scrolltest(uiBlock *block)
|
|
{
|
|
uiBut *bt;
|
|
|
|
block->flag &= ~(UI_BLOCK_CLIPBOTTOM | UI_BLOCK_CLIPTOP);
|
|
|
|
for (bt = block->buttons.first; bt; bt = bt->next) {
|
|
bt->flag &= ~UI_SCROLLED;
|
|
}
|
|
|
|
if (block->buttons.first == block->buttons.last) {
|
|
return;
|
|
}
|
|
|
|
/* mark buttons that are outside boundary */
|
|
for (bt = block->buttons.first; bt; bt = bt->next) {
|
|
if (bt->rect.ymin < block->rect.ymin) {
|
|
bt->flag |= UI_SCROLLED;
|
|
block->flag |= UI_BLOCK_CLIPBOTTOM;
|
|
}
|
|
if (bt->rect.ymax > block->rect.ymax) {
|
|
bt->flag |= UI_SCROLLED;
|
|
block->flag |= UI_BLOCK_CLIPTOP;
|
|
}
|
|
}
|
|
|
|
/* mark buttons overlapping arrows, if we have them */
|
|
for (bt = block->buttons.first; bt; bt = bt->next) {
|
|
if (block->flag & UI_BLOCK_CLIPBOTTOM) {
|
|
if (bt->rect.ymin < block->rect.ymin + UI_MENU_SCROLL_ARROW) {
|
|
bt->flag |= UI_SCROLLED;
|
|
}
|
|
}
|
|
if (block->flag & UI_BLOCK_CLIPTOP) {
|
|
if (bt->rect.ymax > block->rect.ymax - UI_MENU_SCROLL_ARROW) {
|
|
bt->flag |= UI_SCROLLED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ui_popup_block_remove(bContext *C, uiPopupBlockHandle *handle)
|
|
{
|
|
wmWindow *ctx_win = CTX_wm_window(C);
|
|
ScrArea *ctx_sa = CTX_wm_area(C);
|
|
ARegion *ctx_ar = CTX_wm_region(C);
|
|
|
|
wmWindowManager *wm = CTX_wm_manager(C);
|
|
wmWindow *win = ctx_win;
|
|
bScreen *sc = CTX_wm_screen(C);
|
|
|
|
/* There may actually be a different window active than the one showing the popup, so lookup real
|
|
* one. */
|
|
if (BLI_findindex(&sc->regionbase, handle->region) == -1) {
|
|
for (win = wm->windows.first; win; win = win->next) {
|
|
sc = WM_window_get_active_screen(win);
|
|
if (BLI_findindex(&sc->regionbase, handle->region) != -1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
BLI_assert(win && sc);
|
|
|
|
CTX_wm_window_set(C, win);
|
|
ui_region_temp_remove(C, sc, handle->region);
|
|
|
|
/* Reset context (area and region were NULL'ed when chaning context window). */
|
|
CTX_wm_window_set(C, ctx_win);
|
|
CTX_wm_area_set(C, ctx_sa);
|
|
CTX_wm_region_set(C, ctx_ar);
|
|
|
|
/* reset to region cursor (only if there's not another menu open) */
|
|
if (BLI_listbase_is_empty(&sc->regionbase)) {
|
|
win->tag_cursor_refresh = true;
|
|
}
|
|
|
|
if (handle->scrolltimer) {
|
|
WM_event_remove_timer(wm, win, handle->scrolltimer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called for creating new popups and refreshing existing ones.
|
|
*/
|
|
uiBlock *ui_popup_block_refresh(bContext *C,
|
|
uiPopupBlockHandle *handle,
|
|
ARegion *butregion,
|
|
uiBut *but)
|
|
{
|
|
const int margin = UI_POPUP_MARGIN;
|
|
wmWindow *window = CTX_wm_window(C);
|
|
ARegion *region = handle->region;
|
|
|
|
uiBlockCreateFunc create_func = handle->popup_create_vars.create_func;
|
|
uiBlockHandleCreateFunc handle_create_func = handle->popup_create_vars.handle_create_func;
|
|
void *arg = handle->popup_create_vars.arg;
|
|
|
|
uiBlock *block_old = region->uiblocks.first;
|
|
uiBlock *block;
|
|
|
|
handle->refresh = (block_old != NULL);
|
|
|
|
BLI_assert(!handle->refresh || handle->can_refresh);
|
|
|
|
#ifdef DEBUG
|
|
wmEvent *event_back = window->eventstate;
|
|
#endif
|
|
|
|
/* create ui block */
|
|
if (create_func) {
|
|
block = create_func(C, region, arg);
|
|
}
|
|
else {
|
|
block = handle_create_func(C, handle, arg);
|
|
}
|
|
|
|
/* callbacks _must_ leave this for us, otherwise we can't call UI_block_update_from_old */
|
|
BLI_assert(!block->endblock);
|
|
|
|
/* ensure we don't use mouse coords here! */
|
|
#ifdef DEBUG
|
|
window->eventstate = NULL;
|
|
#endif
|
|
|
|
if (block->handle) {
|
|
memcpy(block->handle, handle, sizeof(uiPopupBlockHandle));
|
|
MEM_freeN(handle);
|
|
handle = block->handle;
|
|
}
|
|
else {
|
|
block->handle = handle;
|
|
}
|
|
|
|
region->regiondata = handle;
|
|
|
|
/* set UI_BLOCK_NUMSELECT before UI_block_end() so we get alphanumeric keys assigned */
|
|
if (but == NULL) {
|
|
block->flag |= UI_BLOCK_POPUP;
|
|
}
|
|
|
|
block->flag |= UI_BLOCK_LOOP;
|
|
UI_block_theme_style_set(block, UI_BLOCK_THEME_STYLE_POPUP);
|
|
|
|
/* defer this until blocks are translated (below) */
|
|
block->oldblock = NULL;
|
|
|
|
if (!block->endblock) {
|
|
UI_block_end_ex(
|
|
C, block, handle->popup_create_vars.event_xy, handle->popup_create_vars.event_xy);
|
|
}
|
|
|
|
/* if this is being created from a button */
|
|
if (but) {
|
|
block->aspect = but->block->aspect;
|
|
ui_popup_block_position(window, butregion, but, block);
|
|
handle->direction = block->direction;
|
|
}
|
|
else {
|
|
uiSafetyRct *saferct;
|
|
/* keep a list of these, needed for pulldown menus */
|
|
saferct = MEM_callocN(sizeof(uiSafetyRct), "uiSafetyRct");
|
|
saferct->safety = block->safety;
|
|
BLI_addhead(&block->saferct, saferct);
|
|
}
|
|
|
|
if (block->flag & UI_BLOCK_RADIAL) {
|
|
int win_width = UI_SCREEN_MARGIN;
|
|
int winx, winy;
|
|
|
|
int x_offset = 0, y_offset = 0;
|
|
|
|
winx = WM_window_pixels_x(window);
|
|
winy = WM_window_pixels_y(window);
|
|
|
|
copy_v2_v2(block->pie_data.pie_center_init, block->pie_data.pie_center_spawned);
|
|
|
|
/* only try translation if area is large enough */
|
|
if (BLI_rctf_size_x(&block->rect) < winx - (2.0f * win_width)) {
|
|
if (block->rect.xmin < win_width) {
|
|
x_offset += win_width - block->rect.xmin;
|
|
}
|
|
if (block->rect.xmax > winx - win_width) {
|
|
x_offset += winx - win_width - block->rect.xmax;
|
|
}
|
|
}
|
|
|
|
if (BLI_rctf_size_y(&block->rect) < winy - (2.0f * win_width)) {
|
|
if (block->rect.ymin < win_width) {
|
|
y_offset += win_width - block->rect.ymin;
|
|
}
|
|
if (block->rect.ymax > winy - win_width) {
|
|
y_offset += winy - win_width - block->rect.ymax;
|
|
}
|
|
}
|
|
/* if we are offsetting set up initial data for timeout functionality */
|
|
|
|
if ((x_offset != 0) || (y_offset != 0)) {
|
|
block->pie_data.pie_center_spawned[0] += x_offset;
|
|
block->pie_data.pie_center_spawned[1] += y_offset;
|
|
|
|
UI_block_translate(block, x_offset, y_offset);
|
|
|
|
if (U.pie_initial_timeout > 0) {
|
|
block->pie_data.flags |= UI_PIE_INITIAL_DIRECTION;
|
|
}
|
|
}
|
|
|
|
region->winrct.xmin = 0;
|
|
region->winrct.xmax = winx;
|
|
region->winrct.ymin = 0;
|
|
region->winrct.ymax = winy;
|
|
|
|
ui_block_calc_pie_segment(block, block->pie_data.pie_center_init);
|
|
|
|
/* lastly set the buttons at the center of the pie menu, ready for animation */
|
|
if (U.pie_animation_timeout > 0) {
|
|
for (uiBut *but_iter = block->buttons.first; but_iter; but_iter = but_iter->next) {
|
|
if (but_iter->pie_dir != UI_RADIAL_NONE) {
|
|
BLI_rctf_recenter(&but_iter->rect, UNPACK2(block->pie_data.pie_center_spawned));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
/* Add an offset to draw the popover arrow. */
|
|
if ((block->flag & UI_BLOCK_POPOVER) && ELEM(block->direction, UI_DIR_UP, UI_DIR_DOWN)) {
|
|
/* Keep sync with 'ui_draw_popover_back_impl'. */
|
|
const float unit_size = U.widget_unit / block->aspect;
|
|
const float unit_half = unit_size * (block->direction == UI_DIR_DOWN ? 0.5 : -0.5);
|
|
|
|
UI_block_translate(block, 0, -unit_half);
|
|
}
|
|
|
|
/* clip block with window boundary */
|
|
ui_popup_block_clip(window, block);
|
|
|
|
/* Avoid menu moving down and losing cursor focus by keeping it at
|
|
* the same height. */
|
|
if (handle->refresh && handle->prev_block_rect.ymax > block->rect.ymax) {
|
|
if (block->bounds_type != UI_BLOCK_BOUNDS_POPUP_CENTER) {
|
|
float offset = handle->prev_block_rect.ymax - block->rect.ymax;
|
|
UI_block_translate(block, 0, offset);
|
|
block->rect.ymin = handle->prev_block_rect.ymin;
|
|
}
|
|
}
|
|
|
|
handle->prev_block_rect = block->rect;
|
|
|
|
/* the block and buttons were positioned in window space as in 2.4x, now
|
|
* these menu blocks are regions so we bring it back to region space.
|
|
* additionally we add some padding for the menu shadow or rounded menus */
|
|
region->winrct.xmin = block->rect.xmin - margin;
|
|
region->winrct.xmax = block->rect.xmax + margin;
|
|
region->winrct.ymin = block->rect.ymin - margin;
|
|
region->winrct.ymax = block->rect.ymax + UI_POPUP_MENU_TOP;
|
|
|
|
UI_block_translate(block, -region->winrct.xmin, -region->winrct.ymin);
|
|
|
|
/* apply scroll offset */
|
|
if (handle->scrolloffset != 0.0f) {
|
|
for (uiBut *bt = block->buttons.first; bt; bt = bt->next) {
|
|
bt->rect.ymin += handle->scrolloffset;
|
|
bt->rect.ymax += handle->scrolloffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (block_old) {
|
|
block->oldblock = block_old;
|
|
UI_block_update_from_old(C, block);
|
|
UI_blocklist_free_inactive(C, ®ion->uiblocks);
|
|
}
|
|
|
|
/* checks which buttons are visible, sets flags to prevent draw (do after region init) */
|
|
ui_popup_block_scrolltest(block);
|
|
|
|
/* adds subwindow */
|
|
ED_region_floating_initialize(region);
|
|
|
|
/* get winmat now that we actually have the subwindow */
|
|
wmGetProjectionMatrix(block->winmat, ®ion->winrct);
|
|
|
|
/* notify change and redraw */
|
|
ED_region_tag_redraw(region);
|
|
|
|
ED_region_update_rect(region);
|
|
|
|
#ifdef DEBUG
|
|
window->eventstate = event_back;
|
|
#endif
|
|
|
|
return block;
|
|
}
|
|
|
|
uiPopupBlockHandle *ui_popup_block_create(bContext *C,
|
|
ARegion *butregion,
|
|
uiBut *but,
|
|
uiBlockCreateFunc create_func,
|
|
uiBlockHandleCreateFunc handle_create_func,
|
|
void *arg,
|
|
void (*arg_free)(void *arg))
|
|
{
|
|
wmWindow *window = CTX_wm_window(C);
|
|
uiBut *activebut = UI_context_active_but_get(C);
|
|
static ARegionType type;
|
|
ARegion *region;
|
|
uiBlock *block;
|
|
uiPopupBlockHandle *handle;
|
|
|
|
/* disable tooltips from buttons below */
|
|
if (activebut) {
|
|
UI_but_tooltip_timer_remove(C, activebut);
|
|
}
|
|
/* standard cursor by default */
|
|
WM_cursor_set(window, WM_CURSOR_DEFAULT);
|
|
|
|
/* create handle */
|
|
handle = MEM_callocN(sizeof(uiPopupBlockHandle), "uiPopupBlockHandle");
|
|
|
|
/* store context for operator */
|
|
handle->ctx_area = CTX_wm_area(C);
|
|
handle->ctx_region = CTX_wm_region(C);
|
|
|
|
/* store vars to refresh popup (RGN_REFRESH_UI) */
|
|
handle->popup_create_vars.create_func = create_func;
|
|
handle->popup_create_vars.handle_create_func = handle_create_func;
|
|
handle->popup_create_vars.arg = arg;
|
|
handle->popup_create_vars.arg_free = arg_free;
|
|
handle->popup_create_vars.but = but;
|
|
handle->popup_create_vars.butregion = but ? butregion : NULL;
|
|
copy_v2_v2_int(handle->popup_create_vars.event_xy, &window->eventstate->x);
|
|
|
|
/* don't allow by default, only if popup type explicitly supports it */
|
|
handle->can_refresh = false;
|
|
|
|
/* create area region */
|
|
region = ui_region_temp_add(CTX_wm_screen(C));
|
|
handle->region = region;
|
|
|
|
memset(&type, 0, sizeof(ARegionType));
|
|
type.draw = ui_block_region_draw;
|
|
type.layout = ui_block_region_refresh;
|
|
type.regionid = RGN_TYPE_TEMPORARY;
|
|
region->type = &type;
|
|
|
|
UI_region_handlers_add(®ion->handlers);
|
|
|
|
block = ui_popup_block_refresh(C, handle, butregion, but);
|
|
handle = block->handle;
|
|
|
|
/* keep centered on window resizing */
|
|
if (block->bounds_type == UI_BLOCK_BOUNDS_POPUP_CENTER) {
|
|
type.listener = ui_block_region_popup_window_listener;
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
void ui_popup_block_free(bContext *C, uiPopupBlockHandle *handle)
|
|
{
|
|
/* If this popup is created from a popover which does NOT have keep-open flag set,
|
|
* then close the popover too. We could extend this to other popup types too. */
|
|
ARegion *region = handle->popup_create_vars.butregion;
|
|
if (region != NULL) {
|
|
for (uiBlock *block = region->uiblocks.first; block; block = block->next) {
|
|
if (block->handle && (block->flag & UI_BLOCK_POPOVER) &&
|
|
(block->flag & UI_BLOCK_KEEP_OPEN) == 0) {
|
|
uiPopupBlockHandle *menu = block->handle;
|
|
menu->menuretval = UI_RETURN_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (handle->popup_create_vars.arg_free) {
|
|
handle->popup_create_vars.arg_free(handle->popup_create_vars.arg);
|
|
}
|
|
|
|
ui_popup_block_remove(C, handle);
|
|
|
|
MEM_freeN(handle);
|
|
}
|
|
|
|
/** \} */
|