- Clarified proper usage of `pageAlignVertically` and add note about 2.2
change and how to obtain 2.1 behavior.
- Removed the `@readonly` status of the `parentIsWindow` and `parentNode`;
these can be updated in a controlled manner.
- Added intra-hyperlinks
- Updated some ancillary documentation
The click trampoline added for IE prevents Chrome for Android from being
able to launch Full Screen mode with the default parameters for
`ScaleManger#startFullScreen`. (The desktop version of Chrome is not
affected.)
This fix adds an additional compatibility settings (`clickTrampoline`)
that can be used to configure when such is used. By default the
'when-not-mouse' mode is only enabled for Desktop browsers, where the
primary input is ubquitously a mouse.
There are no known breaking compatibility changes - the Full Screen should
be initiatable in Chrome for Android as it was in 2.1.x. The default
Android browser does not support Full Screen.
ScaleManager.windowContraints now allows specifing 'visual' or 'layout' as
the constraint. Using the 'layout' constraint should prevent a mobile
device from trying to resize the game when zooming.
Including the the new changes the defaults have been changed to
windowContraints = { right: 'layout', bottom: '' }
This changes the current scaling behavior as seen in "Game Scaling" (as it
will only scale for the right edge) but also prevents such scaling from
going wonkers in some mobile environtments like the newer Android browser.
(Automatic scroll-to-top, albeit configurable, enabled for non-desktop by
default is not a fun situation here.)
To obtain the current semantics on a desktop the bottom should be changed
to 'layout'; although this will result in different behavior depending on
mobile device. To make the sizing also follow mobile zooming they should
be changed to 'visual'.
Also added temp Rectangle re-used for various internal calculations.
---
Phaser.DOM now also special-cases desktops to align the layout bounds
correctly (this may disagree with CSS breakpoints but it aligns the with
actual CSS width), without applying a window height/width expansion as
required on mobile browsers.
(And the jshint error isn't mine..)
"Final" changes for a solid 2.2-worthy ScaleManager.
This adds in official support for USER_SCALE, which allows a flexible way
to control the scaling dynamically.
It fixes a visible display bug in desktop browsers (viewport clipping was
off) and mitigates some potential issues all around by using a unified
visualBound calculations in Phaser.DOM.
It applies some protected/deprecated attributes, but does not remove any
behavior of already-established (as in, outside-dev) means.
There are no known [signficant] breaking changes; any known breaks (not
considered fixes) are constrained to dev with no known consumers.
Phaser.DOM
There are no known significant breaking changes; Phaser.DOM was
internal.
- Added visualBounds; this should be the true visual area, minus the
scrollbars. This should be used instead of clientWidth/clientHeight to
detect the visual viewport.
- Expose various viewport sizes as dynamically updated properties on
Rectangle objects. These are visualBounds, layoutBounds,
documentBounds.
- Updated documentation the different bounds; in particular drawing
distinction between viewport/layout bounds and visual bounds.
- Renamed `inViewport` to `inLayoutViewport` to indidcate behavior.
- Minor breaking, but dev-only
- Changed `getAspectRatio` to work on Visual viewport. This will yield
the expected behavior on mobiles.
- Minor breaking, but dev-only
- Removed some quirks-mode and legacy-browser special casing
Phaser.ScaleManager
There are no known significant breaking changes.
- USER_SCALE is 'made public'. It can used to flexibly configure any
custom-yet-dynamic scaling requirements; it should now be able to
replace any sane usage of manual sizing invoking the deprecated
setSize/setScreenSize.
- Added additional usage documentation and links to such
- Added the ability to specify a post-scale trim factor.
- Change the arguments the resize callback and document what is passed
- Minor breaking, but the previous arguments were undocumented
- `compatiblity.showAllCanExpand` renamed to `canExpandParent` and made
generalized over possibly-expanding scaling.
- Minor breaking, dev-only, for coding changing this settin
- Switched from direct usage of of window innerWidth/Heigth to
Phaser.DOM visualViewport - this change correctly accounts for
scrollbars in desktop environments
- Although it does slightly alter the behavior, this is a fix.
- Removed usage of window outerWidth/outerHeight which didn't make much
sense where it was used for desktops and was catostrophic for mobile
browser
- Although it may slightly alter the behavior, this is a fix.
- Removed `aspect` and `elementBounds` because they are duplicative of
Phaser.DOM (which can not be accessed as `scale.dom`).
- Minor breaking, but internal methods on dev-only
- Marked the minWidth/maxWidth/minHeight/maxHeight properties as
protected. They are not removed/obsoleted, but should be revised later
for more flexibility.
- Orientation handling; non-breaking forward deprecations
- Added `onOrientationChange` and deprecated the 4 separate leave,
enter, landscape and portrait signals. They are not removed, so this
is a future-migration change.
- Fixed issue where state not updated prior to callback
- Fixed issue where orientation callbacks were not always delayed
- Fullscreen events: non-breaking forward deprecations
- Added `onFullScreenChange` and deprecated `enterFullScreen` and
`leaveFullScreen`.
- Renamed (with proxy) `fullScreenFailed` to `onFullScreenError`.
Phaser.Device
- Improved `whenReady` to support Phaser.DOM better
- Allows a ready handler to be added without starting the
device-detection proccess. This allows it to be registered to
internally (eg. from System.DOM) without affecting current behavior.
- Passes the device object as the first parameter to the callback
function.
- Fixed code where Silk detection not applied to `desktop` detection.
Manifest: System.Device moved before System.DOM
- Added `onFullScreenInit` signal which is the correct place for a client
to alter the FS target element, such as to set a background color or add
a CSS class.
- Increased documentation overview and specificity including expected
Parent behavior, sizing calculations, and when `refresh` may be required.
- Grouped documentation for scale modes (in 'scaleMode')
- Separated out internal/deprecated `setScreenSize` method from
`updateLayout`.
There are no known breaking changes.
- FIX#1306, hopefully, where an orientation change did not correclty
cause a screen/layout update.
- FIX/CHANGE where Paused games would not update the scale
- The new behavior "runs" the ScaleManager in a paused state via
`pauseUpdate`; a User paused game will now correctly track scale
changes. This is closer to the 2.1.3 behavior in some cases, such as
window resizing, when the updates were done in the DOM event.
- This change also affects device orientation change monitoring and
events, which are also deferred to the update cycle
- The update cycle is set to the maximum and is still dependent on the
RAF / primary loop running, so it should not affect background
apps/tabs
- FIX/CHANGE New better backoff timing; ie. continuous window resizing is
limited to ~10 fps update calculations. This makes it much harder to
crash Chrome by rapidly and continously resizing the window. Also
increases the scaling from 0..10..20..40 to 0..25..50..100.
- FIX an issue where the incorrect orientation was "one frame behind" the
scaling.
- UPDATE The contract for when the change orientation events occurs is
better defined - it now always happens in the update context as with
game sizing.
- UPDATE Unifies orientation-change code / handling and duplicate.
- CHANGE Added DOM.getScreenOrientation which obtains the orientation via
the Device Orientation API (WD) and provides comprehensive fallbacks
- This should cover all modern browsers
- FIX: Orientation on desktops now computed as screen ratio by default
which fixesi the false-portrait chain/detection when the page is made
more narrow than it is tall.
- CHANGE/FIX: window.orientation is now only used as fallback, if
requested (due to device differences). It may be appropriate to enable
this (via `scale.compatibility` on boot, for instance) in some
environments.
Signed-off-by: Paul <pstickne@gmail.com>
No known breaking changes - as it's still dev/internal stuff.
- Added Phaser.DOM to house new DOM functions, moved stuff
over from ScaleManager as appropriate
- Fixed a fiew cases of missing functions
- Changed some of the new signatures to protected for the interim.
(Maybe a `beta` tag would fit better? Public is promises!)
- Moved generic support from Canvas to DOM and added proxy/notes
- Updated internal usages
- Updated some comments for consistency
- Access always on bottom for members/properties, public assumed
- Added `compatibility` settings
- CHANGE (2.1.2-4): moved `supportsFullScreen` and `noMargins` into it
- Added additional properties for greater control and up-front settings.
- `scrollTo`: where the browser will scrollTo, if anywhere
- `forceMinimumDocumentHeight`: apply document element style?
- `allowShowAllExpand`: allow SHOW_ALL to try to expand? (It already
could, this allows configuration.)
- Removed `windowConstraints.top/left`. This may be a feature in the
future, but scrubbed for now.
- Added `USER_SCALE` scale mode. This is like NO_SCALE but it scales off
of a user-specified scale factor, as set by `setUserScale`. This is
marked as "experimental" as the exactly semantics of non-adjusting modes
(e.g. NO_SCALE and USER_SCALE) wrt. Canvas and "maximum" size clamps
need to be re-examined.
- FIX: `onSizeChange` now works as documented, which means it is also
fired if the game size changes even though the game canvas size does
not.
- CHANGE (no known breaking): `margins` is now non-Point/non-Rectangle
that uses top/left/bottom/right properties (any quasi-updated x/y). This
is to get around the issue that Rectangle is only designed for positive
width/height cases.
- Cleaned up property access / quotes for consistency
- Various documentation cleanup and consistency
- Fixed issue with not clearing an unparented `_createdFullScreenTarget`
- Added Phaser.Rectangle.sameDimensions which does a strict equality check
over the `width` and `height` properties of two objects, perhaps
Rectangles.
ScaleManager.calibrate is a private method that calibrates element coordinates for viewport checks.
ScaleManager.aspect gets the viewport aspect ratio (or the aspect ratio of an object or element)
ScaleManager.inViewport tests if the given DOM element is within the viewport, with an optional cushion parameter that allows you to specify a distance.
ScaleManager.scaleSprite takes a Sprite or Image object and scales it to fit the given dimensions. Scaling happens proportionally without distortion to the sprites texture. The letterBox parameter controls if scaling will produce a letter-box effect or zoom the sprite until it fills the given values.
ScaleManager.viewportWidth returns the viewport width in pixels.
ScaleManager.viewportHeight returns the viewport height in pixels.
ScaleManager.documentWidth returns the document width in pixels.
ScaleManager.documentHeight returns the document height in pixels.
- Adds `ScaleManager#windowContraints`
- In 2.1.3 and prior the scale modes (EXACT_FIT, SHOW_ALL) were actually
based off the window dimensions, even though the parent element did
not correctly reflect this nature.
- When set (the default now is that right and bottom are set) the
behavior will mostly correctly mimic the 2.1.3 (minus bugs) and
before.
- CHANGE (from 2.1.3): The window constraints also affect the RESIZE
mode, arguably this is more consistent.
- To disable this "constrain to window" behavior, simply set the
appropriate property to false, as in:
`game.scale.windowConstraints.bottom = false`
- Sizing events:
- CHANGE: The `onResize` callback is called only from `preUpdate` (which
may be triggered from a window resize) and it will be called on
refreshes even if the parent size has not actually changed.
- A new `onSizeChange` Signal has been added. It is called _only_ when
the Game size or Game canvas size has changed and is generally more
applicable for performing layout updates.
- Game documentation now links to ScaleManager#setGameSize (which was
renamed from #setGameDimensions)
- Removed extra/legacy full-screen restore code
- Margins:
- Added `noMargins` flag; if set to true the Canvas margins will never
be altered. This also means that
- Margins are now set/cleared individually to avoid conflict with
'margins' style compound property
- Code consistency updates
- NOTE: Changing `game.width/game.height` via user code was always
problematic. This commit updates the documentation for such members as
read-only. The only supported way to change the GAME SIZE after it is
created is to use `ScaleManager#setGameDimensions`, which has been
added.
- The GAME SIZE will be reset to the initial (or as set by
`setGameDimensions`) values upon changing the scale mode or
entering/leaving full screen. This may be a breaking from 2.1.2 (but
many mode changes acted oddly prior).
- SHOW_ALL will now EXPAND it's parent container if it can. As per
@tjkopena 's notes, this should more closely represented the expected
behavior.
- SHOW_ALL will first try to expand by the OVERFLOW AXIS and then
attempt to resize to fit into the possibly larger area; use the
parent's max-height/max-width properties to limit how far SHOW_ALL can
expand.
- RE-BREAKING: This changes the behavior from 2.1.4 and makes it more like
2.1.3, with fixes.
- As per previous commit the ScaleManager _owns_ the margins and size of
the GAME CANVAS. To control the dimensions of the GAME CANVAS, use the min/max
height/width of the parent. Setting padding on the parent is _NOT_
supported.
- Fixes various issues with switching between Scale Modes
This includes some minor breaking changes.
- Unifies SHOW_ALL and NO_SCALE being stretched in Firefox and IE
- As suggested by MDN: "..to emulate WebKit's behavior on Gecko, you
need to place the element you want to present inside another
element.."
- This done via an (overwritable) `createFullScreenTarget` function.
The (new) DOM element returned from this is placed into the DOM and
the canvas is added to (and later removed) as the full screen mode
changes.
- MINOR BREAK: may affect code that assumes the Phaser canvas has a
fixed DOM/CSS path (which should hopefully be nobody). To use to the
original behavior, where the canvas is not moved, simply set
`this.fullScreenTarget = game.canvas` manually.
- Updates the refresh/queue to be unified and uses a smarter back-off to
detect and react to parent dimension changes
- Cleans up some odd browser issues; not tried on mobile
- Fixes an issue were update might be called too much and spend time
doing nothing useful.
- `maxIterations` is no longer user and marked as deprecated
- MINOR BREAK: previous approach would occasionally (but not always)
back off updates the entire iteration/setTimeout sequence; under the
new approach "onResize" may be called more frequently.
- Fixes a number various transition issues, mostly around RESIZE
- MINOR BREAK, but correct: leaving RESIZE restores the original game
size possible
- Fixes assorted quirks with scales not being updated
- Layout
- MINOR BREAK: All Canvas margins are "OWNED" by the ScaleManager. They
will be reset in all modes as appropriate. This is for consistency
fixes as well as coping with the updated full screen.
- MINOR BREAK: Canvas right/bottom margins are set to negative margins
to counter left/top margins. This prevents Canvas margin adjustments
from affecting the flow .. much.
- `getParentBounds` rounds to the nearest pixel to avoid "close to"
value propagation from CSS.
- Fixes page-align center pushing canvas out of parent
- Misc.
- MINOR BREAK: `setScreenSize` will update the game size if the mode is
RESIZE. User-code shoulde use `refresh` instead to ensure that any
relevant changes are propagated.
- Corrected incorrect documentation
- Added prefixed event handlers for IE; it still doesn't work in IE, but that is for other reasons
- Added monitoring of the fullscreenerror event, exposed as a fullScreenFailed signal
- Added `supportsFullScreen` a read-only flag that indicates that this ScaleManager even attempts to support such
- Specific bug fixes (example)
- Scale modes can now be set independently
- Switching between fullscreen and normal correctly restores modes
- Alignment does not incorrectly offset in fullscreen mode
- Changing scale/alignment promptly refreshes layout
- `isFullScreen` returns a boolean, as it should
- Faster parent checks (if required)
- NO_SCALE should not not scale (vs previous behavior of having no behavior)
- Correct usage of scaleMode depending on mode
- Removed / unified code-paths, which helped address several issues
- fullScreenTarget adjustment/restoration is less brutal
- Updated documentation
- pageAlign* works as alignment on the containing element. It should still work were it worked before (so this is not a breaking change) as well as being more universal.
- Added @protected and @private attributes
- Some methods were (implicitly) @public even though using them out of context is invalid
- API Breaking:
- Renamed some INTERNAL/@private methods
- Should only affect methods that were not valid/sane to use publically
- Event callbacks (ie. checkResize changed to resizeWindow) renamed for meaning
- Changed some INTERNAL semantics to better align with usage
- eg. `check*` methods separated from response-to-check
