void MCControl::layer_scrolled(void) { if (!opened) return; // Check the visibility state of the object. bool t_is_visible; t_is_visible = isvisible() || MCshowinvisibles; // If the layer isn't scrolling, we must redraw the whole thing. Otherwise // we just need to invalidate a portion of the card. if (!layer_isscrolling()) { // We only actually need to do something if we are in the sprite // case, or we are visible if (layer_issprite() || t_is_visible) layer_dirtyeffectiverect(geteffectiverect(), t_is_visible); } else { // If we are a scrolling layer and not visible, there is nothing to // do. if (t_is_visible) static_cast<MCCard *>(parent) -> layer_dirtyrect(geteffectiverect()); } }
void MCControl::layer_rectchanged(const MCRectangle& p_old_rect, bool p_redraw_all) { if (!opened) return; // Check the visibility state of the object. bool t_is_visible; t_is_visible = isvisible() || MCshowinvisibles; // If we are not a sprite, and are invisible there is nothing to do; otherwise // we must at least try to dump cached updated parts of the sprite. if (!layer_issprite() && !t_is_visible) return; // Cache the new rectangle. MCRectangle t_new_rect; t_new_rect = rect; // Temporarily set it back to the old one so we can compute the old effective // rect. MCRectangle t_old_effectiverect; rect = p_old_rect; t_old_effectiverect = geteffectiverect(); // If the rect has changed size and we aren't a scrolling layer, then we // redraw all. if (!layer_isscrolling() && (rect . width != t_new_rect . width || rect . height != t_new_rect . height)) p_redraw_all = true; // Replace the new rect and do the rect changed updates. rect = t_new_rect; layer_changeeffectiverect(t_old_effectiverect, p_redraw_all, t_is_visible); }
void MCControl::layer_setrect(const MCRectangle& p_new_rect, bool p_redraw_all) { if (!opened) { setrect(p_new_rect); return; } // Check the visibility state of the object. bool t_is_visible; t_is_visible = isvisible() || MCshowinvisibles; // If we are not a sprite, and are invisible there is nothing to do; otherwise // we must at least try to dump cached updated parts of the sprite. if (!layer_issprite() && !t_is_visible) { setrect(p_new_rect); return; } MCRectangle t_old_effectiverect; t_old_effectiverect = geteffectiverect(); // If the rect has changed size and we aren't a scrolling layer, then we // redraw all. if (!layer_isscrolling() && (rect . width != p_new_rect . width || rect . height != p_new_rect . height)) p_redraw_all = true; setrect(p_new_rect); layer_changeeffectiverect(t_old_effectiverect, p_redraw_all, t_is_visible); }
void MCControl::SetColorOverlayProperty(MCExecContext& ctxt, MCNameRef index, MCExecValue p_value) { bool t_dirty = false; MCRectangle t_old_effective_rect = geteffectiverect(); if (MCBitmapEffectsSetProperty(ctxt, m_bitmap_effects, index, P_BITMAP_EFFECT_COLOR_OVERLAY, p_value, t_dirty)) { if (t_dirty) EffectRedraw(t_old_effective_rect); return; } ctxt . Throw(); }
void MCControl::SetInnerShadowProperty(MCExecContext& ctxt, MCNameRef index, MCExecValue p_value) { bool t_dirty = false; MCRectangle t_old_effective_rect = geteffectiverect(); if (MCBitmapEffectsSetProperty(ctxt, m_bitmap_effects, index, P_BITMAP_EFFECT_INNER_SHADOW, p_value, t_dirty)) { if (t_dirty) EffectRedraw(t_old_effective_rect); return; } ctxt . Throw(); }
void MCControl::layer_redrawall(void) { if (!opened) return; // Check the visibility state of the object. bool t_is_visible; t_is_visible = isvisible() || MCshowinvisibles; // If we are not a sprite, and are invisible there is nothing to do; otherwise // we must at least try to dump cached updated parts of the sprite. if (!layer_issprite() && !t_is_visible) return; // Scrolling layers are a special case as its the content that must be dirtied // not the effective image. if (!layer_isscrolling()) layer_dirtyeffectiverect(geteffectiverect(), t_is_visible); else layer_dirtycontentrect(layer_getcontentrect(), t_is_visible); }
void MCControl::layer_changeeffectiverect(const MCRectangle& p_old_effective_rect, bool p_force_update, bool p_update_card) { // Compute the 'new' effectiverect based on visibility. MCRectangle t_new_effective_rect; if (getflag(F_VISIBLE) || MCshowinvisibles) t_new_effective_rect = geteffectiverect(); else MCU_set_rect(t_new_effective_rect, 0, 0, 0, 0); // If the effective rect has not changed this is at most an update. if (MCU_equal_rect(p_old_effective_rect, t_new_effective_rect)) { // If we are forcing an update, use the dirty method. if (p_force_update) { // If the layer is not scrolling just defer to the normal // dirty method; otherwise use the dirty content method. if (!layer_isscrolling()) layer_dirtyeffectiverect(t_new_effective_rect, p_update_card); else layer_dirtycontentrect(layer_getcontentrect(), p_update_card); } // We are done. return; } // Fetch the tilecache, making it nil if the parent is a group (in the // latter case, this is just a dirty op). MCTileCacheRef t_tilecache; if (parent -> gettype() != CT_GROUP) t_tilecache = getstack() -> gettilecache(); else t_tilecache = nil; // If no tilecache, then just dirty the old and new effective rects. if (t_tilecache == nil) { layer_dirtyeffectiverect(p_old_effective_rect, p_update_card); layer_dirtyeffectiverect(t_new_effective_rect, p_update_card); return; } // MW-2011-10-17: [[ Bug 9808 ]] Make sure we update the card regardless of // whether we have a layer id - otherwise new objects don't show! // Add the rects to the update region - but only if instructed (update_card will be // false if the object was invisible). if (p_update_card) { static_cast<MCCard *>(parent) -> layer_dirtyrect(p_old_effective_rect); static_cast<MCCard *>(parent) -> layer_dirtyrect(t_new_effective_rect); } // We must be in tile-cache mode with a top-level control, but if the layer // id is zero, there is nothing to do. if (m_layer_id == 0) return; if (!layer_issprite()) { // Non-dynamic layers are scenery in the tilecache, and we must use old // new effective rects so that the appropriate tiles get flushed. Note // that 'force_update' has no effect here as reshaping a scenery layer // implicitly invalidates all tiles it touches. MCTileCacheReshapeScenery(t_tilecache, m_layer_id, p_old_effective_rect, t_new_effective_rect); } else { // Dynamic layers are sprites in the tilecache, and there is nothing to // do unless 'force update' is required. In particular, if the layer is // just moving then no redraw of the layer will be needed. Note, however, // that this implicitly assumes that 'force update' is true if the content // in a sprite-relative co-ord system has changed. if (p_force_update) { MCRectangle t_rect; // If the layer is not scrolling, just use the width/height from the // effective rect; otherwise use content width/height. if (!layer_isscrolling()) t_rect = p_old_effective_rect; else t_rect = layer_getcontentrect(); MCTileCacheUpdateSprite(t_tilecache, m_layer_id, MCU_make_rect(0, 0, t_rect . width, t_rect . height)); } } }
void MCControl::layer_dirtycontentrect(const MCRectangle& p_updated_rect, bool p_update_card) { if (MCU_empty_rect(p_updated_rect)) return; MCRectangle t_content_rect; t_content_rect = layer_getcontentrect(); MCTileCacheRef t_tilecache; t_tilecache = getstack() -> gettilecache(); // Note that this method is only called if layer_isscrolling() is true, which is only // possible if we have a tilecache. if (m_layer_id != 0) MCTileCacheUpdateSprite(t_tilecache, m_layer_id, MCU_offset_rect(p_updated_rect, -t_content_rect . x, -t_content_rect . y)); // Add the rect to the update region - but only if instructed (update_card will be // false if the object was invisible). if (p_update_card) static_cast<MCCard *>(parent) -> layer_dirtyrect(MCU_intersect_rect(p_updated_rect, geteffectiverect())); }