blender
/
blender
136
406
Fork 587
Code Issues 6.2k Pull Requests 755 Projects 19 Wiki Activity

Merge branch 'blender-v3.1-release'

This commit is contained in:
Germano Cavalcante 2022-03-01 18:25:59 -03:00
parent e1ec2d0251 9bd586a01e
commit bfe37b7255
13 changed files with 100 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
intern/ghost/GHOST_C-api.h
View File

@ -249,6 +249,16 @@ extern GHOST_TSuccess GHOST_EndFullScreen(GHOST_SystemHandle systemhandle);
*/
extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
/**
* Get the Window under the cursor.
* \param x: The x-coordinate of the cursor.
* \param y: The y-coordinate of the cursor.
* @return The window under the cursor or nullptr in none.
*/
extern GHOST_WindowHandle GHOST_GetWindowUnderCursor(GHOST_SystemHandle systemhandle,
int32_t x,
int32_t y);
/***************************************************************************************
* Event management functionality
***************************************************************************************/

8
intern/ghost/GHOST_ISystem.h
View File

@ -309,6 +309,14 @@ class GHOST_ISystem {
*/
virtual void useWindowFocus(const bool use_focus) = 0;
/**
* Get the Window under the cursor.
* \param x: The x-coordinate of the cursor.
* \param y: The y-coordinate of the cursor.
* @return The window under the cursor or nullptr if none.
*/
virtual GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y) = 0;
/***************************************************************************************
* Event management functionality
***************************************************************************************/

10
intern/ghost/intern/GHOST_C-api.cpp
View File

@ -233,6 +233,16 @@ int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle)
return (int)system->getFullScreen();
}
GHOST_WindowHandle GHOST_GetWindowUnderCursor(GHOST_SystemHandle systemhandle,
int32_t x,
int32_t y)
{
GHOST_ISystem *system = (GHOST_ISystem *)systemhandle;
GHOST_IWindow *window = system->getWindowUnderCursor(x, y);
return (GHOST_WindowHandle)window;
}
bool GHOST_ProcessEvents(GHOST_SystemHandle systemhandle, bool waitForEvent)
{
GHOST_ISystem *system = (GHOST_ISystem *)systemhandle;

19
intern/ghost/intern/GHOST_System.cpp
View File

@ -189,6 +189,25 @@ bool GHOST_System::getFullScreen(void)
return fullScreen;
}
GHOST_IWindow *GHOST_System::getWindowUnderCursor(int32_t x, int32_t y)
{
/* TODO: This solution should follow the order of the activated windows (Z-order).
* It is imperfect but usable in most cases. */
for (GHOST_IWindow *iwindow : m_windowManager->getWindows()) {
if (iwindow->getState() == GHOST_kWindowStateMinimized) {
continue;
}
GHOST_Rect bounds;
iwindow->getClientBounds(bounds);
if (bounds.isInside(x, y)) {
return iwindow;
}
}
return NULL;
}
void GHOST_System::dispatchEvents()
{
#ifdef WITH_INPUT_NDOF

8
intern/ghost/intern/GHOST_System.h
View File

@ -157,6 +157,14 @@ class GHOST_System : public GHOST_ISystem {
void useWindowFocus(const bool use_focus);
bool m_windowFocus;
/**
* Get the Window under the cursor.
* \param x: The x-coordinate of the cursor.
* \param y: The y-coordinate of the cursor.
* @return The window under the cursor or nullptr if none.
*/
GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y);
/***************************************************************************************
* Event management functionality
***************************************************************************************/

8
intern/ghost/intern/GHOST_SystemCocoa.h
View File

@ -109,6 +109,14 @@ class GHOST_SystemCocoa : public GHOST_System {
*/
GHOST_TSuccess disposeContext(GHOST_IContext *context);
/**
* Get the Window under the cursor.
* \param x: The x-coordinate of the cursor.
* \param y: The y-coordinate of the cursor.
* @return The window under the cursor or nullptr if none.
*/
GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y);
/***************************************************************************************
* Event management functionality
***************************************************************************************/

14
intern/ghost/intern/GHOST_SystemCocoa.mm
View File

@ -772,6 +772,20 @@ GHOST_TSuccess GHOST_SystemCocoa::disposeContext(GHOST_IContext *context)
return GHOST_kSuccess;
}
GHOST_IWindow *GHOST_SystemCocoa::getWindowUnderCursor(int32_t x, int32_t y)
{
NSPoint scr_co = NSMakePoint(x, y);
int windowNumberAtPoint = [NSWindow windowNumberAtPoint:scr_co belowWindowWithWindowNumber:0];
NSWindow *nswindow = [NSApp windowWithWindowNumber:windowNumberAtPoint];
if (nswindow == nil) {
return nil;
}
return m_windowManager->getWindowAssociatedWithOSWindow((void *)nswindow);
}
/**
* \note : returns coordinates in Cocoa screen coordinates
*/

5
intern/ghost/intern/GHOST_SystemNULL.h
View File

@ -114,4 +114,9 @@ class GHOST_SystemNULL : public GHOST_System {
type,
((glSettings.flags & GHOST_glStereoVisual) != 0));
}
GHOST_IWindow *getWindowUnderCursor(int32_t x, int32_t y)
{
return NULL;
}
};

3
source/blender/editors/interface/interface_eyedropper.c
View File

@ -147,8 +147,7 @@ void datadropper_win_area_find(
*r_win = CTX_wm_window(C);
*r_area = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, mval);
if (*r_area == NULL) {
wmWindowManager *wm = CTX_wm_manager(C);
*r_win = WM_window_find_under_cursor(wm, NULL, *r_win, mval, r_mval);
*r_win = WM_window_find_under_cursor(*r_win, mval, r_mval);
if (*r_win) {
screen = WM_window_get_active_screen(*r_win);
*r_area = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, r_mval);

5
source/blender/editors/screen/area.c
View File

@ -3442,7 +3442,6 @@ ScrArea *ED_area_find_under_cursor(const bContext *C, int spacetype, const int x
{
bScreen *screen = CTX_wm_screen(C);
wmWindow *win = CTX_wm_window(C);
wmWindowManager *wm = CTX_wm_manager(C);
ScrArea *area = NULL;
@ -3454,8 +3453,8 @@ ScrArea *ED_area_find_under_cursor(const bContext *C, int spacetype, const int x
if (!area) {
/* Check all windows except the active one. */
int scr_pos[2];
wmWindow *r_win = WM_window_find_under_cursor(wm, win, win, xy, scr_pos);
if (r_win) {
wmWindow *r_win = WM_window_find_under_cursor(win, xy, scr_pos);
if (r_win && r_win != win) {
win = r_win;
screen = WM_window_get_active_screen(win);
area = BKE_screen_find_area_xy(screen, spacetype, scr_pos);

6
source/blender/windowmanager/WM_api.h
View File

@ -127,11 +127,7 @@ void WM_reinit_gizmomap_all(struct Main *bmain);
*/
void WM_script_tag_reload(void);
wmWindow *WM_window_find_under_cursor(const wmWindowManager *wm,
const wmWindow *win_ignore,
const wmWindow *win,
const int mval[2],
int r_mval[2]);
wmWindow *WM_window_find_under_cursor(wmWindow *win, const int mval[2], int r_mval[2]);
void WM_window_pixel_sample_read(const wmWindowManager *wm,
const wmWindow *win,
const int pos[2],

4
source/blender/windowmanager/intern/wm_event_system.c
View File

@ -4667,8 +4667,8 @@ static wmWindow *wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *wi
}
}
wmWindow *win_other = WM_window_find_under_cursor(wm, win, win, mval, mval);
if (win_other) {
wmWindow *win_other = WM_window_find_under_cursor(win, mval, mval);
if (win_other && win_other != win) {
copy_v2_v2_int(event->xy, mval);
return win_other;
}

57
source/blender/windowmanager/intern/wm_window.c
View File

@ -1841,56 +1841,23 @@ bool wm_window_get_swap_interval(wmWindow *win, int *intervalOut)
/** \name Find Window Utility
* \{ */
static void wm_window_desktop_pos_get(const wmWindow *win,
const int screen_pos[2],
int r_desk_pos[2])
wmWindow *WM_window_find_under_cursor(wmWindow *win, const int mval[2], int r_mval[2])
{
/* To desktop space. */
r_desk_pos[0] = screen_pos[0] + (int)(U.pixelsize * win->posx);
r_desk_pos[1] = screen_pos[1] + (int)(U.pixelsize * win->posy);
}
int tmp[2];
copy_v2_v2_int(tmp, mval);
wm_cursor_position_to_ghost(win, &tmp[0], &tmp[1]);
static void wm_window_screen_pos_get(const wmWindow *win,
const int desktop_pos[2],
int r_scr_pos[2])
{
/* To window space. */
r_scr_pos[0] = desktop_pos[0] - (int)(U.pixelsize * win->posx);
r_scr_pos[1] = desktop_pos[1] - (int)(U.pixelsize * win->posy);
}
GHOST_WindowHandle ghostwin = GHOST_GetWindowUnderCursor(g_system, tmp[0], tmp[1]);
wmWindow *WM_window_find_under_cursor(const wmWindowManager *wm,
const wmWindow *win_ignore,
const wmWindow *win,
const int mval[2],
int r_mval[2])
{
int desk_pos[2];
wm_window_desktop_pos_get(win, mval, desk_pos);
/* TODO: This should follow the order of the activated windows.
* The current solution is imperfect but usable in most cases. */
LISTBASE_FOREACH (wmWindow *, win_iter, &wm->windows) {
if (win_iter == win_ignore) {
continue;
}
if (win_iter->windowstate == GHOST_kWindowStateMinimized) {
continue;
}
int scr_pos[2];
wm_window_screen_pos_get(win_iter, desk_pos, scr_pos);
if (scr_pos[0] >= 0 && scr_pos[1] >= 0 && scr_pos[0] <= WM_window_pixels_x(win_iter) &&
scr_pos[1] <= WM_window_pixels_y(win_iter)) {
copy_v2_v2_int(r_mval, scr_pos);
return win_iter;
}
if (!ghostwin) {
return NULL;
}
return NULL;
wmWindow *r_win = GHOST_GetWindowUserData(ghostwin);
wm_cursor_position_from_ghost(r_win, &tmp[0], &tmp[1]);
copy_v2_v2_int(r_mval, tmp);
return r_win;
}
void WM_window_pixel_sample_read(const wmWindowManager *wm,