Phaser
Phaser is a fast, free and fun open source HTML5 game framework. It uses Pixi.js for WebGL and Canvas rendering across desktop and mobile web browsers. Games can be compiled to iOS and Android apps via 3rd party tools.
Along with the fantastic open source community Phaser is actively developed and maintained by Photon Storm Limited. As a result of rapid support and a developer friendly API Phaser is currently one of the most starred game frameworks on Github.
Thousands of developers worldwide use it. From indies and multi-national digital agencies to schools and Universities. Each creating their own incredible games. Grab the source and join in the fun!
- Visit: The Phaser website and follow on Twitter (#phaserjs)
- Learn: API Documentation, Support Forum and StackOverflow
- Code: 500+ Source Examples (also available in this git repo)
- Read: Subscribe to the Newsletter and grab our Phaser Books
- Chat: #phaserio IRC channel on freenode
- Extend: With Phaser Plugins
- Be awesome: Support our work via Gratipay
Index
- What's New?
- Download Phaser
- Getting Started
- Using Phaser
- Games made with Phaser
- Requirements
- Road Map
- Change Log
- Contributing
What's new in Phaser 2.3.0
26th March 2015
Phaser 2.3.0 marks the second release in 2015 and easily one of our most significant for a while. In terms of API changes they're actually quite minimal, but under the hood we've taken Phaser for a serious workout.
We've traditionally had something of a 'kitchen sink' issue with Phaser. As we thought of great new features to give you we just added them in. And like too much of a good thing they contributed to an ever growing file size.
So two of the biggest changes 2.3.0 has is an internal shift to using Game Object components, and allowing you to exclude features in your own custom builds. The new build system lets you selectively exclude features from being bundled in: for example if your game doesn't need Gamepad or Keyboard support you can now tell Phaser to skip those parts entirely.
This tutorial explains the process in detail. But the end result is that thanks to these changes we've both managed to remove thousands of lines of code and let you decide what Phaser contains. The minimum build size is now just 83KB minified and gzipped and that's still including both the WebGL and Canvas renderers.
Even though we've been cutting down on size we still managed to pack a whole load of great new features in. For example the new spacial sorting added to Arcade Physics allows for incredible speed increases when dealing with densely populated game worlds. The Loader has received a complete overhaul - now offering full parallel asset loading, sync points and more! The Tilemap system was upgraded to support new Tiled 0.11 editor features. Audio has been also been enhanced, with better marker and loop handling. See the Change Log for all the details.
Your games will run faster, have a smaller footprint and load faster than ever.
But it's not just Phaser that has been updated - we also finally released the new Phaser web site! For the past few years it was a huge "wall of text", with hundreds of links filling up the single page site. Now it's all changed! with a much more attractive layout and structure. We've got a healthy and constantly updating news section, the examples have a great new visual showcase and there's even a Sandbox to play in.
It was a lot of hard work but we're super-happy with the result - and judging by our page hits, which are going off the charts, you are too :) We'll be sure to keep enhancing it over the coming months, especially as Phaser 3 development ramps up.
That's all for now. I hope you enjoy Phaser 2.3.0, the new site, the new features and the New Year. Happy coding everyone! See you on the forums.
Cheers,
Rich - @photonstorm
Download Phaser
Phaser is hosted on Github. There are a number of ways to download it:
- Clone the git repository via https, ssh or with the Github Windows or Mac clients.
- Download as zip or tar.gz
- Download just the build files: phaser.js and phaser.min.js
- Checkout with svn
Bower / npm
Install via bower
bower install phaser
Install via npm
npm install phaser
CDN
jsDelivr is a "super-fast CDN for developers". Include the following in your html:
<script src="//cdn.jsdelivr.net/phaser/2.3.0/phaser.js"></script>
or the minified version:
<script src="//cdn.jsdelivr.net/phaser/2.3.0/phaser.min.js"></script>
Phaser Sandbox
If you'd like to try coding in Phaser right now, with nothing more than your web browser then you can head over to the Phaser Sandbox. You'll find Quick Start templates and a user-friendly editor filled with handy code-completion features.
Koding
Want to try Phaser without downloading anything? Clone Phaser in Koding and start working right away in their web based development system.
License
Phaser is released under the MIT License.
Getting Started
We have a Getting Started Guide which covers all you need to begin developing games with Phaser. From setting up a web server, to picking an IDE and coding your first game.
Prefer videos to reading? Lynda.com have published a free course: HTML5 Game Development with Phaser
The single biggest Phaser resource is the new Phaser web site. It has hundreds of tutorials listed and fresh ones are added every week, so keep coming back to see what's new!
Using Phaser with TypeScript? Check out this great series of Game From Scratch tutorials.
Source Code Examples
Ever since we started Phaser we've been growing and expanding our extensive set of source code examples. Currently there are over 500 of them!
Browse the Phaser Examples or clone the examples repo and eat your heart out!
Phaser Books
We've been busy writing books about Phaser. Available now:
- A Guide to the Phaser Tween Manager Book + Code Bundle
- A Guide to the Phaser Scale Manager
With more on the way. Vote on the next title to be written.
Game Mechanic Explorer
The Game Mechanic Explorer is a great interactive way to learn how to develop specific game mechanics in Phaser. Well worth exploring once you've got your dev environment set-up.
Mighty Editor - Visual Game Editor
MightyEditor is a browser-based visual Phaser game editor. Create your maps with ease, position objects and share them in seconds. It also exports to native Phaser code. Excellent for quickly setting-up levels and scenes.
Using Phaser
Phaser is provided ready compiled in the build
folder of the repository. There are both plain and minified versions. The plain version is for use during development and the minified version for production.
Custom Builds
As of Phaser 2.3.0 we now include a brand new build system which allows you to strip out lots of additional features you may not require, saving hundreds of KB in the process. Don't use any Sound in your game? Then you can now exclude the entire sound system. Don't need Keyboard support? That can be stripped out too.
As a result of this work the minimum build size of Phaser is now just 83KB minified and gzipped.
See the Creating a Custom Phaser Build tutorial for details.
Building from source
Should you wish to build Phaser from source you can take advantage of the provided Grunt scripts. Ensure you have the required packages by running npm install
first.
Run grunt
to perform a default build to the dist
folder.
If you change either Pixi.js or P2 then use the Grunt tasks replace:pixi
and replace:p2
respectively. These tasks patch their UMD strings so they work properly with Phaser under requireJS.
Games made with Phaser
Thousands of games have been made in Phaser. From game jam entries to titles for some of the largest entertainment brands in the world. This is just a tiny sample.
Artwork copyright their respective owners.
We add new games to the Phaser site regularly, be sure to send us yours when it's finished!
Requirements
Phaser requires a web browser that supports the canvas tag. This includes Internet Explorer 9+, Firefox, Chrome, Safari and Opera on desktop. iOS Safari, Android Browser and Chrome for Android are supported on mobile.
While Phaser does its best to ensure a consistent cross-platform experience always be aware of browser and device limitations. This is especially important with regard to memory and GPU limitations on mobile, and legacy browser HTML5 compatibility.
IE9
If you need to support IE9 / Android 2.x and use P2 physics then you must use the polyfill in the resources/IE9 Polyfill
folder. If you don't use P2 (or don't care about IE9!) you can skip this.
JavaScript and TypeScript
Phaser is developed in JavaScript. We've made no assumptions about how you like to code and were careful not to impose a strict structure upon you. You won't find Phaser split into modules, requiring a build step, or making you use a class / inheritance OOP approach. That doesn't mean you can't do so, it just means we don't force you to. It's your choice.
If you code with TypeScript there are comprehensive definition files in the typescript
folder. They are for TypeScript 1.4+.
Road Map
All Phaser development is now taking place on the Phaser 3 project. The Phaser 2 branch will still be supported and issues fixed, but roadmap features have been migrated over to Phaser 3.
Phaser 3
We're now several months in to development of Phaser 3. We've been working hard on creating a brand new and extremely powerful renderer. Progress reports are posted to the web site and Phaser 3 repo.
There is still plenty of time to add your suggestions and feedback in this forum thread.
If you are an exceptional JavaScript developer and would like to join the Phaser 3 development team then let us know. We have a limited budget available to pay towards your time.
Change Log
Version 2.3.0 - "Tarabon" - 26th March 2015
Significant Updates
Game Objects and Components
All of the core Game Objects have received an important internal restructuring. We have moved all of the common functions to a new set of Component classes. They cover functionality such as 'Crop', 'Physics Body', 'InCamera' and more. You can find the source code to each component in the src/gameobjects/components
folder of the repo.
All of the Game Object classes have been restructured to use the new component approach. This puts an end to the "God classes" structure we had before and removes literally hundreds of lines of duplicate code. It also allowed us to add features to Game Objects; for example Bitmap Text objects are now full-class citizens with regard to physics capabilities.
Although this was a big internal shift from an API point of view not much changed - you still access the same methods and properties in the same way as before. Phaser is just a lot leaner under the hood now.
It's worth mentioning that from a JavaScript perspective components are mixins applied to the core game objects when Phaser is instantiated. They are not added at run-time or are dynamic (they never get removed from an object once added for example). Please understand that this is by design.
You can create your own custom Phaser classes, with your own set of active components by copying any of the pre-existing Game Objects and modifying them.
Custom Builds
As a result of the shift to components we went through the entire source base and optimised everything we could. Redundant paths were removed, debug flags removed and new stub classes and hooks were created. What this means is that it's now easier than ever to "disable" parts of Phaser and build your own custom version.
We have always included a couple of extra custom builds with Phaser. For example a build without P2 Physics included. But now you can strip out lots of additional features you may not require, saving hundreds of KB from your build file in the process. Don't use any Sound in your game? Then you can now exclude the entire sound system. Don't need Keyboard support? That can be stripped out too.
As a result of this work the minimum build size of Phaser is now just 83KB (minified and gzipped).
Please see the README instructions on how to create custom builds.
Arcade Physics
We've updated the core of Arcade Physics in a number of significant ways.
First we've dropped lots of internal private vars and moved to using non-cached local vars. Array lengths are no longer cached and we've implemented physicsType
properties on Game Objects to speed-up the core World collideHandler. All of these small changes have lead to a nice improvement in speed as a result, and also allows us to now offer things like physics enabled BitmapText objects.
More importantly we're now using a spacial pre-sort for all Sprite vs. Group and Group vs. Group collisions. You can define the direction the sort will prioritize via the new sortDirection
property. By default it is set to Phaser.Physics.Arcade.LEFT_RIGHT
. For example if you are making a horizontally scrolling game, where the player starts on the left of the world and moves to the right, then this sort order will allow the physics system to quickly eliminate any objects to the right of the player bounds. This cuts down on the sheer volume of actual collision checks needing to be made. In a densely populated level it can improve the fps rate dramatically.
There are 3 other directions available (RIGHT_LEFT
, TOP_BOTTOM
and BOTTOM_TOP
) and which one you need will depend on your game type. If you were making a vertically scrolling shoot-em-up then you'd pick BOTTOM_TOP
so it sorts all objects above and can bail out quickly. There is also SORT_NONE
if you would like to pre-sort the Groups yourself or disable this feature.
Another handy feature is that you can switch the sortDirection
at run-time with no loss of performance. Just make sure you do it before running any collision checks. So if you had a large 8-way scrolling world you could set the sortDirection
to match the direction the player was moving in and adjust it in real-time, getting the benefits as you go. My thanks to Aaron Lahman for inspiring this update.
Phaser.Loader
The Phaser.Loader has been updated to support parallel downloads which is now enabled by default (you can toggle it via the Loader.enableParallel
flag) as well as adding future extensibility points with a pack/file unified filelist and an inflight queue.
There are no known incompatibilities with the previous Loader. Be aware that with parallel downloading enabled the order of the Loader events may vary (as can be seen in the "Load Events" example).
The parallel file concurrency limit is available in Loader.maxParallelDownloads
and is set to 4 by default. Under simulated slower network connections parallel loading was a good bit faster than sequential loading. Even under a direct localhost connection parallel loading was never slower, but benefited most when loading many small assets (large assets are more limited by bandwidth); both results are fairly expected.
The Loader now supports synchronization points. An asset marked as a synchronization point must be loaded (or fail to load) before any subsequent assets can be loaded. This is enabled by using the withSyncPoint
and addSyncPoint
methods. Packs ('packfile' files) and Scripts ('script' files) are treated as synchronization points by default. This allows parallel downloads in general while allowing synchronization of select resources if required (packs, and potentially other assets in the future, can load-around synchronization points if they are written to delay final 'loading').
Additional error handling / guards have been added, and the reported error message has been made more consistent. Invalid XML (when loading) no longer throws an exception but fails the particular file/asset that was being loaded.
Some public methods/properties have been marked as protected, but no (except in case of a should-have-been-private-method) public-facing interfaces have been removed. Some private methods have been renamed and/or removed.
A new XHR object is created for each relevant asset (as there must be a different XHR for each asset loaded in parallel). Online searches indicated that there was no relevant benefit of XHR (as a particular use-case) re-use; and time will be dominated with the resource fetch. With the new flight queue an XHR cache could be re-added, at the cost of some complexity.
The URL is always transformed through transformUrl, which can make adding some one-off special cases like #1355 easier to deal with.
This also incorporates the fast-cache path for Images tags that can greatly speed up the responsiveness of image loading.
Loader.resetLocked is a boolean that allows you to control what happens when the loader is reset, which happens automatically on a State change. If you set resetLocked
to true
it allows you to populate the loader queue in one State, then swap to another State without having the queue erased, and start the load going from there. After the load has completed you could then disable the lock again as needed.
Thanks to @pnstickne for vast majority of this update.
Pixi v2
We are now using our own custom build of Pixi v2. The Pixi project has moved all development resources over to Pixi v3, but it wasn't ready in time for the release of Phaser 2.3 so we've started applying our own fixes to the version of Pixi that Phaser uses.
As a result we have removed all files from the src/pixi
folder that Phaser doesn't use, in order to make this distinction clearer.
We've also removed functions and properties from Pixi classes that Phaser doesn't require: such as the Interaction Manager, Stage.dirty, etc. This has helped us cut down the source code size and make the docs less confusing, as they no longer show properties for things that weren't even enabled.
We've rolled our own fixes into our version of Pixi, ensuring we keep it as bug-free as possible.
 Iftrue
theBody.preUpdate
method will be skipped, halting all motion for all bodies. Note that other methods such ascollide
will still work, so be careful not to call them on paused bodies.Arcade.Body.friction
allows you to have more fine-grained control over the amount of velocity passed between bodies on collision.- BitmapData.text will render the given string to the BitmapData, with optional font, color and shadow settings.
- MSPointer.capture allows you to optionally event.preventDefault the pointer events (was previously always on)
- MSPointer.event now stores the most recent pointer event.
- MSPointer.pointerDownCallback, pointerMoveCallback and pointerUpCallback all allow you to set your own event based callbacks.
- MSPointer.button now records which button was pressed down (if any)
- Phaser now supports rotated and flipped tiles in tilemaps, as exported from the Tiled map editor (thanks @nkholski #1608)
- TilemapParser now supports Tiled 0.11 version maps which includes the
rotation
property on all Object types. - Tilemap.createFromObjects now checks for a
rotation
property on the Object and if present will set it as the Sprite.angle (#1433) - If for whatever reason you wish to hide the Phaser banner in the console.log you can set
window.PhaserGlobal.hideBanner
totrue
and it will skip the output. Honestly I'd rather if you didn't, but the option is now there. - TilemapLayer.setScale will allow you to apply scaling to a specific Tilemap layer, i.e.
layer.setScale(2)
would double the size of the layer. The way the Camera responds to the layer is adjusted accordingly based on the scale, as is Arcade collision (thanks @mickez #1605) - SoundManager.setDecodedCallback lets you specify a list of Sound files, or keys, and a callback. Once all of the Sound files have finished decoding the callback will be invoked. The amount of time spent decoding depends on the codec used and file size. If all of the files given have already decoded the callback is triggered immediately.
- Sound.loopFull is a new method that will start playback of the Sound and set it to loop in its entirety.
- left, right, top and bottom are new properties that contain the totals of the Game Objects position and dimensions, adjusted for the anchor. These are available on any Game Object with the Bounds Component.
- Sprite.offsetX and Sprite.offsetY contain the offsets from the Sprite.x/y coordinates to the top-left of the Sprite, taking anchor into consideration.
- Emitter.flow now works in a slightly different (and more useful!) way. You can now specify a
quantity
and atotal
. Thequantity
controls how many particles are emitted every time the flow frequency is met. Thetotal
controls how many particles will be emitted in total. You can settotal
to be -1 and it will carry on emitting at the given frequency forever (also fixes #1598 thanks @brianbunch) - ArraySet.removeAll allows you to remove all members of an ArraySet and optionally call
destroy
on them as well. - GameObject.input.dragStartPoint now stores the coordinates the object was at when the drag started. This value is populated when the drag starts. It can be used to return an object to its pre-drag position, for example if it was dropped in an invalid place in-game.
- Text.padding specifies a padding value which is added to the line width and height when calculating the Text size. Allows you to add extra spacing if Phaser is unable to accurately determine the true font dimensions (#1561 #1518)
- P2 Capsule Shapes now support BodyDebug drawing (thanks @englercj #1686)
- Game Objects now have a new
physicsType
property. This maps to a Phaser const such asSPRITE
orGROUP
and allows Phaser to sort out pairings for collision checks in the core World collide handler much quicker than before. - BitmapText objects can now have physics enabled on them. When the physics body is first created it will use the dimensions of the BitmapText at the time you enable it. If you update the text it will adjust the body width and height as well, however any applied offset will be retained.
- BitmapText objects now have an
anchor
property. This works in a similar way to Sprite.anchor except that it offsets the position of each letter of the BitmapText by the given amount, based on the overall BitmapText width - whereas Sprite.anchor offsets the position the texture is drawn at.
Updates
- TypeScript definitions fixes and updates (thanks @Phaiax @Bilge @clark-stevenson @TimvdEijnden @belohlavek @ivw @vulvulune @zeh @englercj)
- There is a new TypeScript defs file (phaser.comments.d.ts) which now has all of the jsdocs included! (thanks @vulvulune #1559)
- Sound.fadeTween is now used for Sound.fadeIn and Sound.fadeOut audio tweens.
- Sound.stop and Sound.destroy now halt a fade tween if in effect.
- Arcade Physics
computeVelocity
now allows a max velocity of 0 allowing movement to be constrained to a single axis (thanks @zekoff #1594) - Added missing properties to the InputHandler prototype, reducing hidden class modifications.
- Updated docstrap-master toc.js to fix nav scrolling (thanks @abderrahmane-tj @vulvulune #1589)
- Added missing plugins member in Phaser.Game class (thanks @Bilge #1568)
- Lots of JSDocs fixes (thanks @vulvulune @micahjohnston @Marchys @JesseAldridge)
- TilemapLayer.getTiles now returns a copy of the Tiles found by the method, rather than references to the original Tile objects, so you're free to modify them without corrupting the source (thanks @Leekao #1585)
- Sprite.events.onDragStart has 2 new parameters
x
andy
which is the position of the Sprite before the drag was started. The full list of parameters is:(sprite, pointer, x, y)
. This allows you to retain the position of the Sprite prior to dragging shoulddragFromCenter
have been enabled (thanks @vulvulune #1583) - Body.reset now resets the Body.speed value to zero.
- Device.touch checks if
window.navigator.maxTouchPoints
is>= 1
rather than> 1
, which allows touch events to work properly in Chrome mobile emulation. - Loader.XDomainRequest wasn't used for atlas json loading. It has now been moved to the
xhrLoad
method to ensure it's used for all request if required (thanks @draconisNoctis #1601) - Loader.reset has a new optional 2nd parameter
clearEvents
which if set totrue
(the default is false) will reset all event listeners bound to the Loader. - If
Body.customSeparateX
orcustomSeparateY
istrue
then the Body will no longer be automatically separated from a Tilemap collision or exchange any velocity. The amount of pixels that the Body has intersected the tile is available inBody.overlapX
andoverlapY
, so you can use these values to perform your own separation in your collision callback (#992) - TilemapParser will now set the
.type
property for ObjectLayer Objects (thanks @mikaturunen #1609) - The Loader now directly calls StateManager.loadComplete rather than the StateManager listening for the loadComplete event, because Loader.reset unbinds this event (and it's easy to accidentally remove it too)
- Loader.onLoadComplete is dispatched before the Loader is reset. If you have a
create
method in your State please note that the Loader will have been reset before this method is called. This allows you to immediately re-use the Loader without having to first reset it manually. - World.setBounds will now adjust the World.x/y values to match those given (#1555)
- ArcadePhysics.distanceToPointer now calculates the distance in world space values.
- Sound.fadeIn now supports fading from a marker, as well as the entire audio clip, so now works with audio sprites (thanks @vorrin #1413)
- Text font components can now be specified as part of "style". There is a breaking change in that the
fontWeight
now only handles the CSS font-weight component. ThefontStyle
property handles 'italic', 'oblique', values from font-style. This makes the overall consistency cleaner but some code may need to be updated. This does not affect font-weight/font-style as with setStyle({font:..}). Also fixes overwrite font/size/weight oddities - which may result in different behavior for code that was relying on such. All of the text examples appear to work and modification using the new features (while respecting the change in previous behavior) work better (thanks @pnstickne #1375 #1370) - Loader.audiosprite has a new
jsonData
parameter. It allows you to pass a pre-existing JSON object (or a string which will be parsed as JSON) to use as the audiosprite data, instead of specifying a URL to a JSON file on the server (thanks @jounii #1447) - Loader.audiosprite has a new
autoDecode
parameter. Iftrue
the audio file will be decoded immediately upon load. - Tile.properties is now unique to that specific Tile, and not a reference to the Tileset index bound properties object. Tile.properties can now be modified freely without impacting other tiles sharing the same id (#1254)
- PIXI.TextureSilentFail is a boolean that defaults to
false
. Iftrue
thenPIXI.Texture.setFrame
will no longer throw an error if the texture dimensions are incorrect. InsteadTexture.valid
will be set tofalse
(#1556) - InputHandler.enableDrag with a boundsRect set now takes into account the Sprites anchor when limiting the drag (thanks @unindented #1593)
- InputHandler.enableDrag with a boundsSprite set now takes into account both the Sprites anchor and the boundsSprite anchor when limiting the drag.
- Sound in Web Audio now uses AudioContext.onended to trigger when it will stop playing instead of using a time based value. This is only used if the sound doesn't loop and isn't an audio sprite, but will give a much more accurate
Sound.onStop
event. It also prevents short audio files from being cut off during playback (#1471) and accounts for time spent decoding. - If you load an image and provide a key that was already in-use in the Cache, then the old image is now destroyed (via
Cache.removeImage
) and the new image takes its place. - BitmapText has a new
maxWidth
property that will attempt to wrap the text if it exceeds the width specified. - Group.cursorIndex is the index of the item the Group cursor points to. This replaces Group._cache[8].
- Tween.updateTweenData allows you to set a property to the given value across one or all of the current tweens. All of the Tween methods like Tween.delay and Tween.repeat have been updated to use this.
- Tween.repeat has a new parameter
repeatDelay
which allows you to set the delay (in ms) before a tween will repeat itself. - Tween.yoyo has a new parameter
yoyoDelay
which allows you to set the delay (in ms) before a tween will start a yoyo. - Tween.interpolation has a new parameter
context
which allows you to define the context in which the interpolation function will run. - ArraySet.getByKey gets an item from the set based on the property strictly equaling the value given.
- A State swap now sets the Loader.reset
hard
parameter totrue
by default. This will null any Loader.preloadSprite that may have been set. - You can now set a
resolution
property in your Game Configuration object. This will be read when the Pixi renderer instance is created and used to set the resolution within that (#1621) - Text style has a new optional property:
backgroundColor
which is a Canvas fill style that is set behind all Text in the Text object. It allows you to set a background color without having to use an additional Graphics object. - The Physics Manager now has a new
reset
method which will reset the active physics systems. This is called automatically on a State swap (thanks @englercj #1691) - When a State is started and linked to Phaser it has a new property created on it:
key
, which is the string identifier used by the State. - When the Game first boots it will now call
window.focus()
. This allows keyboard events to work properly in IE when the game is running inside an iframe. You can stop this from happening by settingwindow.PhaserGlobal.stopFocus = true
(thanks @webholics #1681) - When an Animation completes playback and isn't set to loop it would change the
currentFrame
property to be the first frame in the set after theonComplete
callback had fired. This meant if you set a Sprite to a new frame within an Animation onComplete callback then your change would have been overwritten by the animation itself. This is now no longer the case. - When an Emitter is destroyed via Emitter.destroy it now removes itself from the Phaser Particle Manager, freeing it up for garbage collection and stopping it from being processed.
Bug Fixes
- SoundManager.unlock checks for audio
start
support and falls back tonoteOn
if not found. - Sprite.frame and AnimationManager.frame wouldn't return the correct index if a sprite sheet was being used unless it had first been set via the setter.
- Error in diffX and diffY calculation in Tilemap.paste (thanks @amelia410 #1446)
- Fixed issue in PIXI.canUseNewCanvasBlendModes which would create false positives in browsers that supported
multiply
in Canvas path/fill ops, but not fordrawImage
(Samsung S5 for example). Now uses more accurate magenta / yellow mix test. - Fixed FrameData.getFrame index out of bound error (thanks @jromer94 #1581 #1547)
- In P2.Body calling adjust mass would desync the debug graphics from the real position of the body (thanks @tomlarkworthy #1549)
- Fix CORS loading of BitmapFonts with IE9 (thanks @jeppester #1565)
- TileSprites were not detecting Pointer up events correctly because of a branching condition (thanks @integricho #1580 #1551)
- TileSprites weren't destroying WebGL textures, leading to eventual out of memory errors (thanks @chacal #1563)
- P2.Body.clearCollision default values were incorrectly set to
false
if no parameters were provided, even though the docs said they weretrue
(thanks @brianbunch #1597) - BitmapText.font wouldn't update an internal Pixi property (fontName) causing the text to fail to change font (thanks @starnut #1602)
- Fixed issue in PIXI.Text where it was using the wrong string for descender text measurements.
- Sprite.loadTexture and Image.loadTexture now no longer call
updateTexture
if the texture given is a RenderTexture. This fixes issues with RetroFonts in IE11 WebGL as well as other RenderTexture related IE11 problems (#1310 #1381 #1523) - You can now tint animated Sprites in Canvas mode. Or change the texture atlas frame of a tinted Sprite or Image. Please note that this is pretty expensive (depending in the browser), as the tint is re-applied every time the frame changes. The Pixi tint cache has also been removed to allow for subtle tint color shifts and to avoid blowing up memory. So use this feature sparingly! But at least it does now work (#1070)
- ArcadePhysics.moveToPointer no longer goes crazy if the maxTime parameter is given and the Sprite is positioned in a larger game world (thanks @AnderbergE #1472)
- Sound.loop even when set for WebAudio wouldn't use the AudioContext loop property because Sound.start was being invoked with an offset and duration. Now if
loop
is true and no marker is being used it will use the native Web Audio loop support (#1431) - Timer.update was calling the TimerEvent callback even if
TimerEvent.pendingDelete
was already set totrue
, causing timer events to stack-up in cases where a new TimerEvent was generated in the callback (thanks @clowerweb #838) - Pointer.stop would call
event.preventDefault
ifPointer._stateReset
wastrue
, which is alwaystrue
after a State has changed and before Pointer.start has been called. However this broken interacting with DOM elements in the case where the State changes and you immediately try to use the DOM element without first having clicked on the Phaser game. An additional guard was added sopreventDefault
will now only be called if both_stateReste
andPointer.withinGame
are true (thanks @satan6 #1509) - Group.forEach (and many other Group methods) now uses the
children.length
value directly instead of caching it, which both helps performance and stops the loop from breaking should you remove a Group child in the invoked callback. - Phaser.Ellipse.contains is now working again (thanks @spayton #1524)
- PIXI.WebGLRenderer.destroy has been fixed to decrement the
glContextId
and remove it from the PIXI.instances global.Game.destroy
now hooks into this. This now means that you can now delete and create your Phaser game over and over without it crashing WebGL after the 4th attempt (#1260) - World.setBounds if called after you had already started P2 Physics would incorrectly create a new collision group for the wall objects. P2.World now remembers the settings you provide for each wall and the collision group, and re-applies these settings should the world dimensions ever change (thanks @nextht #1455)
- InputHandler was using the wrong property in
checkBoundsSprite
when fixedToCamera (thanks @yig #1613) - Tween.to now correctly accepts arrays are destination values, which makes the Tween interpolate through each value specified in the array using the defined Tween.interpolation method (see new example, thanks @FridayMarch26th #1619)
- Tween.interpolationFunction was using the incorrect context to invoke the function. This is now defined in
TweenData.interpolationContext
and defaults toPhaser.Math
. If you provide your own interpolation function then please adjust the context accordingly (thanks @FridayMarch26th #1618) - Graphics.drawEllipse method was missing (thanks @jackrugile #1574)
- A TweenData wouldn't take into account the
repeatDelay
property when repeating the tween, but now does. A TweenData also has a new propertyyoyoDelay
which controls the delay before the yoyo will start, allowing you to set both independently (thanks @DreadKnight #1469) - Animation.update skips ahead frames when the system is lagging, however it failed to set the animation to the final frame in the sequence if the animation skipped ahead too far (thanks @richpixel #1628)
- Loader.preloadSprite had an extra guard added to ensure it didn't try to updateCrop a non-existent sprite (thanks @noidexe #1636)
- The
TilemapParser
has had its row / column calculations updated to account for margins and and spacing on all sides of the tileset (thanks @zekoff #1642) - Any Tile set with alpha !== 1 would cause the whole layer to render incorrectly (thanks @nkholski #1666)
- P2 Debug Body class: The shape check in draw() needed to check for Convex last, since other shapes (like Rectangle) inherit from Convex (thanks @englercj #1674)
- P2 Debug Body class: The updateSpriteTransform() function needed to be called from the ctor. Otherwise bodies with no sprite (so no postUpdate call) would never be moved to draw in the correct position (thanks @englercj #1674)
- Animations are now guarded allowing Sprites with animations to be destroyed from within onUpdate, onLoop or onComplete events (thanks @pnstickne #1685 #1679)
- Text.lineSpacing can now accept negative values without cutting the bottom of the Text object off. The value can never be less than the height of a single line of text (thanks @anthonysapp #1690)
- Text.lineSpacing is no longer applied to the first line of Text, which prevents text from being cut off further down the Text object.
- If you paused a Sound object that is using audio markers and then resumed it, it wouldn't correctly calculate the resume duration - causing the sound to sometimes play into the marker that followed it (thanks @AnderbergE #1669)
- Animation.play wouldn't correctly set the play state on the Game Objects AnimationManager causing the animation to fail to start (calling AnimationManager.play did work however), now they're both consistently working.
- Graphics.drawArc would fail to draw any subsequent arcs if you set
beginFill
on it after drawing the first arc. - Graphics.drawArc would only move to the center position of the first arc created and ignore any subsequent arcs.
- Graphics.drawArc now correctly renders multiple arcs across both WebGL and Canvas. You no longer need to specifically call moveTo to move into the correct place to draw the arc.
- Graphics.drawArc now bails out if the startAngle = the endAngle and/or the sweep is invalid before adjusting any points.
- Graphics.drawArc now correctly handles the fill on the CanvasRenderer if the arc is a subsequent arc and no line style is set.
Pixi 2.2.8 Bug Fixes
- SpriteBatch added fix to handle batch context loss on change.
- RenderTexture resolution fix.
- WebGL Filter Resolution fix.
- TilingSprite fixes when masked in canvas mode.
- TilingSprite.destroy fixed if TilingSprite hasn't ever been rendered.
For changes in previous releases please see the extensive Version History.
Contributing
Please read the Contributors Guide for full details on helping with Phaser, but the main points are:
Found a bug? Report it on GitHub Issues and include a code sample.
Pull Requests should only be made against the
dev
branch. Never againstmaster
.Before submitting a Pull Request run your code through JSHint using our config.
Before contributing please read the code of conduct.
Written something cool that shows Phaser in use? Please tell us about it in our forum or email<EMAIL_ADDRESS>Phaser is a Photon Storm production.
Created by Richard Davey. Powered by coffee, anime, pixels and love.
The Phaser logo and characters are © 2015 Photon Storm Limited.
All rights reserved.


| 1 | /* =========================================================== | |
| 2 | * JFreeChart : a free chart library for the Java(tm) platform | |
| 3 | * =========================================================== | |
| 4 | * | |
| 5 | * (C) Copyright 2000-2009, by Object Refinery Limited and Contributors. | |
| 6 | * | |
| 7 | * Project Info: http://www.jfree.org/jfreechart/index.html | |
| 8 | * | |
| 9 | * This library is free software; you can redistribute it and/or modify it | |
| 10 | * under the terms of the GNU Lesser General Public License as published by | |
| 11 | * the Free Software Foundation; either version 2.1 of the License, or | |
| 12 | * (at your option) any later version. | |
| 13 | * | |
| 14 | * This library is distributed in the hope that it will be useful, but | |
| 15 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
| 16 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public | |
| 17 | * License for more details. | |
| 18 | * | |
| 19 | * You should have received a copy of the GNU Lesser General Public | |
| 20 | * License along with this library; if not, write to the Free Software | |
| 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, | |
| 22 | * USA. | |
| 23 | * | |
| 24 | * [Java is a trademark or registered trademark of Sun Microsystems, Inc. | |
| 25 | * in the United States and other countries.] | |
| 26 | * | |
| 27 | * -------------------------- | |
| 28 | * StackedXYAreaRenderer.java | |
| 29 | * -------------------------- | |
| 30 | * (C) Copyright 2003-2009, by Richard Atkinson and Contributors. | |
| 31 | * | |
| 32 | * Original Author: Richard Atkinson; | |
| 33 | * Contributor(s): Christian W. Zuckschwerdt; | |
| 34 | * David Gilbert (for Object Refinery Limited); | |
| 35 | * | |
| 36 | * Changes: | |
| 37 | * -------- | |
| 38 | * 27-Jul-2003 : Initial version (RA); | |
| 39 | * 30-Jul-2003 : Modified entity constructor (CZ); | |
| 40 | * 18-Aug-2003 : Now handles null values (RA); | |
| 41 | * 20-Aug-2003 : Implemented Cloneable, PublicCloneable and Serializable (DG); | |
| 42 | * 22-Sep-2003 : Changed to be a two pass renderer with optional shape Paint | |
| 43 | * and Stroke (RA); | |
| 44 | * 07-Oct-2003 : Added renderer state (DG); | |
| 45 | * 10-Feb-2004 : Updated state object and changed drawItem() method to make | |
| 46 | * overriding easier (DG); | |
| 47 | * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState. Renamed | |
| 48 | * XYToolTipGenerator --> XYItemLabelGenerator (DG); | |
| 49 | * 15-Jul-2004 : Switched getX() with getXValue() and getY() with | |
| 50 | * getYValue() (DG); | |
| 51 | * 10-Sep-2004 : Removed getRangeType() method (DG); | |
| 52 | * 11-Nov-2004 : Now uses ShapeUtilities to translate shapes (DG); | |
| 53 | * 06-Jan-2005 : Override equals() (DG); | |
| 54 | * 07-Jan-2005 : Update for method name changes in DatasetUtilities (DG); | |
| 55 | * 28-Mar-2005 : Use getXValue() and getYValue() from dataset (DG); | |
| 56 | * 06-Jun-2005 : Fixed null pointer exception, plus problems with equals() and | |
| 57 | * serialization (DG); | |
| 58 | * ------------- JFREECHART 1.0.x --------------------------------------------- | |
| 59 | * 10-Nov-2006 : Fixed bug 1593156, NullPointerException with line | |
| 60 | * plotting (DG); | |
| 61 | * 02-Feb-2007 : Fixed bug 1649686, crosshairs don't stack y-values (DG); | |
| 62 | * 06-Feb-2007 : Fixed bug 1086307, crosshairs with multiple axes (DG); | |
| 63 | * 22-Mar-2007 : Fire change events in setShapePaint() and setShapeStroke() | |
| 64 | * methods (DG); | |
| 65 | * 20-Apr-2007 : Updated getLegendItem() for renderer change (DG); | |
| 66 | * 21-Jun-2007 : Removed JCommon dependencies (DG); | |
| 67 | * 27-Jun-2007 : Updated drawItem() to use addEntity() (DG); | |
| 68 | * | |
| 69 | */ | |
| 70 | ||
| 71 | package org.jfree.chart.renderer.xy; | |
| 72 | ||
| 73 | import java.awt.Graphics2D; | |
| 74 | import java.awt.Paint; | |
| 75 | import java.awt.Point; | |
| 76 | import java.awt.Polygon; | |
| 77 | import java.awt.Shape; | |
| 78 | import java.awt.Stroke; | |
| 79 | import java.awt.geom.Line2D; | |
| 80 | import java.awt.geom.Rectangle2D; | |
| 81 | import java.io.IOException; | |
| 82 | import java.io.ObjectInputStream; | |
| 83 | import java.io.ObjectOutputStream; | |
| 84 | import java.io.Serializable; | |
| 85 | import java.util.Stack; | |
| 86 | ||
| 87 | import org.jfree.chart.axis.ValueAxis; | |
| 88 | import org.jfree.chart.entity.EntityCollection; | |
| 89 | import org.jfree.chart.event.RendererChangeEvent; | |
| 90 | import org.jfree.chart.labels.XYToolTipGenerator; | |
| 91 | import org.jfree.chart.plot.PlotOrientation; | |
| 92 | import org.jfree.chart.plot.PlotRenderingInfo; | |
| 93 | import org.jfree.chart.plot.XYCrosshairState; | |
| 94 | import org.jfree.chart.plot.XYPlot; | |
| 95 | import org.jfree.chart.urls.XYURLGenerator; | |
| 96 | import org.jfree.chart.util.ObjectUtilities; | |
| 97 | import org.jfree.chart.util.PaintUtilities; | |
| 98 | import org.jfree.chart.util.PublicCloneable; | |
| 99 | import org.jfree.chart.util.SerialUtilities; | |
| 100 | import org.jfree.chart.util.ShapeUtilities; | |
| 101 | import org.jfree.data.Range; | |
| 102 | import org.jfree.data.general.DatasetUtilities; | |
| 103 | import org.jfree.data.xy.TableXYDataset; | |
| 104 | import org.jfree.data.xy.XYDataset; | |
| 105 | ||
| 106 | /** | |
| 107 | * A stacked area renderer for the {@link XYPlot} class. | |
| 108 | *

 | |
| 109 | * The example shown here is generated by the | |
| 110 | * StackedXYAreaRendererDemo1.java program included in the | |
| 111 | * JFreeChart demo collection: | |
| 112 | *

 | |
| 113 | *  | |
| 115 | *

 | |
| 116 | * SPECIAL NOTE: This renderer does not currently handle negative data values | |
| 117 | * correctly. This should get fixed at some point, but the current workaround | |
| 118 | * is to use the {@link StackedXYAreaRenderer2} class instead. | |
| 119 | */ | |
| 120 | public class StackedXYAreaRenderer extends XYAreaRenderer | |
| 121 | implements Cloneable, PublicCloneable, Serializable { | |
| 122 | ||
| 123 | /** For serialization. */ | |
| 124 | private static final long serialVersionUID =<PHONE_NUMBER>178570889L; | |
| 125 | ||
| 126 | /** | |
| 127 | * A state object for use by this renderer. | |
| 128 | */ | |
| 129 | static class StackedXYAreaRendererState extends XYItemRendererState { | |
| 130 | ||
| 131 | /** The area for the current series. */ | |
| 132 | private Polygon seriesArea; | |
| 133 | ||
| 134 | /** The line. */ | |
| 135 | private Line2D line; | |
| 136 | ||
| 137 | /** The points from the last series. */ | |
| 138 | private Stack lastSeriesPoints; | |
| 139 | ||
| 140 | /** The points for the current series. */ | |
| 141 | private Stack currentSeriesPoints; | |
| 142 | ||
| 143 | /** | |
| 144 | * Creates a new state for the renderer. | |
| 145 | * | |
| 146 | * @param info the plot rendering info. | |
| 147 | */ | |
| 148 | public StackedXYAreaRendererState(PlotRenderingInfo info) { | |
| 149 | super(info); | |
| 150 | this.seriesArea = null; | |
| 151 | this.line = new Line2D.Double(); | |
| 152 | this.lastSeriesPoints = new Stack(); | |
| 153 | this.currentSeriesPoints = new Stack(); | |
| 154 | } | |
| 155 | ||
| 156 | /** | |
| 157 | * Returns the series area. | |
| 158 | * | |
| 159 | * @return The series area. | |
| 160 | */ | |
| 161 | public Polygon getSeriesArea() { | |
| 162 |
1
1. getSeriesArea : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::getSeriesArea to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.seriesArea; |
| 163 | } | |
| 164 | ||
| 165 | /** | |
| 166 | * Sets the series area. | |
| 167 | * | |
| 168 | * @param area the area. | |
| 169 | */ | |
| 170 | public void setSeriesArea(Polygon area) { | |
| 171 | this.seriesArea = area; | |
| 172 | } | |
| 173 | ||
| 174 | /** | |
| 175 | * Returns the working line. | |
| 176 | * | |
| 177 | * @return The working line. | |
| 178 | */ | |
| 179 | public Line2D getLine() { | |
| 180 |
1
1. getLine : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::getLine to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.line; |
| 181 | } | |
| 182 | ||
| 183 | /** | |
| 184 | * Returns the current series points. | |
| 185 | * | |
| 186 | * @return The current series points. | |
| 187 | */ | |
| 188 | public Stack getCurrentSeriesPoints() { | |
| 189 |
1
1. getCurrentSeriesPoints : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::getCurrentSeriesPoints to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.currentSeriesPoints; |
| 190 | } | |
| 191 | ||
| 192 | /** | |
| 193 | * Sets the current series points. | |
| 194 | * | |
| 195 | * @param points the points. | |
| 196 | */ | |
| 197 | public void setCurrentSeriesPoints(Stack points) { | |
| 198 | this.currentSeriesPoints = points; | |
| 199 | } | |
| 200 | ||
| 201 | /** | |
| 202 | * Returns the last series points. | |
| 203 | * | |
| 204 | * @return The last series points. | |
| 205 | */ | |
| 206 | public Stack getLastSeriesPoints() { | |
| 207 |
1
1. getLastSeriesPoints : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::getLastSeriesPoints to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return this.lastSeriesPoints; |
| 208 | } | |
| 209 | ||
| 210 | /** | |
| 211 | * Sets the last series points. | |
| 212 | * | |
| 213 | * @param points the points. | |
| 214 | */ | |
| 215 | public void setLastSeriesPoints(Stack points) { | |
| 216 | this.lastSeriesPoints = points; | |
| 217 | } | |
| 218 | ||
| 219 | } | |
| 220 | ||
| 221 | /** | |
| 222 | * Custom Paint for drawing all shapes, if null defaults to series shapes | |
| 223 | */ | |
| 224 | private transient Paint shapePaint = null; | |
| 225 | ||
| 226 | /** | |
| 227 | * Custom Stroke for drawing all shapes, if null defaults to series | |
| 228 | * strokes. | |
| 229 | */ | |
| 230 | private transient Stroke shapeStroke = null; | |
| 231 | ||
| 232 | /** | |
| 233 | * Creates a new renderer. | |
| 234 | */ | |
| 235 | public StackedXYAreaRenderer() { | |
| 236 | this(AREA); | |
| 237 | } | |
| 238 | ||
| 239 | /** | |
| 240 | * Constructs a new renderer. | |
| 241 | * | |
| 242 | * @param type the type of the renderer. | |
| 243 | */ | |
| 244 | public StackedXYAreaRenderer(int type) { | |
| 245 | this(type, null, null); | |
| 246 | } | |
| 247 | ||
| 248 | /** | |
| 249 | * Constructs a new renderer. To specify the type of renderer, use one of | |
| 250 | * the constants: SHAPES, LINES, | |
| 251 | * SHAPES_AND_LINES, AREA or | |
| 252 | * AREA_AND_SHAPES. | |
| 253 | * | |
| 254 | * @param type the type of renderer. | |
| 255 | * @param labelGenerator the tool tip generator to use (null | |
| 256 | * is none). | |
| 257 | * @param urlGenerator the URL generator (null permitted). | |
| 258 | */ | |
| 259 | public StackedXYAreaRenderer(int type, | |
| 260 | XYToolTipGenerator labelGenerator, | |
| 261 | XYURLGenerator urlGenerator) { | |
| 262 | ||
| 263 | super(type, labelGenerator, urlGenerator); | |
| 264 | } | |
| 265 | ||
| 266 | /** | |
| 267 | * Returns the paint used for rendering shapes, or null if | |
| 268 | * using series paints. | |
| 269 | * | |
| 270 | * @return The paint (possibly null). | |
| 271 | * | |
| 272 | * @see #setShapePaint(Paint) | |
| 273 | */ | |
| 274 | public Paint getShapePaint() { | |
| 275 |
1
1. getShapePaint : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::getShapePaint to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.shapePaint; |
| 276 | } | |
| 277 | ||
| 278 | /** | |
| 279 | * Sets the paint for rendering shapes and sends a | |
| 280 | * {@link RendererChangeEvent} to all registered listeners. | |
| 281 | * | |
| 282 | * @param shapePaint the paint (null permitted). | |
| 283 | * | |
| 284 | * @see #getShapePaint() | |
| 285 | */ | |
| 286 | public void setShapePaint(Paint shapePaint) { | |
| 287 | this.shapePaint = shapePaint; | |
| 288 |
1
1. setShapePaint : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 289 | } | |
| 290 | ||
| 291 | /** | |
| 292 | * Returns the stroke used for rendering shapes, or null if | |
| 293 | * using series strokes. | |
| 294 | * | |
| 295 | * @return The stroke (possibly null). | |
| 296 | * | |
| 297 | * @see #setShapeStroke(Stroke) | |
| 298 | */ | |
| 299 | public Stroke getShapeStroke() { | |
| 300 |
1
1. getShapeStroke : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::getShapeStroke to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this.shapeStroke; |
| 301 | } | |
| 302 | ||
| 303 | /** | |
| 304 | * Sets the stroke for rendering shapes and sends a | |
| 305 | * {@link RendererChangeEvent} to all registered listeners. | |
| 306 | * | |
| 307 | * @param shapeStroke the stroke (null permitted). | |
| 308 | * | |
| 309 | * @see #getShapeStroke() | |
| 310 | */ | |
| 311 | public void setShapeStroke(Stroke shapeStroke) { | |
| 312 | this.shapeStroke = shapeStroke; | |
| 313 |
1
1. setShapeStroke : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer::fireChangeEvent → SURVIVED |
fireChangeEvent(); |
| 314 | } | |
| 315 | ||
| 316 | /** | |
| 317 | * Initialises the renderer. This method will be called before the first | |
| 318 | * item is rendered, giving the renderer an opportunity to initialise any | |
| 319 | * state information it wants to maintain. | |
| 320 | * | |
| 321 | * @param g2 the graphics device. | |
| 322 | * @param dataArea the area inside the axes. | |
| 323 | * @param plot the plot. | |
| 324 | * @param data the data. | |
| 325 | * @param info an optional info collection object to return data back to | |
| 326 | * the caller. | |
| 327 | * | |
| 328 | * @return A state object that should be passed to subsequent calls to the | |
| 329 | * drawItem() method. | |
| 330 | */ | |
| 331 | public XYItemRendererState initialise(Graphics2D g2, | |
| 332 | Rectangle2D dataArea, | |
| 333 | XYPlot plot, | |
| 334 | XYDataset data, | |
| 335 | PlotRenderingInfo info) { | |
| 336 | ||
| 337 | XYItemRendererState state = new StackedXYAreaRendererState(info); | |
| 338 | // in the rendering process, there is special handling for item | |
| 339 | // zero, so we can't support processing of visible data items only | |
| 340 |
1
1. initialise : removed call to org/jfree/chart/renderer/xy/XYItemRendererState::setProcessVisibleItemsOnly → SURVIVED |
state.setProcessVisibleItemsOnly(false); |
| 341 |
1
1. initialise : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::initialise to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return state; |
| 342 | } | |
| 343 | ||
| 344 | /** | |
| 345 | * Returns the number of passes required by the renderer. | |
| 346 | * | |
| 347 | * @return 2. | |
| 348 | */ | |
| 349 | public int getPassCount() { | |
| 350 |
1
1. getPassCount : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return 2; |
| 351 | } | |
| 352 | ||
| 353 | /** | |
| 354 | * Returns the range of values the renderer requires to display all the | |
| 355 | * items from the specified dataset. | |
| 356 | * | |
| 357 | * @param dataset the dataset (null permitted). | |
| 358 | * | |
| 359 | * @return The range ([0.0, 0.0] if the dataset contains no values, and | |
| 360 | * null if the dataset is null). | |
| 361 | * | |
| 362 | * @throws ClassCastException if dataset is not an instance | |
| 363 | * of {@link TableXYDataset}. | |
| 364 | */ | |
| 365 | public Range findRangeBounds(XYDataset dataset) { | |
| 366 |
1
1. findRangeBounds : negated conditional → SURVIVED |
if (dataset != null) { |
| 367 |
1
1. findRangeBounds : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::findRangeBounds to ( if (x != null) null else throw new RuntimeException ) → SURVIVED |
return DatasetUtilities.findStackedRangeBounds( |
| 368 | (TableXYDataset) dataset); | |
| 369 | } | |
| 370 | else { | |
| 371 |
1
1. findRangeBounds : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::findRangeBounds to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return null; |
| 372 | } | |
| 373 | } | |
| 374 | ||
| 375 | /** | |
| 376 | * Draws the visual representation of a single data item. | |
| 377 | * | |
| 378 | * @param g2 the graphics device. | |
| 379 | * @param state the renderer state. | |
| 380 | * @param dataArea the area within which the data is being drawn. | |
| 381 | * @param plot the plot (can be used to obtain standard color information | |
| 382 | * etc). | |
| 383 | * @param domainAxis the domain axis. | |
| 384 | * @param rangeAxis the range axis. | |
| 385 | * @param dataset the dataset. | |
| 386 | * @param series the series index (zero-based). | |
| 387 | * @param item the item index (zero-based). | |
| 388 | * @param pass the pass index. | |
| 389 | * | |
| 390 | * @throws ClassCastException if state is not an instance of | |
| 391 | * StackedXYAreaRendererState or dataset | |
| 392 | * is not an instance of {@link TableXYDataset}. | |
| 393 | */ | |
| 394 | public void drawItem(Graphics2D g2, XYItemRendererState state, | |
| 395 | Rectangle2D dataArea, XYPlot plot, ValueAxis domainAxis, | |
| 396 | ValueAxis rangeAxis, XYDataset dataset, int series, int item, | |
| 397 | boolean selected, int pass) { | |
| 398 | ||
| 399 | PlotOrientation orientation = plot.getOrientation(); | |
| 400 | StackedXYAreaRendererState areaState | |
| 401 | = (StackedXYAreaRendererState) state; | |
| 402 | // Get the item count for the series, so that we can know which is the | |
| 403 | // end of the series. | |
| 404 | TableXYDataset tdataset = (TableXYDataset) dataset; | |
| 405 | int itemCount = tdataset.getItemCount(); | |
| 406 | ||
| 407 | // get the data point... | |
| 408 | double x1 = dataset.getXValue(series, item); | |
| 409 | double y1 = dataset.getYValue(series, item); | |
| 410 | boolean nullPoint = false; | |
| 411 |
1
1. drawItem : negated conditional → SURVIVED |
if (Double.isNaN(y1)) { |
| 412 | y1 = 0.0; | |
| 413 | nullPoint = true; | |
| 414 | } | |
| 415 | ||
| 416 | // Get height adjustment based on stack and translate to Java2D values | |
| 417 | double ph1 = getPreviousHeight(tdataset, series, item); | |
| 418 | double transX1 = domainAxis.valueToJava2D(x1, dataArea, | |
| 419 | plot.getDomainAxisEdge()); | |
| 420 |
1
1. drawItem : Replaced double addition with subtraction → SURVIVED |
double transY1 = rangeAxis.valueToJava2D(y1 + ph1, dataArea, |
| 421 | plot.getRangeAxisEdge()); | |
| 422 | ||
| 423 | Paint seriesPaint = getItemPaint(series, item, selected); | |
| 424 | Stroke seriesStroke = getItemStroke(series, item, selected); | |
| 425 | ||
| 426 |
1
1. drawItem : negated conditional → SURVIVED |
if (pass == 0) { |
| 427 | // On first pass render the areas, line and outlines | |
| 428 | ||
| 429 |
1
1. drawItem : negated conditional → KILLED |
if (item == 0) { |
| 430 | // Create a new Area for the series | |
| 431 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::setSeriesArea → KILLED |
areaState.setSeriesArea(new Polygon()); |
| 432 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::setLastSeriesPoints → SURVIVED |
areaState.setLastSeriesPoints( |
| 433 | areaState.getCurrentSeriesPoints()); | |
| 434 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer$StackedXYAreaRendererState::setCurrentSeriesPoints → SURVIVED |
areaState.setCurrentSeriesPoints(new Stack()); |
| 435 | ||
| 436 | // start from previous height (ph1) | |
| 437 | double transY2 = rangeAxis.valueToJava2D(ph1, dataArea, | |
| 438 | plot.getRangeAxisEdge()); | |
| 439 | ||
| 440 | // The first point is (x, 0) | |
| 441 |
1
1. drawItem : negated conditional → SURVIVED |
if (orientation == PlotOrientation.VERTICAL) { |
| 442 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → SURVIVED |
areaState.getSeriesArea().addPoint((int) transX1, |
| 443 | (int) transY2); | |
| 444 | } | |
| 445 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (orientation == PlotOrientation.HORIZONTAL) { |
| 446 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → NO_COVERAGE |
areaState.getSeriesArea().addPoint((int) transY2, |
| 447 | (int) transX1); | |
| 448 | } | |
| 449 | } | |
| 450 | ||
| 451 | // Add each point to Area (x, y) | |
| 452 |
1
1. drawItem : negated conditional → SURVIVED |
if (orientation == PlotOrientation.VERTICAL) { |
| 453 | Point point = new Point((int) transX1, (int) transY1); | |
| 454 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → SURVIVED |
areaState.getSeriesArea().addPoint((int) point.getX(), |
| 455 | (int) point.getY()); | |
| 456 | areaState.getCurrentSeriesPoints().push(point); | |
| 457 | } | |
| 458 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (orientation == PlotOrientation.HORIZONTAL) { |
| 459 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → NO_COVERAGE |
areaState.getSeriesArea().addPoint((int) transY1, |
| 460 | (int) transX1); | |
| 461 | } | |
| 462 | ||
| 463 |
1
1. drawItem : negated conditional → SURVIVED |
if (getPlotLines()) { |
| 464 |
2
1. drawItem : changed conditional boundary → KILLED 2. drawItem : negated conditional → KILLED |
if (item > 0) { |
| 465 | // get the previous data point... | |
| 466 |
1
1. drawItem : Replaced integer subtraction with addition → KILLED |
double x0 = dataset.getXValue(series, item - 1); |
| 467 |
1
1. drawItem : Replaced integer subtraction with addition → KILLED |
double y0 = dataset.getYValue(series, item - 1); |
| 468 |
1
1. drawItem : Replaced integer subtraction with addition → KILLED |
double ph0 = getPreviousHeight(tdataset, series, item - 1); |
| 469 | double transX0 = domainAxis.valueToJava2D(x0, dataArea, | |
| 470 | plot.getDomainAxisEdge()); | |
| 471 |
1
1. drawItem : Replaced double addition with subtraction → SURVIVED |
double transY0 = rangeAxis.valueToJava2D(y0 + ph0, |
| 472 | dataArea, plot.getRangeAxisEdge()); | |
| 473 | ||
| 474 |
1
1. drawItem : negated conditional → SURVIVED |
if (orientation == PlotOrientation.VERTICAL) { |
| 475 |
1
1. drawItem : removed call to java/awt/geom/Line2D::setLine → SURVIVED |
areaState.getLine().setLine(transX0, transY0, transX1, |
| 476 | transY1); | |
| 477 | } | |
| 478 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (orientation == PlotOrientation.HORIZONTAL) { |
| 479 |
1
1. drawItem : removed call to java/awt/geom/Line2D::setLine → NO_COVERAGE |
areaState.getLine().setLine(transY0, transX0, transY1, |
| 480 | transX1); | |
| 481 | } | |
| 482 |
1
1. drawItem : removed call to java/awt/Graphics2D::draw → SURVIVED |
g2.draw(areaState.getLine()); |
| 483 | } | |
| 484 | } | |
| 485 | ||
| 486 | // Check if the item is the last item for the series and number of | |
| 487 | // items > 0. We can't draw an area for a single point. | |
| 488 |
5
1. drawItem : changed conditional boundary → SURVIVED 2. drawItem : Replaced integer subtraction with addition → SURVIVED 3. drawItem : negated conditional → SURVIVED 4. drawItem : negated conditional → SURVIVED 5. drawItem : negated conditional → SURVIVED |
if (getPlotArea() && item > 0 && item == (itemCount - 1)) { |
| 489 | ||
| 490 | double transY2 = rangeAxis.valueToJava2D(ph1, dataArea, | |
| 491 | plot.getRangeAxisEdge()); | |
| 492 | ||
| 493 |
1
1. drawItem : negated conditional → SURVIVED |
if (orientation == PlotOrientation.VERTICAL) { |
| 494 | // Add the last point (x,0) | |
| 495 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → SURVIVED |
areaState.getSeriesArea().addPoint((int) transX1, |
| 496 | (int) transY2); | |
| 497 | } | |
| 498 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (orientation == PlotOrientation.HORIZONTAL) { |
| 499 | // Add the last point (x,0) | |
| 500 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → NO_COVERAGE |
areaState.getSeriesArea().addPoint((int) transY2, |
| 501 | (int) transX1); | |
| 502 | } | |
| 503 | ||
| 504 | // Add points from last series to complete the base of the | |
| 505 | // polygon | |
| 506 |
1
1. drawItem : negated conditional → SURVIVED |
if (series != 0) { |
| 507 | Stack points = areaState.getLastSeriesPoints(); | |
| 508 |
1
1. drawItem : negated conditional → KILLED |
while (!points.empty()) { |
| 509 | Point point = (Point) points.pop(); | |
| 510 |
1
1. drawItem : removed call to java/awt/Polygon::addPoint → NO_COVERAGE |
areaState.getSeriesArea().addPoint((int) point.getX(), |
| 511 | (int) point.getY()); | |
| 512 | } | |
| 513 | } | |
| 514 | ||
| 515 | // Fill the polygon | |
| 516 |
1
1. drawItem : removed call to java/awt/Graphics2D::setPaint → SURVIVED |
g2.setPaint(seriesPaint); |
| 517 |
1
1. drawItem : removed call to java/awt/Graphics2D::setStroke → SURVIVED |
g2.setStroke(seriesStroke); |
| 518 |
1
1. drawItem : removed call to java/awt/Graphics2D::fill → SURVIVED |
g2.fill(areaState.getSeriesArea()); |
| 519 | ||
| 520 | // Draw an outline around the Area. | |
| 521 |
1
1. drawItem : negated conditional → SURVIVED |
if (isOutline()) { |
| 522 |
1
1. drawItem : removed call to java/awt/Graphics2D::setStroke → NO_COVERAGE |
g2.setStroke(lookupSeriesOutlineStroke(series)); |
| 523 |
1
1. drawItem : removed call to java/awt/Graphics2D::setPaint → NO_COVERAGE |
g2.setPaint(lookupSeriesOutlinePaint(series)); |
| 524 |
1
1. drawItem : removed call to java/awt/Graphics2D::draw → NO_COVERAGE |
g2.draw(areaState.getSeriesArea()); |
| 525 | } | |
| 526 | } | |
| 527 | ||
| 528 | int domainAxisIndex = plot.getDomainAxisIndex(domainAxis); | |
| 529 | int rangeAxisIndex = plot.getRangeAxisIndex(rangeAxis); | |
| 530 | XYCrosshairState crosshairState = state.getCrosshairState(); | |
| 531 |
2
1. drawItem : Replaced double addition with subtraction → SURVIVED 2. drawItem : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer::updateCrosshairValues → SURVIVED |
updateCrosshairValues(crosshairState, x1, ph1 + y1, |
| 532 | domainAxisIndex, rangeAxisIndex, transX1, transY1, | |
| 533 | orientation); | |
| 534 | ||
| 535 | } | |
| 536 |
1
1. drawItem : negated conditional → SURVIVED |
else if (pass == 1) { |
| 537 | // On second pass render shapes and collect entity and tooltip | |
| 538 | // information | |
| 539 | ||
| 540 | Shape shape = null; | |
| 541 |
1
1. drawItem : negated conditional → SURVIVED |
if (getPlotShapes()) { |
| 542 | shape = getItemShape(series, item, selected); | |
| 543 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (plot.getOrientation() == PlotOrientation.VERTICAL) { |
| 544 | shape = ShapeUtilities.createTranslatedShape(shape, | |
| 545 | transX1, transY1); | |
| 546 | } | |
| 547 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (plot.getOrientation() == PlotOrientation.HORIZONTAL) { |
| 548 | shape = ShapeUtilities.createTranslatedShape(shape, | |
| 549 | transY1, transX1); | |
| 550 | } | |
| 551 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (!nullPoint) { |
| 552 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (getShapePaint() != null) { |
| 553 |
1
1. drawItem : removed call to java/awt/Graphics2D::setPaint → NO_COVERAGE |
g2.setPaint(getShapePaint()); |
| 554 | } | |
| 555 | else { | |
| 556 |
1
1. drawItem : removed call to java/awt/Graphics2D::setPaint → NO_COVERAGE |
g2.setPaint(seriesPaint); |
| 557 | } | |
| 558 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (getShapeStroke() != null) { |
| 559 |
1
1. drawItem : removed call to java/awt/Graphics2D::setStroke → NO_COVERAGE |
g2.setStroke(getShapeStroke()); |
| 560 | } | |
| 561 | else { | |
| 562 |
1
1. drawItem : removed call to java/awt/Graphics2D::setStroke → NO_COVERAGE |
g2.setStroke(seriesStroke); |
| 563 | } | |
| 564 |
1
1. drawItem : removed call to java/awt/Graphics2D::draw → NO_COVERAGE |
g2.draw(shape); |
| 565 | } | |
| 566 | } | |
| 567 | else { | |
| 568 |
1
1. drawItem : negated conditional → SURVIVED |
if (plot.getOrientation() == PlotOrientation.VERTICAL) { |
| 569 |
2
1. drawItem : Replaced double subtraction with addition → SURVIVED 2. drawItem : Replaced double subtraction with addition → SURVIVED |
shape = new Rectangle2D.Double(transX1 - 3, transY1 - 3, |
| 570 | 6.0, 6.0); | |
| 571 | } | |
| 572 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (plot.getOrientation() == PlotOrientation.HORIZONTAL) { |
| 573 |
2
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE 2. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
shape = new Rectangle2D.Double(transY1 - 3, transX1 - 3, |
| 574 | 6.0, 6.0); | |
| 575 | } | |
| 576 | } | |
| 577 | EntityCollection entities = state.getEntityCollection(); | |
| 578 |
1
1. drawItem : negated conditional → KILLED |
if (entities != null) { |
| 579 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/StackedXYAreaRenderer::addEntity → NO_COVERAGE |
addEntity(entities, shape, dataset, series, item, selected, |
| 580 | 0.0, 0.0); | |
| 581 | } | |
| 582 | } | |
| 583 | } | |
| 584 | ||
| 585 | /** | |
| 586 | * Calculates the stacked value of the all series up to, but not including | |
| 587 | * series for the specified item. It returns 0.0 if | |
| 588 | * series is the first series, i.e. 0. | |
| 589 | * | |
| 590 | * @param dataset the dataset. | |
| 591 | * @param series the series. | |
| 592 | * @param index the index. | |
| 593 | * | |
| 594 | * @return The cumulative value for all series' values up to but excluding | |
| 595 | * series for index. | |
| 596 | */ | |
| 597 | protected double getPreviousHeight(TableXYDataset dataset, | |
| 598 | int series, int index) { | |
| 599 | double result = 0.0; | |
| 600 |
3
1. getPreviousHeight : changed conditional boundary → SURVIVED 2. getPreviousHeight : Changed increment from 1 to -1 → KILLED 3. getPreviousHeight : negated conditional → KILLED |
for (int i = 0; i < series; i++) { |
| 601 | double value = dataset.getYValue(i, index); | |
| 602 |
1
1. getPreviousHeight : negated conditional → SURVIVED |
if (!Double.isNaN(value)) { |
| 603 |
1
1. getPreviousHeight : Replaced double addition with subtraction → SURVIVED |
result += value; |
| 604 | } | |
| 605 | } | |
| 606 |
1
1. getPreviousHeight : replaced return of double value with -(x + 1) for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::getPreviousHeight → SURVIVED |
return result; |
| 607 | } | |
| 608 | ||
| 609 | /** | |
| 610 | * Tests the renderer for equality with an arbitrary object. | |
| 611 | * | |
| 612 | * @param obj the object (null permitted). | |
| 613 | * | |
| 614 | * @return A boolean. | |
| 615 | */ | |
| 616 | public boolean equals(Object obj) { | |
| 617 |
1
1. equals : negated conditional → KILLED |
if (obj == this) { |
| 618 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 619 | } | |
| 620 |
2
1. equals : negated conditional → KILLED 2. equals : negated conditional → KILLED |
if (!(obj instanceof StackedXYAreaRenderer) || !super.equals(obj)) { |
| 621 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 622 | } | |
| 623 | StackedXYAreaRenderer that = (StackedXYAreaRenderer) obj; | |
| 624 |
1
1. equals : negated conditional → KILLED |
if (!PaintUtilities.equal(this.shapePaint, that.shapePaint)) { |
| 625 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 626 | } | |
| 627 |
1
1. equals : negated conditional → KILLED |
if (!ObjectUtilities.equal(this.shapeStroke, that.shapeStroke)) { |
| 628 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 629 | } | |
| 630 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return true; |
| 631 | } | |
| 632 | ||
| 633 | /** | |
| 634 | * Returns a clone of the renderer. | |
| 635 | * | |
| 636 | * @return A clone. | |
| 637 | * | |
| 638 | * @throws CloneNotSupportedException if the renderer cannot be cloned. | |
| 639 | */ | |
| 640 | public Object clone() throws CloneNotSupportedException { | |
| 641 |
1
1. clone : mutated return of Object value for org/jfree/chart/renderer/xy/StackedXYAreaRenderer::clone to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return super.clone(); |
| 642 | } | |
| 643 | ||
| 644 | /** | |
| 645 | * Provides serialization support. | |
| 646 | * | |
| 647 | * @param stream the input stream. | |
| 648 | * | |
| 649 | * @throws IOException if there is an I/O error. | |
| 650 | * @throws ClassNotFoundException if there is a classpath problem. | |
| 651 | */ | |
| 652 | private void readObject(ObjectInputStream stream) | |
| 653 | throws IOException, ClassNotFoundException { | |
| 654 |
1
1. readObject : removed call to java/io/ObjectInputStream::defaultReadObject → SURVIVED |
stream.defaultReadObject(); |
| 655 | this.shapePaint = SerialUtilities.readPaint(stream); | |
| 656 | this.shapeStroke = SerialUtilities.readStroke(stream); | |
| 657 | } | |
| 658 | ||
| 659 | /** | |
| 660 | * Provides serialization support. | |
| 661 | * | |
| 662 | * @param stream the output stream. | |
| 663 | * | |
| 664 | * @throws IOException if there is an I/O error. | |
| 665 | */ | |
| 666 | private void writeObject(ObjectOutputStream stream) throws IOException { | |
| 667 |
1
1. writeObject : removed call to java/io/ObjectOutputStream::defaultWriteObject → SURVIVED |
stream.defaultWriteObject(); |
| 668 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writePaint → KILLED |
SerialUtilities.writePaint(this.shapePaint, stream); |
| 669 |
1
1. writeObject : removed call to org/jfree/chart/util/SerialUtilities::writeStroke → KILLED |
SerialUtilities.writeStroke(this.shapeStroke, stream); |
| 670 | } | |
| 671 | ||
| 672 | } | |
Mutations | ||
| 162 |
1.1 |
|
| 180 |
1.1 |
|
| 189 |
1.1 |
|
| 207 |
1.1 |
|
| 275 |
1.1 |
|
| 288 |
1.1 |
|
| 300 |
1.1 |
|
| 313 |
1.1 |
|
| 340 |
1.1 |
|
| 341 |
1.1 |
|
| 350 |
1.1 |
|
| 366 |
1.1 |
|
| 367 |
1.1 |
|
| 371 |
1.1 |
|
| 411 |
1.1 |
|
| 420 |
1.1 |
|
| 426 |
1.1 |
|
| 429 |
1.1 |
|
| 431 |
1.1 |
|
| 432 |
1.1 |
|
| 434 |
1.1 |
|
| 441 |
1.1 |
|
| 442 |
1.1 |
|
| 445 |
1.1 |
|
| 446 |
1.1 |
|
| 452 |
1.1 |
|
| 454 |
1.1 |
|
| 458 |
1.1 |
|
| 459 |
1.1 |
|
| 463 |
1.1 |
|
| 464 |
1.1 2.2 |
|
| 466 |
1.1 |
|
| 467 |
1.1 |
|
| 468 |
1.1 |
|
| 471 |
1.1 |
|
| 474 |
1.1 |
|
| 475 |
1.1 |
|
| 478 |
1.1 |
|
| 479 |
1.1 |
|
| 482 |
1.1 |
|
| 488 |
1.1 2.2 3.3 4.4 5.5 |
|
| 493 |
1.1 |
|
| 495 |
1.1 |
|
| 498 |
1.1 |
|
| 500 |
1.1 |
|
| 506 |
1.1 |
|
| 508 |
1.1 |
|
| 510 |
1.1 |
|
| 516 |
1.1 |
|
| 517 |
1.1 |
|
| 518 |
1.1 |
|
| 521 |
1.1 |
|
| 522 |
1.1 |
|
| 523 |
1.1 |
|
| 524 |
1.1 |
|
| 531 |
1.1 2.2 |
|
| 536 |
1.1 |
|
| 541 |
1.1 |
|
| 543 |
1.1 |
|
| 547 |
1.1 |
|
| 551 |
1.1 |
|
| 552 |
1.1 |
|
| 553 |
1.1 |
|
| 556 |
1.1 |
|
| 558 |
1.1 |
|
| 559 |
1.1 |
|
| 562 |
1.1 |
|
| 564 |
1.1 |
|
| 568 |
1.1 |
|
| 569 |
1.1 2.2 |
|
| 572 |
1.1 |
|
| 573 |
1.1 2.2 |
|
| 578 |
1.1 |
|
| 579 |
1.1 |
|
| 600 |
1.1 2.2 3.3 |
|
| 602 |
1.1 |
|
| 603 |
1.1 |
|
| 606 |
1.1 |
|
| 617 |
1.1 |
|
| 618 |
1.1 |
|
| 620 |
1.1 2.2 |
|
| 621 |
1.1 |
|
| 624 |
1.1 |
|
| 625 |
1.1 |
|
| 627 |
1.1 |
|
| 628 |
1.1 |
|
| 630 |
1.1 |
|
| 641 |
1.1 |
|
| 654 |
1.1 |
|
| 667 |
1.1 |
|
| 668 |
1.1 |
|
| 669 |
1.1 |


Simple relation constraints over integer variables
[Using finite domain integers]
Functions | |
| void | Gecode::rel (Space *home, const IntVarArgs &x, IntRelType r, IntVar y, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Post propagators for for all . | |
| void | Gecode::rel (Space *home, IntVar x, IntRelType r, int c, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Propagates . | |
| void | Gecode::rel (Space *home, const IntVarArgs &x, IntRelType r, int c, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Propagates for all . | |
| void | Gecode::rel (Space *home, IntVar x0, IntRelType r, IntVar x1, BoolVar b, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Post propagator for . | |
| void | Gecode::rel (Space *home, IntVar x, IntRelType r, int c, BoolVar b, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Post propagator for . | |
| void | Gecode::rel (Space *home, const IntVarArgs &x, IntRelType r, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Post propagator for pairwise relation on x. | |
| void | Gecode::rel (Space *home, const IntVarArgs &x, IntRelType r, const IntVarArgs &y, IntConLevel icl=ICL_DEF, PropKind pk=PK_DEF) |
| Post propagator for relation between x and y. |
Function Documentation
| void Gecode::rel | ( | Space * | home, | |
| const IntVarArgs & | x, | |||
| IntRelType | r, | |||
| IntVar | y, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
| void Gecode::rel | ( | Space * | home, | |
| IntVar | x0, | |||
| IntRelType | r, | |||
| int | n, | |||
| IntConLevel | , | |||
| PropKind | ||||
| ) |
| void Gecode::rel | ( | Space * | home, | |
| const BoolVarArgs & | x, | |||
| IntRelType | r, | |||
| int | n, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
Propagates for all .
Propagates for all .
Throws an exception of type Int::NotZeroOne, if n is neither 0 or 1.
| void Gecode::rel | ( | Space * | home, | |
| IntVar | x0, | |||
| IntRelType | r, | |||
| IntVar | x1, | |||
| BoolVar | b, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
| void Gecode::rel | ( | Space * | home, | |
| IntVar | x, | |||
| IntRelType | r, | |||
| int | c, | |||
| BoolVar | b, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
| void Gecode::rel | ( | Space * | home, | |
| const IntVarArgs & | x, | |||
| IntRelType | r, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
Post propagator for pairwise relation on x.
States that the elements of x are in the following relation:
- if r = IRT_EQ, then all elements of x must be equal. Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).
- if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respt to r. Supports domain consistency (icl = ICL_DOM, default).
- if r = IRT_NQ, then all elements of x must be pairwise distinct (corresponds to the distinct constraint). Supports value (icl = ICL_VAL, default), bounds (icl = ICL_BND), and domain consistency (icl = ICL_DOM). Throws an exception of type Int::ArgumentSame, if x contains the same unassigned variable multiply.
States that the elements of x are in the following relation:
- if r = IRT_EQ, then all elements of x must be equal.
- if r = IRT_LE, r = IRT_LQ, r = IRT_GR, or r = IRT_GQ, then the elements of x are ordered with respt to r.
- if r = IRT_NQ, then all elements of x must be pairwise distinct (corresponds to the distinct constraint).
| void Gecode::rel | ( | Space * | home, | |
| const IntVarArgs & | x, | |||
| IntRelType | r, | |||
| const IntVarArgs & | y, | |||
| IntConLevel | icl = ICL_DEF , |
|||
| PropKind | pk = PK_DEF | |||
| ) |
Post propagator for relation between x and y.
Note that for the inequality relations this corresponds to the lexical order between x and y.
Supports both bounds (icl = ICL_BND) and domain consistency (icl = ICL_DOM, default).
Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size.
Note that for the inequality relations this corresponds to the lexical order between x and y.
Throws an exception of type Int::ArgumentSizeMismatch, if x and y are of different size.


migraine sensitivity visual contrast S-cone color deficits MWO significant presented spatial differences chromatic {border-style participants temporal Figure Vis px;} retinal #ffffff;} cortical peripheral Experiment B/Y Gabors associated discrimination using Res Sci identified paracentral SWAP spatiotemporal aura frequency inferior revealed stimuli stream superior group pathway processing used ./j.-...x Cambridge Controls Ophthalmol R/G based luminance perimetry studies Brain Cephalalgia Colour Control Research Test Visual achromatic average background cpd field mean migraine. migraineurs modulated streams study .), Eye However, McKendrick Participants assess compared difference evidence headache hierarchical individuals magnocellular measurements measures properties px; specific tritan {font-family ./S-()- Canada Contrast Neurol S-cones Soc cone control counterphase different font-size functional greater lower mechanisms neural operations parvocellular points retina showed shown steadily stimulus temporally vision "blue" "yellow" .). Badcock CIE Headache Invest Opt Wesner analysis assessed automated cd/m cells comes double; dysfunction frequencies groups. isoluminant low opponent peak possible postreceptoral provided psychophysical respectively. responses test thresholds trivector work (ie, ./JOSAA.. ./iovs.- Automated Group Hz) Neurosci PC- Results Shepherd University axes border-color border-width cardinal cell central confusion damage discriminability duration findings flickered function gain group. headaches high higher however, identify involved koniocellular means measure migraine: pathways patients points) quadrants reduced research response results retina. role solid; stream. ventral {font-style {font-weight "C" (Experiment (MA: -Hz ./s--- Chronicle Gabor Interestingly, Lakehead MWO: Migraine SEM Short-wavelength activated apparent aura. bold colour cortex courier; detection did driven em; functioning ganglion geniculate group, groups including indicated information levels locus measured menstrual modulation nasal nasal; nature need noted ocular panel partial perimetric points), possibly postretinal presentations pt;} range regarding regions selectively sensitivity. short-wavelength-sensitive signals similar spatiochromatic spreading suggesting system. temporal, temporal; terms −.;


- Source:
Methods
(inner) create - post request to '/'()
Create a new product
- Source:
(inner) find - get request to '/'(id)
Find a product
Parameters:
| Name | Type | Description |
|---|---|---|
id |
Number | The id of the product |
- Source:
(inner) find - get request to '/'(url)
Find a product by url
Parameters:
| Name | Type | Description |
|---|---|---|
url |
Number | The url of the product |
- Source:
(inner) list - get request to '/'()
Get all products
- Source:
(inner) remove - delete request to '/'(id)
Delete a product
Parameters:
| Name | Type | Description |
|---|---|---|
id |
Number | The id of the product |
- Source:
(inner) update - put request to '/'(id)
Update a product
Parameters:
| Name | Type | Description |
|---|---|---|
id |
Number | The id of the product |
- Source:


Family of Dead Los Zetas Gunman Seeks Donations for Burial
MONTERREY, Nuevo Leon – The family of a recently killed gunman for Los Zetas is holding local fundraisers to cover his burial expenses. The assassin’s body remains in another state where he took part in a failed ambush on law enforcement.
by Cartel ChroniclesRelatives of a member of the Cartel Del Noreste (CDN) faction of Los Zetas known as “Chikilin” are sharing a series of messages on social media advertising the sale of food items. The family is offering containers of tripe soup known as menudo for $200 pesos ($10 USD) to raise the needed funds to move his body from Monterrey, Nuevo Leon to Nuevo Laredo for a proper burial. Relatives also advertised they would be asking for donations along the main avenues of Nuevo Laredo.
The gunman was a member of the CDN-Zetas armed wing called “Tropa Del Infierno” or “Hell’s Troops” who died last week when the organization tried to ambush state police officers and then targeted their wounded in transit to hospitals. Despite the criminal organization’s reputation for brutality, “human rights” activists in Nuevo Laredo continue to critique the police officers who combat the cartel.
The lack of funding for a burial demonstrates the stark contrast with the perceived life of luxury portrayed in popular culture about the narco-lifestyle. The CDN faction of Los Zetas is the leading criminal organization in Nuevo Laredo where it controls drug trafficking, human smuggling, fuel theft, and commercial extortion schemes.
Editor’s Note: Breitbart Texas traveled to the Mexican States of Tamaulipas, Coahuila, and Nuevo León to recruit citizen journalists willing to risk their lives and expose the cartels silencing their communities. The writers would face certain death at the hands of the various cartels that operate in those areas including the Gulf Cartel and Los Zetas if a pseudonym were not used. Breitbart Texas’ Cartel Chronicles are published in both English and in their original Spanish . This article was written by Tony Aranda from Nuevo Leon.


Reach me:<PHONE_NUMBER>
Laura Bonini
Licensed Clinical Social Worker (LCSW)
Home
About Me
Services
FAQs
Resources
Contact
Resources
Here are a few helpful resources to get you started
ADAA
Anxiety and Depression Association of America
NAMI
National Alliance on Mental Health
NIHM
National Institute of Mental Health
DBSA
Depression and Bipolar Support Alliance
Yale
Yale Childhood Study Center Program for Anxiety Disorders
Boston University
The Center for Anxiety and Related Disorders at Boston University
DBSA
National Center for PTSD
Anxiety
Anxiety.org
CHADD
Children and Adults with Attention-Deficit/Hyperactivity Disorder
© 2020 Laura Bonini. All Rights Reserved.


United States
-
This is the wanderer. -
This is the wanderer. -
This is the wanderer. -
This is the wanderer. -
This is the wanderer. -
This is the wanderer. -
This is the wanderer.


| Package | flare.vis.operator.layout |
| Class | public class CircleLayout |
| Inheritance | CircleLayout Layout Operator |
treeLayout
property is set to true
, the layout will use an
underlying tree structure to layout the data. Leaf nodes will be
placed along the circumference of the circle, but parent nodes will
be placed in the interior. Also, the layout will add spacing to
differentiate sibling groups along the circumference.The layout also supports mixes of the above modes. For example, if
treeLayout
is set to true
and a data field for
the radius is set, the angles in the layout will be determined as in
a normal ciruclar tree layout, but the radius values will be derived
using the data field.
| Property | Defined by | ||
|---|---|---|---|
| angleField : String The angle source property.
| CircleLayout | ||
| angleScale : ScaleBinding
The scale binding for the angle.
| CircleLayout | ||
| angleWidth : Number The angular width of the layout, in radians (default is 2 pi).
| CircleLayout | ||
| enabled : Boolean Indicates if the operator is enabled or disabled.
| Operator | ||
| layoutAnchor : Point The layout anchor, used by some layout instances to place an
initial item or determine a focal point.
| Layout | ||
| layoutBounds : Rectangle The layout bounds for the layout.
| Layout | ||
| layoutRoot : DataSprite
The layout root, the root node for tree layouts.
| Layout | ||
| layoutType : String = "null" The type of layout and axes.
| Layout | ||
| padding : Number = 50 The padding around the circumference of the circle, in pixels.
| CircleLayout | ||
| parameters : Object
Sets parameter values for this operator.
| Operator | ||
| radiusField : String The radius source property.
| CircleLayout | ||
| radiusScale : ScaleBinding
The scale binding for the radius.
| CircleLayout | ||
| startAngle : Number The starting angle for the layout, in radians.
| CircleLayout | ||
| startRadius : Number The starting (inner) radius at which to place items.
| CircleLayout | ||
| startRadiusFraction : Number The starting (inner) radius as a fraction of the outer radius.
| CircleLayout | ||
| treeLayout : Boolean = false Flag indicating if tree structure should inform the layout.
| CircleLayout | ||
| visualization : Visualization
The visualization processed by this operator.
| Operator |
| Property | Defined by | ||
|---|---|---|---|
| _aBinding : ScaleBinding | CircleLayout | ||
| _aField : Property | CircleLayout | ||
| _anchor : Point | Layout | ||
| _group : String | CircleLayout | ||
| _inner : Number = 0 | CircleLayout | ||
| _outer : Number | CircleLayout | ||
| _rBinding : ScaleBinding | CircleLayout | ||
| _rField : Property | CircleLayout | ||
| _setAnchor : Boolean = false | Layout | ||
| _t : Transitioner = null A transitioner for storing value updates.
| Layout | ||
| xyAxes : CartesianAxes
Returns the visualization's axes as a CartesianAxes instance.
| Layout |
| Method | Defined by | ||
|---|---|---|---|
|
CircleLayout(radiusField:String = null, angleField:String = null, treeLayout:Boolean = false, group:String)
Creates a new CircleLayout.
| CircleLayout | ||
|
applyParameters(op:IOperator, params:Object):void
[static]
Static method that applies parameter settings to an operator.
| Operator | ||
|
clearEdgePoints():void
Strips all EdgeSprites in a visualization of any control points.
| Layout | ||
|
Hides the axes.
| Layout | ||
|
operate(t:Transitioner = null):void
Performs an operation over the contents of a visualization.
| Layout | ||
|
setup():void
Setup method invoked whenever this operator's visualization
property is set.
| CircleLayout | ||
|
Reveals the axes.
| Layout | ||
|
[static]
Updates all edges to be straight lines.
| Layout |
| Method | Defined by | ||
|---|---|---|---|
|
autoAnchor():void
Automatically-generate an anchor point.
| Layout | ||
|
layout():void
Calculates the spatial layout of visualized items.
| CircleLayout | ||
|
minAngle(a1:Number, a2:Number):Number
Returns an angle value that minimizes the angular distance
between a reference angle and a target angle.
| Layout |
| _aBinding | property |
protected var _aBinding:ScaleBinding
| _aField | property |
protected var _aField:Property
| angleField | property |
angleField:String
[read-write]The angle source property.
Implementation public function get angleField():String
public function set angleField(value:String):void
| angleScale | property |
angleScale:ScaleBinding
[read-write]The scale binding for the angle.
Implementation public function get angleScale():ScaleBinding
public function set angleScale(value:ScaleBinding):void
| angleWidth | property |
public var angleWidth:Number
The angular width of the layout, in radians (default is 2 pi).
| _group | property |
protected var _group:String
| _inner | property |
protected var _inner:Number = 0
| _outer | property |
protected var _outer:Number
| padding | property |
public var padding:Number = 50
The padding around the circumference of the circle, in pixels.
| radiusField | property |
radiusField:String
[read-write]The radius source property.
Implementation public function get radiusField():String
public function set radiusField(value:String):void
| radiusScale | property |
radiusScale:ScaleBinding
[read-write]The scale binding for the radius.
Implementation public function get radiusScale():ScaleBinding
public function set radiusScale(value:ScaleBinding):void
| _rBinding | property |
protected var _rBinding:ScaleBinding
| _rField | property |
protected var _rField:Property
| startAngle | property |
public var startAngle:Number
The starting angle for the layout, in radians.
| startRadius | property |
startRadius:Number
[read-write] The starting (inner) radius at which to place items.
Setting this value also overrides the
startRadiusFraction
property.
public function get startRadius():Number
public function set startRadius(value:Number):void
| startRadiusFraction | property |
startRadiusFraction:Number
[read-write] The starting (inner) radius as a fraction of the outer radius.
Setting this value also overrides the
startRadius
property. When this property is set to
NaN
, the current value of startRadius
will be used directly.
public function get startRadiusFraction():Number
public function set startRadiusFraction(value:Number):void
| treeLayout | property |
public var treeLayout:Boolean = false
Flag indicating if tree structure should inform the layout.
| CircleLayout | () | constructor |
public function CircleLayout(radiusField:String = null, angleField:String = null, treeLayout:Boolean = false, group:String)
Creates a new CircleLayout.
ParametersradiusField:String (default = null ) — optional data field to encode as radius length
|
|
angleField:String (default = null ) — optional data field to encode as angle
|
|
treeLayout:Boolean (default = false ) — boolean flag indicating if any tree-structure in
the data should be used to inform the layout
|
|
group:String — the data group to process. If tree layout is set to
true, this value may get ignored.
|
| layout | () | method |
protected override function layout():void
Calculates the spatial layout of visualized items. Layout operators override this method with their layout implementations.
| setup | () | method |
public override function setup():void
Setup method invoked whenever this operator's visualization property is set.


© 2019
| ophianthus ophiantha ophianthum | snake flower | |||
| ophis | ophi | noun/m | οφιϛ a snake | |
| anthos | anth | noun/n | ανϑοϛ flower | |
| us | adj | Latinizing suffix | ||
| Penstemon ophianthus Pennell | ||||
| ophiocarpus ophiocarpa ophiocarpum | snake like seed | |||
| ophis | ophi | noun/m | οφιϛ a snake | |
| o | o | cnct | connective vowel in botanical Latin, usually for Greek words but in some cases, such as color tingeing, for Latin words | |
| carpos | carp | noun/m | καρποϛ fruit | |
| us | adj | Latinizing suffix | ||
| ophiodes ophiodes ophiodes | snake like | |||
| ophis | ophi | noun/m | οφιϛ a snake | |
| odes | od | adj | oides -οειδεϛ adjective suffix for nouns: like, resemble | |
| Nephelium ophiodes Radlk. | ||||
| ophioglossoides ophioglossoides ophioglossoides | like genus Ophioglossum, snake tongue fern | |||
| ophis | ophi | noun/m | οφιϛ a snake | |
| o | o | cnct | connective vowel in botanical Latin, usually for Greek words but in some cases, such as color tingeing, for Latin words | |
| glossa | gloss | noun/f | γλωσσα the tongue; a language | |
| oides | oid | adj | -οειδεϛ adjective suffix for nouns: like, resemble | |
| Pogonia ophioglossoides (L.) Ker-Gawl. | ||||
| oppositifolius oppositifolia oppositifolium | leaves opposite | |||
| oppositus | opposit | ppar | placed opposite, against | |
| i | i | cnct | connective vowel used by botanical Latin | |
| folius | foli | adj | folium leaf | |
| Lewisia oppositifolia (S.Wats.) B.L.Robins. Aethionema oppositifolium Boiss. Umbilicus oppositifolius (Ledeb.) Ledeb. | ||||
| orbelicus orbelica orbelicum | Mt Orbelicos, Greece | |||
| orbelus | orbel | noun/m | Orbelus Ορβελοϛ Mt Orbelus between Macedonia & Trace | |
| icus | ic | adj | -ικοϛ adjective suffix for nouns: belonging to, from, of | |
| orbicularis orbicularis orbiculare | orbicular, circular | |||
| orbiculus | orbicul | noun/m | a small circle, ring | |
| aris | ar | adj | alis adjective suffix for nouns: of or pertaining to | |
| Carpolipum orbiculare (Schwein.) Nees Medicago orbicularis (L.) Bartalini | ||||
| orbiculatus orbiculata orbiculatum | circular | |||
| orbiculus | orbicul | noun/m | a small circle, ring | |
| atus | at | adj | adjectival suffix for nouns: possessive of or likeness of something (with, shaped, made)/ for verb participles: a completed action, -ed | |
| Cotyledon orbiculata L. Celastrus orbiculatus Thunb. | ||||
| orbus orba orbum | orphan | |||
| orbus | orb | adj | destitute; orphaned, childless | |
| orchioides orchioides orchioides | orchid like | |||
| orchis | orch | noun/f | ορχιϛ testicle (here, shape of) | |
| i | i | cnct | connective vowel used by botanical Latin | |
| oides | oid | adj | -οειδεϛ adjective suffix for nouns: like, resemble | |
| Spiranthes orchioides (Sw.) A. Rich. | ||||
| oreadus oreada oreadum | mountain nymph | |||
| oreas | oread | noun/f | Oreas ορειαϛ, αδοϛ (Gk: of or pertaining to the mountains); an Oread, mountain nymph | |
| us | adj | Latinizing suffix | ||
| Campanula oreadum Boiss. & Heldr. | ||||
| oreibatus oreibata oreibatum | of the mountains | |||
| oreibates | oreibat | adj | ορειβατηϛ mountain ranging | |
| us | adj | Latinizing suffix | ||
| Draba oreibata J.F.Macbr. & Payson ex Payson | ||||
| oreocreticus oreocretica oreocreticum | from mountains of Crete | |||
| oros | ore | noun/n | οροϛ, εοϛ a, or range of, mountain(s) or hill(s) | |
| o | o | cnct | connective vowel in botanical Latin, usually for Greek words but in some cases, such as color tingeing, for Latin words | |
| creticus | cretic | adj | Creticus from Crete, Cretan | |
| Crocus oreocreticus B.L.Burtt | ||||
| oreodoxus oreodoxa oreodoxum | mountain glory | |||
| oros | ore | noun/n | οροϛ, εοϛ a, or range of, mountain(s) or hill(s) | |
| o | o | cnct | connective vowel in botanical Latin, usually for Greek words but in some cases, such as color tingeing, for Latin words | |
| doxa | dox | noun/f | δοξα opinion, judgment; reputation, glory, splendor | |
| us | adj | Latinizing suffix | ||
| Rhododendron oreodoxa Franch. | ||||
| oreophilus oreophila oreophilum | mountain loving | |||
| oros | ore | noun/n | οροϛ, εοϛ a, or range of, mountain(s) or hill(s) | |
| o | o | cnct | connective vowel in botanical Latin, usually for Greek words but in some cases, such as color tingeing, for Latin words | |
| philus | phil | adj | philos φιλοσ, ε, ον loved; loving, friendly, fond | |
| us Latinizing suffix | ||||
| Sarracenia oreophila (Kearney) Wherry Allium oreophilum C.A.Mey. Aragallus oreophilus (Gray) A. Nels. |


The <javaClassAccess> element provides the ClassModifiersopt for the declaration of the class access values.
A class declaration can include the following modifiers: public, abstract, or final. Fields, methods, member class, member interface, and constructor declaration can include the access modifiers public, protected, or private.
<javaClass id="com.ibm.xtools.viz.ui"> <apiName>UMLDiagramResourceUtil</apiName> <shortdesc>A utility class that exposes UML diagram resource lifecycle operations and provides access to the modeling platform.</shortdesc> <javaClassDetail> <javaClassDef> <javaFinalClass /> <javaClassAccess value="public"/> <javaBaseClass href="../Object.html" format=”html”>Object</javaBaseClass> </javaClassDef> <apiDesc>API clients should not instantiate this class.</apiDesc> </javaClassDetail> </javaClass>


Spoilers: Darren supports Luke in Hollyoaks as he worries about his health
Luke Morgan (Gary Lucy) has had plenty on his mind since returning to the village in Hollyoaks earlier this year, but his recent trip to the hospital has left him incredibly concerned about his health. In the coming episodes, he decides to put his mind at rest by making a hospital appointment — and he asks Darren Osborne (Ashley Taylor Dawson) to accompany him.
After his altercation with Darren left him in need of medical attention, Luke was devastated to discover that he might have an underlying health condition.
In the coming episodes, he continues to worry about his health, as his hand keeps seizing up.
Sienna (Anna Passey) notices his hand, and proceeds to tell him about her dad, who had motor neurone disease. Luke decides to book himself an appointment at the hospital, and asks if Darren wouldn’t mind going with him.
Advertisement Advertisement
Meanwhile, the day of Cindy (Stephanie Waring) and Luke’s move arrives, but Luke’s nowhere to be seen, as he’s at the hospital for his MRI scan — with Darren in tow.
Later in the week, Luke attempts to escape his problems, but Darren meets with him and encourages him to stay strong.
It’s an incredibly tough time for Luke right now, but Darren is seemingly proving to be a great source of comfort for him.
However, will Luke open up about to Cindy about his worries and concerns?
One to watch: Tuesday 3rd December at 7pm on E4.