void MCStack::setacceleratedrendering(bool p_value)
{
// If we are turning accelerated rendering off, then destroy the tilecache.
if (!p_value)
{
MCTileCacheDestroy(m_tilecache);
m_tilecache = nil;
// MW-2012-03-15: [[ Bug ]] Make sure we dirty the stack to ensure all the
// layer mode attrs are rest.
dirtyall();
return;
}
// If we are turning accelerated rendering on, and we already have a tile-
// cache, then do nothing.
if (m_tilecache != nil)
return;
// Otherwise, we configure based on platform settings.
int32_t t_tile_size;
int32_t t_cache_limit;
MCTileCacheCompositorType t_compositor_type;
#ifdef _MAC_DESKTOP
t_compositor_type = kMCTileCacheCompositorCoreGraphics;
t_tile_size = 32;
t_cache_limit = 32 * 1024 * 1024;
#elif defined(_WINDOWS_DESKTOP) || defined(_LINUX_DESKTOP)
t_compositor_type = kMCTileCacheCompositorSoftware;
t_tile_size = 32;
t_cache_limit = 32 * 1024 * 1024;
#elif defined(_IOS_MOBILE) || defined(_ANDROID_MOBILE)
t_compositor_type = kMCTileCacheCompositorStaticOpenGL;
const MCDisplay *t_display;
MCscreen -> getdisplays(t_display, false);
MCRectangle t_viewport;
t_viewport = t_display -> viewport;
bool t_small_screen, t_medium_screen;
t_small_screen = MCMin(t_viewport . width, t_viewport . height) <= 480 && MCMax(t_viewport . width, t_viewport . height) <= 640;
t_medium_screen = MCMin(t_viewport . width, t_viewport . height) <= 768 && MCMax(t_viewport . width, t_viewport . height) <= 1024;
if (t_small_screen)
t_tile_size = 32, t_cache_limit = 16 * 1024 * 1024;
else if (t_medium_screen)
t_tile_size = 64, t_cache_limit = 32 * 1024 * 1024;
else
t_tile_size = 64, t_cache_limit = 64 * 1024 * 1024;
#endif
MCTileCacheCreate(t_tile_size, t_cache_limit, m_tilecache);
MCTileCacheSetViewport(m_tilecache, curcard -> getrect());
MCTileCacheSetCompositor(m_tilecache, t_compositor_type);
dirtyall();
}
void MCStack::view_setcompositortilesize(uint32_t p_size)
{
if (m_view_tilecache != nil)
{
MCTileCacheSetTileSize(m_view_tilecache, p_size);
dirtyall();
}
}
void MCStack::view_setcompositorcachelimit(uint32_t p_limit)
{
if (m_view_tilecache != nil)
{
MCTileCacheSetCacheLimit(m_view_tilecache, p_limit);
dirtyall();
}
}
void MCStack::view_on_rect_changed(void)
{
// IM-2013-10-03: [[ FullscreenMode ]] if the view rect has changed, update the tilecache geometry
view_updatetilecacheviewport();
if (view_getfullscreen() || view_platform_dirtyviewonresize())
dirtyall();
}
MCRectangle MCStack::view_setgeom(const MCRectangle &p_rect)
{
// IM-2014-09-23: [[ Bug 13349 ]] Defer window resizing if the screen is locked.
if ((MCRedrawIsScreenLocked() || !MCRedrawIsScreenUpdateEnabled()) && (opened && getflag(F_VISIBLE)))
{
m_view_need_resize = true;
MCRedrawScheduleUpdateForStack(this);
return p_rect;
}
dirtyall();
return view_platform_setgeom(p_rect);
}
void MCStack::view_setcompositortype(MCTileCacheCompositorType p_type)
{
if (p_type == kMCTileCacheCompositorNone)
{
MCTileCacheDestroy(m_view_tilecache);
m_view_tilecache = nil;
}
else
{
if (m_view_tilecache == nil)
{
MCTileCacheCreate(32, 4096 * 1024, m_view_tilecache);
view_updatetilecacheviewport();
}
MCTileCacheSetCompositor(m_view_tilecache, p_type);
}
dirtyall();
}
// IM-2013-10-14: [[ FullscreenMode ]] Move update region tracking into view abstraction
void MCStack::view_dirty_all(void)
{
view_dirty_rect(MCRectangleMake(0, 0, m_view_rect.width, m_view_rect.height));
dirtyall();
}
void MCStack::view_setacceleratedrendering(bool p_value)
{
#ifdef _SERVER
// We don't have accelerated rendering on Server
return;
#else
// If we are turning accelerated rendering off, then destroy the tilecache.
if (!p_value)
{
MCTileCacheDestroy(m_view_tilecache);
m_view_tilecache = nil;
// MW-2012-03-15: [[ Bug ]] Make sure we dirty the stack to ensure all the
// layer mode attrs are rest.
dirtyall();
return;
}
// If we are turning accelerated rendering on, and we already have a tile-
// cache, then do nothing.
if (m_view_tilecache != nil)
return;
// Otherwise, we configure based on platform settings.
int32_t t_tile_size;
int32_t t_cache_limit;
MCTileCacheCompositorType t_compositor_type;
#ifdef _MAC_DESKTOP
t_compositor_type = kMCTileCacheCompositorCoreGraphics;
t_tile_size = 32;
t_cache_limit = 32 * 1024 * 1024;
#elif defined(_WINDOWS_DESKTOP) || defined(_LINUX_DESKTOP) || defined(__EMSCRIPTEN__)
t_compositor_type = kMCTileCacheCompositorSoftware;
t_tile_size = 32;
t_cache_limit = 32 * 1024 * 1024;
#elif defined(_IOS_MOBILE) || defined(_ANDROID_MOBILE)
t_compositor_type = kMCTileCacheCompositorStaticOpenGL;
const MCDisplay *t_display;
MCscreen -> getdisplays(t_display, false);
MCRectangle t_viewport;
t_viewport = t_display -> viewport;
// IM-2014-01-30: [[ HiDPI ]] Use backing-surface size to determine small, medium, or large
t_viewport = MCRectangleGetScaledBounds(t_viewport, view_getbackingscale());
bool t_small_screen, t_medium_screen;
t_small_screen = MCMin(t_viewport . width, t_viewport . height) <= 480 && MCMax(t_viewport . width, t_viewport . height) <= 640;
t_medium_screen = MCMin(t_viewport . width, t_viewport . height) <= 768 && MCMax(t_viewport . width, t_viewport . height) <= 1024;
if (t_small_screen)
t_tile_size = 32, t_cache_limit = 16 * 1024 * 1024;
else if (t_medium_screen)
t_tile_size = 64, t_cache_limit = 32 * 1024 * 1024;
else
t_tile_size = 64, t_cache_limit = 64 * 1024 * 1024;
#else
# error "No tile cache implementation defined for this platform"
#endif
MCTileCacheCreate(t_tile_size, t_cache_limit, m_view_tilecache);
view_updatetilecacheviewport();
MCTileCacheSetCompositor(m_view_tilecache, t_compositor_type);
dirtyall();
#endif /* !_SERVER */
}
void MCStack::view_update_transform(bool p_ensure_onscreen)
{
MCRectangle t_view_rect;
MCGAffineTransform t_transform;
#if defined(_MOBILE)
MCOrientation t_orientation;
MCSystemGetOrientation(t_orientation);
MCOrientationGetRectForOrientation(t_orientation ,m_view_requested_stack_rect);
#endif
// IM-2014-01-16: [[ StackScale ]] Use utility method to calculate new values
view_calculate_viewports(m_view_requested_stack_rect, m_view_adjusted_stack_rect, t_view_rect, t_transform);
// IM-2013-12-20: [[ ShowAll ]] Calculate new stack visible rect
MCRectangle t_stack_visible_rect;
t_stack_visible_rect = MCRectangleGetTransformedBounds(MCRectangleMake(0, 0, t_view_rect.width, t_view_rect.height), MCGAffineTransformInvert(t_transform));
if (m_view_fullscreenmode == kMCStackFullscreenLetterbox || m_view_fullscreenmode == kMCStackFullscreenNoScale)
t_stack_visible_rect = MCU_intersect_rect(t_stack_visible_rect, MCRectangleMake(0, 0, m_view_adjusted_stack_rect.width, m_view_adjusted_stack_rect.height));
// IM-2013-10-03: [[ FullscreenMode ]] if the transform has changed, redraw everything
// IM-2013-12-20: [[ ShowAll ]] if the stack viewport has changed, redraw everything
bool t_rect_changed, t_transform_changed;
t_rect_changed = !MCU_equal_rect(t_stack_visible_rect, m_view_stack_visible_rect);
t_transform_changed = !MCGAffineTransformIsEqual(t_transform, m_view_transform);
if (t_rect_changed || t_transform_changed)
{
m_view_transform = t_transform;
m_view_stack_visible_rect = t_stack_visible_rect;
dirtyall();
if (t_transform_changed)
this->OnViewTransformChanged();
}
// PM-2015-07-17: [[ Bug 13754 ]] Make sure stack does not disappear off screen when changing the scalefactor
MCRectangle t_bounded_rect;
if (p_ensure_onscreen)
{
// AL-2015-10-01: [[ Bug 16017 ]] Remember location of stacks on a second monitor
const MCDisplay* t_nearest_display;
t_nearest_display = MCscreen -> getnearestdisplay(t_view_rect);
if (t_nearest_display != nil)
{
MCRectangle t_screen_rect;
t_screen_rect = t_nearest_display -> viewport;
t_bounded_rect = MCU_bound_rect(t_view_rect, t_screen_rect . x, t_screen_rect . y, t_screen_rect . width, t_screen_rect . height);
}
else
{
// In noUI mode, we don't have a nearest display.
t_bounded_rect = MCU_bound_rect(t_view_rect, 0, 0, MCscreen -> getwidth(), MCscreen -> getheight());
}
}
else
{
t_bounded_rect = t_view_rect;
}
// IM-2014-01-16: [[ StackScale ]] Update view rect if needed
view_setrect(t_bounded_rect);
}
