translations/*_untranslated.ts
qrc_*.cpp
+src/declarative/qtdeclarativeversion.h
+
# Test generated files
QObject.log
tst_*
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Flipable {
id: container
property int rating: 2
property variant prevScale: 1.0
+ property int flipDuration: 1600
+
signal closed
transform: Rotation {
slider.value = prevScale;
}
if (inBackState && bigImage.status == Image.Ready)
- particleBox.imageInAnim();
+ effectBox.imageInAnim();
}
property bool inBackState: false
onInBackStateChanged:{
if(inBackState && bigImage.status == Image.Ready)
- particleBox.imageInAnim();
+ effectBox.imageInAnim();
else if (!inBackState && bigImage.status == Image.Ready)
- particleBox.imageOutAnim();
+ effectBox.imageOutAnim();
}
}
+ ShaderEffectSource{
+ id: pictureSource
+ sourceItem: bigImage
+ smooth: true
+ //Workaround: Doesn't work below lines
+ width: bigImage.width
+ height: bigImage.width
+ visible: false
+ }
+ Turbulence{//only fill visible rect
+ id: turbulence
+ system: imageSystem
+ anchors.fill: parent
+ frequency: 100
+ strength: 250
+ active: false
+ }
Item{
- id: particleBox
+ id: effectBox
width: bigImage.width * bigImage.scale
height: bigImage.height * bigImage.scale
anchors.centerIn: parent
-
function imageInAnim(){
- cp.visible = true;
- pixAffect.onceOff = false;
bigImage.visible = false;
+ noiseIn.visible = true;
endEffectTimer.start();
- pixelEmitter.pulse(1);
}
function imageOutAnim(){
- cp.visible = true;
- pixAffect.onceOff = true;
bigImage.visible = false;
+ noiseIn.visible = false;
turbulence.active = true;
endEffectTimer.start();
pixelEmitter.burst(2048);
}
Timer{
id: endEffectTimer
- interval: 1000
+ interval: flipDuration
repeat: false
running: false
onTriggered:{
- bigImage.visible = true;
turbulence.active = false;
- cp.visible = false;
+ noiseIn.visible = false;
+ bigImage.visible = true;
}
}
- ParticleSystem{
- id: imageSystem
- }
- ColoredParticle{
- id: cp
- system: imageSystem
- color: "gray"
- alpha: 1
- image: "images/squareParticle.png"
- colorVariation: 0
- }
- Picture{
- id: pixAffect
- system: imageSystem
+ ShaderEffectItem{
+ id: noiseIn
anchors.fill: parent
- image: container.photoUrl;
- onceOff: true
+ property real t: 0
+ visible: false
+ onVisibleChanged: tAnim.start()
+ NumberAnimation{
+ id: tAnim
+ target: noiseIn
+ property: "t"
+ from: 0.0
+ to: 1.0
+ duration: flipDuration
+ }
+ property variant source: pictureSource
+ property variant noise: ShaderEffectSource{
+ sourceItem:Image{
+ source: "images/noise.png"
+ }
+ hideSource: true
+ smooth: false
+ }
+ fragmentShader:"
+ uniform sampler2D noise;
+ uniform sampler2D source;
+ uniform highp float t;
+ uniform lowp float qt_Opacity;
+ varying highp vec2 qt_TexCoord0;
+ void main(){
+ //Want to use noise2, but it always returns (0,0)?
+ if(texture2D(noise, qt_TexCoord0).w <= t)
+ gl_FragColor = texture2D(source, qt_TexCoord0) * qt_Opacity;
+ else
+ gl_FragColor = vec4(0.,0.,0.,0.);
+ }
+ "
}
- Turbulence{
- id: turbulence
- system: imageSystem
- anchors.fill: parent
- frequency: 100
- strength: 250
- active: false
+ ParticleSystem{
+ id: imageSystem
}
- TrailEmitter{
- id: pixelEmitter0
+ Emitter{
+ id: pixelEmitter
system: imageSystem
- height: parent.height
- particleSize: 4
- particleDuration: 1000
- particlesPerSecond: 4096
- speed: PointVector{x: 360; xVariation: 8; yVariation: 4}
+ //anchors.fill: parent
+ width: Math.min(bigImage.width * bigImage.scale, flickable.width);
+ height: Math.min(bigImage.height * bigImage.scale, flickable.height);
+ anchors.centerIn: parent
+ size: 4
+ lifeSpan: flipDuration
+ emitRate: 2048
emitting: false
}
- TrailEmitter{
- id: pixelEmitter
+ CustomParticle{
+ id: blowOut
system: imageSystem
- anchors.fill: parent
- particleSize: 4
- particleDuration: 1000
- particlesPerSecond: 2048
- emitting: false
+ property real maxWidth: effectBox.width
+ property real maxHeight: effectBox.height
+ vertexShader:"
+ attribute highp vec2 vPos;
+ attribute highp vec2 vTex;
+ attribute highp vec4 vData; // x = time, y = lifeSpan, z = size, w = endSize
+ attribute highp vec4 vVec; // x,y = constant speed, z,w = acceleration
+ attribute highp float r;
+
+ uniform highp float maxWidth;
+ uniform highp float maxHeight;
+
+ uniform highp mat4 qt_ModelViewProjectionMatrix;
+ uniform highp float timestamp;
+ uniform lowp float qt_Opacity;
+
+ varying highp vec2 fTex2;
+ varying lowp float fFade;
+
+ void main() {
+ fTex2 = vec2(vPos.x / maxWidth, vPos.y / maxHeight);
+ highp float size = vData.z;
+ highp float endSize = vData.w;
+
+ highp float t = (timestamp - vData.x) / vData.y;
+
+ highp float currentSize = mix(size, endSize, t * t);
+
+ if (t < 0. || t > 1.)
+ currentSize = 0.;
+
+ highp vec2 pos = vPos
+ - currentSize / 2. + currentSize * vTex // adjust size
+ + vVec.xy * t * vData.y // apply speed vector..
+ + 0.5 * vVec.zw * pow(t * vData.y, 2.);
+
+ gl_Position = qt_ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0, 1);
+
+ highp float fadeIn = min(t * 10., 1.);
+ highp float fadeOut = 1. - max(0., min((t - 0.75) * 4., 1.));
+
+ fFade = 1.0;//fadeIn * fadeOut * qt_Opacity;
+ }
+ "
+ property variant pictureTexture: pictureSource
+ fragmentShader: "
+ uniform sampler2D pictureTexture;
+ varying highp vec2 fTex2;
+ varying highp float fFade;
+ void main() {
+ gl_FragColor = texture2D(pictureTexture, fTex2) * fFade;
+ }"
}
+
+
}
}
}
transitions: Transition {
SequentialAnimation {
PropertyAction { target: bigImage; property: "smooth"; value: false }
- NumberAnimation { easing.type: Easing.InOutQuad; properties: "angle"; duration: 1000 }
+ NumberAnimation { easing.type: Easing.InOutQuad; properties: "angle"; duration: flipDuration }
PropertyAction { target: bigImage; property: "smooth"; value: !flickable.movingVertically }
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item{
id: container
running: container.visible
id: barSys
}
- ColoredParticle{
+ ImageParticle{
color: "lightsteelblue"
alpha: 0.1
colorVariation: 0.05
- image: "images/particle.png"
+ source: "images/particle.png"
system: barSys
}
- TrailEmitter{
+ Emitter{
y: 2; height: parent.height-4;
x: 2; width: Math.max(parent.width * progress - 4, 0);
- speed: AngleVector{ angleVariation: 180; magnitudeVariation: 12 }
+ speed: AngledDirection{ angleVariation: 180; magnitudeVariation: 12 }
system: barSys
- particlesPerSecond: width;
- particleDuration: 1000
- particleSize: 20
- particleSizeVariation: 4
- particleEndSize: 12
- maxParticles: parent.width;
+ emitRate: width;
+ lifeSpan: 1000
+ size: 20
+ sizeVariation: 4
+ endSize: 12
+ emitCap: parent.width;
}
Text {
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item{
id: container
anchors.fill:parent
overwrite: false
}
- DataParticle{
+ ModelParticle{
id: mp
fade: false
system: sys
}
}
property real emitterSpacing: parent.width/3
- TrailEmitter{
+ Emitter{
system: sys
width: emitterSpacing - 64
x: emitterSpacing*0 + 32
y: -128
height: 32
- speed: PointVector{ y: (container.height + 128)/12 }
- particlesPerSecond: 0.4
- particleDuration: 1000000//eventually -1 should mean a million seconds for neatness
- maxParticles: 15
+ speed: PointDirection{ y: (container.height + 128)/12 }
+ emitRate: 0.4
+ lifeSpan: 1000000//eventually -1 should mean a million seconds for neatness
+ emitCap: 15
}
- TrailEmitter{
+ Emitter{
system: sys
width: emitterSpacing - 64
x: emitterSpacing*1 + 32
y: -128
height: 32
- speed: PointVector{ y: (container.height + 128)/12 }
- particlesPerSecond: 0.4
- particleDuration: 1000000//eventually -1 should mean a million seconds for neatness
- maxParticles: 15
+ speed: PointDirection{ y: (container.height + 128)/12 }
+ emitRate: 0.4
+ lifeSpan: 1000000//eventually -1 should mean a million seconds for neatness
+ emitCap: 15
}
- TrailEmitter{
+ Emitter{
system: sys
width: emitterSpacing - 64
x: emitterSpacing*2 + 32
y: -128
height: 32
- speed: PointVector{ y: (container.height + 128)/12 }
- particlesPerSecond: 0.4
- particleDuration: 1000000//eventually -1 should mean a million seconds for neatness
- maxParticles: 15
+ speed: PointDirection{ y: (container.height + 128)/12 }
+ emitRate: 0.4
+ lifeSpan: 1000000//eventually -1 should mean a million seconds for neatness
+ emitCap: 15
}
Kill{
system: sys
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Package {
function photoClicked() {
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content"
Item {
id: bgParticles
startTime: 16000
}
- ColoredParticle {
+ ImageParticle {
particles: ["trail"]
- image: "content/images/particle.png"
+ source: "content/images/particle.png"
color: "#1A1A6F"
alpha: 0.1
colorVariation: 0.01
blueVariation: 0.8
system: bgParticles
}
- TrailEmitter {
+ Emitter {
particle: "drops"
width: parent.width
- particlesPerSecond: 0.5
- particleDuration: 20000
- speed: PointVector{
+ emitRate: 0.5
+ lifeSpan: 20000
+ speed: PointDirection{
y: {screen.height/18}
}
system: bgParticles
FollowEmitter {
follow: "drops"
particle: "trail"
- particlesPerParticlePerSecond: 18
- particleSize: 32
- particleEndSize: 0
- particleSizeVariation: 4
- particleDuration: 1200
+ emitRatePerParticle: 18
+ size: 32
+ endSize: 0
+ sizeVariation: 4
+ lifeSpan: 1200
system: bgParticles
anchors.fill: parent
- emissionWidth: 16
- emissionHeight: 16
- emissionShape: Ellipse{}
+ emitWidth: 16
+ emitHeight: 16
+ emitShape: EllipseShape{}
}
VisualDataModel{
****************************************************************************/
import QtQuick 1.0
-import Qt.labs.particles 1.0
+import QtQuick.Particles 1.0
Item {
property bool explode : false
anchors.centerIn: parent; anchors.verticalCenterOffset: -30
path: Path {
PathAttribute { name: 'z'; value: 9999.0 }
- PathLine { x: 1; y: 1 }
+ PathLineShape { x: 1; y: 1 }
PathAttribute { name: 'z'; value: 0.0 }
}
}
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
width: 24
height: 24
- TrailEmitter{
+ Emitter{
id: visualization
particle: "blaster"
system: container.system
emitting: show
anchors.fill: parent
- shape: Ellipse{}
- speed: DirectedVector{ targetX: width/2; targetY: width/2; magnitude: -1; proportionalMagnitude: true}
- particleDuration: 1000
- particlesPerSecond: 64
+ shape: EllipseShape{}
+ speed: TargetedDirection{ targetX: width/2; targetY: width/2; magnitude: -1; proportionalMagnitude: true}
+ lifeSpan: 1000
+ emitRate: 64
- particleSize: 24
- particleSizeVariation: 24
- particleEndSize: 0
+ size: 24
+ sizeVariation: 24
+ endSize: 0
}
property int blastsLeft: 0
rofTimer.repeat = false;
}
}
- TrailEmitter{
+ Emitter{
id: emitter
particle: "blaster"
emitting: false
system: container.system
anchors.centerIn: parent
- particleDuration: 1000
- particlesPerSecond: 16
- maxParticles: blasts
- particleSize: 24
- particleEndSize:16
- particleSizeVariation: 8
- speed: DirectedVector{
+ lifeSpan: 1000
+ emitRate: 16
+ emitCap: blasts
+ size: 24
+ endSize:16
+ sizeVariation: 8
+ speed: TargetedDirection{
id: blastVector
targetX: target.x; targetY: target.y; magnitude: 1.1; proportionalMagnitude: true
}
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
width: 24
height: 24
- TrailEmitter{
+ Emitter{
id: visualization
particle: "cannon"
emitting: container.show
system: container.system
anchors.centerIn: parent
- particleDuration: 2000
- particlesPerSecond: 1
+ lifeSpan: 2000
+ emitRate: 1
- particleSize: 4
- particleEndSize: 0
+ size: 4
+ endSize: 0
}
function fireAt(targetArg, hardpoint){
}
emitter.burst(1);
}
- TrailEmitter{
+ Emitter{
id: emitter
particle: "cannon"
emitting: false
system: container.system
anchors.centerIn: parent
- particleDuration: 1000
- particlesPerSecond: 1
- particleSize: 8
- particleEndSize: 4
- speed: DirectedVector{
+ lifeSpan: 1000
+ emitRate: 1
+ size: 8
+ endSize: 4
+ speed: TargetedDirection{
id: blastVector
targetX: target.x; targetY: target.y; magnitude: 1.1; proportionalMagnitude: true
}
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item{
id: container
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
property int gunType: 0
width: 128
height: 128
- TrailEmitter{
+ Emitter{
//TODO: Cooler would be an 'orbiting' affector
//TODO: On the subject, opacity and size should be grouped type 'overLife' if we can cram that in the particles
system: container.system
anchors.centerIn: parent
width: 64
height: 64
- shape: Ellipse{}
+ shape: EllipseShape{}
- particlesPerSecond: hp > 0 ? hp * 1 + 20 : 0
- particleDuration: 2400
- maxParticles: (maxHP * 1 + 20)*2.4
+ emitRate: hp > 0 ? hp * 1 + 20 : 0
+ lifeSpan: 2400
+ emitCap: (maxHP * 1 + 20)*2.4
- particleSize: 48
- particleSizeVariation: 16
- particleEndSize: 16
+ size: 48
+ sizeVariation: 16
+ endSize: 16
- speed: AngleVector{angleVariation:360; magnitudeVariation: 32}
+ speed: AngledDirection{angleVariation:360; magnitudeVariation: 32}
}
- TrailEmitter{
+ Emitter{
system: container.system
particle: "cruiserArmor"
anchors.fill: parent
- shape: Ellipse{ fill: false }
+ shape: EllipseShape{ fill: false }
emitting: hp>0
- particlesPerSecond: 16
- particleDuration: 2000
+ emitRate: 16
+ lifeSpan: 2000
- particleSize: 48
- particleSizeVariation: 24
+ size: 48
+ sizeVariation: 24
SpriteGoal{
id: destructor
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
property int gunType: 0
width: 128
height: 128
- TrailEmitter{
+ Emitter{
system: container.system
particle: "frigateShield"
anchors.centerIn: parent
- particleSize: 92
- particlesPerSecond: 1
- particleDuration: 4800
+ size: 92
+ emitRate: 1
+ lifeSpan: 4800
emitting: hp > 0
}
- TrailEmitter{
+ Emitter{
system: container.system
particle: container.shipParticle
anchors.centerIn: parent
width: 64
height: 16
- shape: Ellipse{}
+ shape: EllipseShape{}
- particleSize: 16
- particleSizeVariation: 8
- particleEndSize: 8
- particlesPerSecond: hp > 0 ? hp * 1 + 20 : 0
- particleDuration: 1200
- maxParticles: (maxHP * 1 + 20)*2
+ size: 16
+ sizeVariation: 8
+ endSize: 8
+ emitRate: hp > 0 ? hp * 1 + 20 : 0
+ lifeSpan: 1200
+ emitCap: (maxHP * 1 + 20)*2
}
Timer{
id: fireControl
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
SequentialLoader {
id: hLdr
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
width: 24
height: 24
- TrailEmitter{
+ Emitter{
id: visualization
particle: "laser"
system: container.system
anchors.fill: parent
emitting: container.show
- shape: Ellipse{}
- speed: DirectedVector{ targetX: width/2; targetY: width/2; magnitude: -1; proportionalMagnitude: true }
- particleDuration: 1000
- particlesPerSecond: 64
+ shape: EllipseShape{}
+ speed: TargetedDirection{ targetX: width/2; targetY: width/2; magnitude: -1; proportionalMagnitude: true }
+ lifeSpan: 1000
+ emitRate: 64
- particleSize: 24
- particleSizeVariation: 8
- particleEndSize: 8
+ size: 24
+ sizeVariation: 8
+ endSize: 8
}
function fireAt(targetArg, hardpoint){
emitter.pulse(0.10);
// console.log("Fire box: " + Math.min(container.width/2, target.x) + "," + Math.min(container.height/2, target.y) + " " + (Math.max(container.width/2, target.x) - Math.min(container.width/2, target.x)) + "," + (Math.max(container.height/2, target.y) - Math.min(container.height/2, target.y)));
}
- TrailEmitter{
+ Emitter{
id: emitter
particle: "laser"
emitting: false
width: Math.max(container.width/2, target.x) - x;
y: Math.min(container.height/2, target.y);
height: Math.max(container.height/2, target.y) - y;
- shape: Line{
+ shape: LineShape{
mirrored: (emitter.y < 0 || emitter.x < 0) && !(emitter.y < 0 && emitter.x < 0 )//I just want XOR
}
- particleDuration: 1000
- particlesPerSecond: 8000
- maxParticles: 800
- particleSize: 16
- particleEndSize: 0
+ lifeSpan: 1000
+ emitRate: 8000
+ emitCap: 800
+ size: 16
+ endSize: 0
- speed: PointVector{xVariation: 4; yVariation: 4}
+ speed: PointDirection{xVariation: 4; yVariation: 4}
}
}
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item{
property ParticleSystem sys
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["default"]
- image: "pics/blur-circle3.png"
+ source: "pics/blur-circle3.png"
color: "#003A3A3A"
colorVariation: 0.1
z: 0
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["redTeam"]
- image: "pics/blur-circle3.png"
+ source: "pics/blur-circle3.png"
color: "#0028060A"
colorVariation: 0.1
z: 0
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["greenTeam"]
- image: "pics/blur-circle3.png"
+ source: "pics/blur-circle3.png"
color: "#0006280A"
colorVariation: 0.1
z: 0
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["blaster"]
- image: "pics/star2.png"
+ source: "pics/star2.png"
//color: "#0F282406"
color: "#0F484416"
colorVariation: 0.2
z: 2
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["laser"]
- image: "pics/star3.png"
+ source: "pics/star3.png"
//color: "#00123F68"
color: "#00428FF8"
colorVariation: 0.2
z: 2
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["cannon"]
- image: "pics/particle.png"
+ source: "pics/particle.png"
color: "#80FFAAFF"
colorVariation: 0.1
z: 2
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["cannonCore"]
- image: "pics/particle.png"
+ source: "pics/particle.png"
color: "#00666666"
colorVariation: 0.8
z: 1
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["cannonWake"]
- image: "pics/star.png"
+ source: "pics/star.png"
color: "#00CCCCCC"
colorVariation: 0.2
z: 1
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["frigateShield"]
- image: "pics/blur-circle2.png"
+ source: "pics/blur-circle2.png"
color: "#00000000"
colorVariation: 0.05
blueVariation: 0.5
greenVariation: 0.1
z: 3
}
- SpriteParticle{
+ ImageParticle{
system: sys
particles: ["cruiserArmor"]
z: 1
system: sys
particle: "cannonWake"
follow: "cannon"
- particlesPerParticlePerSecond: 64
- particleDuration: 600
- speed: AngleVector{ angleVariation: 360; magnitude: 48}
- particleSize: 16
- particleEndSize: 8
- particleSizeVariation: 2
+ emitRatePerParticle: 64
+ lifeSpan: 600
+ speed: AngledDirection{ angleVariation: 360; magnitude: 48}
+ size: 16
+ endSize: 8
+ sizeVariation: 2
emitting: true
width: 1000//XXX: Terrible hack
height: 1000
system: sys
particle: "cannonCore"
follow: "cannon"
- particlesPerParticlePerSecond: 256
- particleDuration: 128
- particleSize: 24
- particleEndSize: 8
+ emitRatePerParticle: 256
+ lifeSpan: 128
+ size: 24
+ endSize: 8
emitting: true
width: 1000//XXX: Terrible hack
height: 1000
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: me
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: container
property int gunType: 0
width: 128
height: 128
- TrailEmitter{
+ Emitter{
id: emitter
//TODO: Cooler would be an 'orbiting' affector
//TODO: On the subject, opacity and size should be grouped type 'overLife' if we can cram that in the particles
system: container.system
particle: container.shipParticle
- shape: Ellipse{}
+ shape: EllipseShape{}
- particlesPerSecond: hp > 0 ? hp + 20 : 0
- particleDuration: blinkInterval
- maxParticles: (maxHP + 20)
+ emitRate: hp > 0 ? hp + 20 : 0
+ lifeSpan: blinkInterval
+ emitCap: (maxHP + 20)
- acceleration: AngleVector{angleVariation: 360; magnitude: 8}
+ acceleration: AngledDirection{angleVariation: 360; magnitude: 8}
- particleSize: 24
- particleEndSize: 4
- particleSizeVariation: 8
+ size: 24
+ endSize: 4
+ sizeVariation: 8
width: 16
height: 16
x: 64
**
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content"
Rectangle {
id: title
width: root.width
height: 240
- TrailEmitter{
+ Emitter{
anchors.fill: parent
system: particles
emitting: true
particle: "default"
- particlesPerSecond: 1200
- particleDuration: 1200
- shape: Mask{source:"content/pics/TitleText.png"}
- particleSize: 16
- particleEndSize: 0
- particleSizeVariation: 8
- speed: AngleVector{angleVariation:360; magnitudeVariation: 6}
+ emitRate: 1200
+ lifeSpan: 1200
+ shape: MaskShape{source:"content/pics/TitleText.png"}
+ size: 16
+ endSize: 0
+ sizeVariation: 8
+ speed: AngledDirection{angleVariation:360; magnitudeVariation: 6}
}
}
Button{
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Item {
id: block
Behavior on opacity { NumberAnimation { duration: 200 } }
anchors.fill: parent
}
- TrailEmitter {
+ Emitter {
id: particles
system: particleSystem
particle: {
}
anchors.fill: parent
- speed: DirectedVector{targetX: block.width/2; targetY: block.height/2; magnitude: -60; magnitudeVariation: 60}
- shape: Ellipse{fill:true}
+ speed: TargetedDirection{targetX: block.width/2; targetY: block.height/2; magnitude: -60; magnitudeVariation: 60}
+ shape: EllipseShape{fill:true}
emitting: false;
- particleDuration: 700; particleDurationVariation: 100
- particlesPerSecond: 1000
- maxParticles: 100 //only fires 0.1s bursts (still 2x old number, ColoredParticle wants less than 16000 max though)
- particleSize: 28
- particleEndSize: 14
+ lifeSpan: 700; lifeSpanVariation: 100
+ emitRate: 1000
+ emitCap: 100 //only fires 0.1s bursts (still 2x old number, ImageParticle wants less than 16000 max though)
+ size: 28
+ endSize: 14
}
states: [
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "SamegameCore"
import "SamegameCore/samegame.js" as Logic
}
Item{
ParticleSystem{ id: particleSystem; }
- ColoredParticle {
+ ImageParticle {
system: particleSystem
particles: ["red"]
color: Qt.darker("red");//Actually want desaturated...
- image: "SamegameCore/pics/particle.png"
+ source: "SamegameCore/pics/particle.png"
colorVariation: 0.4
alpha: 0.1
}
- ColoredParticle {
+ ImageParticle {
system: particleSystem
particles: ["green"]
color: Qt.darker("green");//Actually want desaturated...
- image: "SamegameCore/pics/particle.png"
+ source: "SamegameCore/pics/particle.png"
colorVariation: 0.4
alpha: 0.1
}
- ColoredParticle {
+ ImageParticle {
system: particleSystem
particles: ["blue"]
color: Qt.darker("blue");//Actually want desaturated...
- image: "SamegameCore/pics/particle.png"
+ source: "SamegameCore/pics/particle.png"
colorVariation: 0.4
alpha: 0.1
}
****************************************************************************/
import QtQuick 1.0
-import Qt.labs.particles 1.0
+import QtQuick.Particles 1.0
Item {
id: root
****************************************************************************/
import QtQuick 1.0
-import Qt.labs.particles 1.0
+import QtQuick.Particles 1.0
Item { id:link
property bool dying: false
//![0]
Column {
- Image { source: "image://colors/yellow" }
- Image { source: "image://colors/red" }
+ Image { source: "source://colors/yellow" }
+ Image { source: "source://colors/red" }
}
//![0]
--- /dev/null
+import QtQuick 2.0
+import QtQuick.Particles 2.0
+
+Rectangle{
+ color: "goldenrod"
+ width: 2000
+ height: 2000
+ ParticleSystem{id: sys}
+ ImageParticle{
+ id: up
+ system: sys
+ source: "content/singlesmile.png"
+ }
+ Emitter{
+ anchors.centerIn: parent
+ system: sys
+ emitRate: 1000
+ size: 20
+ lifeSpan: 10000
+ speed: AngledDirection{angleVariation: 360; magnitudeVariation: 100;}
+ }
+ MouseArea{
+ anchors.fill: parent
+ onClicked: up.autoRotation = !up.autoRotation
+ }
+}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
+ id: root
color: "white"
width: 310
height: 300
ParticleSystem{ id: sys }
- Picture{
+ CustomParticle{
system: sys
- anchors.fill: parent
- image: "content/singlesmile.png"
- onceOff: true
- }
- ColoredParticle{
- system: sys
- image: "content/particle.png"
- color: "black"
- alpha: 0.4
- sizeTable: "content/sizeInOut.png"
+ property real maxWidth: root.width
+ property real maxHeight: root.height
+ ShaderEffectSource{
+ id: pictureSource
+ sourceItem: picture
+ hideSource: true
+ }
+ Image{
+ id: picture
+ source: "content/singlesmile.png"
+ }
+ ShaderEffectSource{
+ id: particleSource
+ sourceItem: particle
+ hideSource: true
+ }
+ Image{
+ id: particle
+ source: "content/particle.png"
+ }
+ vertexShader:"
+ attribute highp vec2 vPos;
+ attribute highp vec2 vTex;
+ attribute highp vec4 vData; // x = time, y = lifeSpan, z = size, w = endSize
+ attribute highp vec4 vVec; // x,y = constant speed, z,w = acceleration
+ attribute highp float r;
+
+ uniform highp float maxWidth;
+ uniform highp float maxHeight;
+
+ uniform highp mat4 qt_ModelViewProjectionMatrix;
+ uniform highp float timestamp;
+ uniform lowp float qt_Opacity;
+
+ varying highp vec2 fTex;
+ varying highp vec2 fTex2;
+ varying lowp float fFade;
+
+ void main() {
+ fTex = vTex;
+ fTex2 = vec2(vPos.x / maxWidth, vPos.y / maxHeight);
+ highp float size = vData.z;
+ highp float endSize = vData.w;
+
+ highp float t = (timestamp - vData.x) / vData.y;
+
+ highp float currentSize = mix(size, endSize, t * t);
+
+ if (t < 0. || t > 1.)
+ currentSize = 0.;
+
+ highp vec2 pos = vPos
+ - currentSize / 2. + currentSize * vTex // adjust size
+ + vVec.xy * t * vData.y // apply speed vector..
+ + 0.5 * vVec.zw * pow(t * vData.y, 2.);
+
+ gl_Position = qt_ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0, 1);
+
+ highp float fadeIn = min(t * 10., 1.);
+ highp float fadeOut = 1. - max(0., min((t - 0.75) * 4., 1.));
+
+ fFade = fadeIn * fadeOut * qt_Opacity;
+ }
+ "
+ property variant particleTexture: particleSource
+ property variant pictureTexture: pictureSource
+ fragmentShader: "
+ uniform sampler2D particleTexture;
+ uniform sampler2D pictureTexture;
+ varying highp vec2 fTex;
+ varying highp vec2 fTex2;
+ varying highp float fFade;
+ void main() {
+ gl_FragColor = texture2D(pictureTexture, fTex2) * texture2D(particleTexture, fTex).w * fFade;
+ }"
}
- TrailEmitter{
+ Emitter{
id: emitter
system: sys
emitting: false
- particleDuration: 4000
- maxParticles: 1200
+ lifeSpan: 4000
+ emitCap: 1200
anchors.fill: parent
- particleSize: 32
- speed: PointVector{ xVariation: 12; yVariation: 12 }
+ size: 32
+ speed: PointDirection{ xVariation: 12; yVariation: 12 }
}
MouseArea{
anchors.fill: parent
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "goldenrod"
width: 400
height: 400
ParticleSystem{id:sys}
- DeformableParticle{
+ ImageParticle{
system: sys
particles: ["goingLeft", "goingRight"]
- image: "content/singlesmile.png"
+ source: "content/singlesmile.png"
rotation: 90
rotationSpeed: 90
autoRotation: true
}
- DeformableParticle{
+ ImageParticle{
system: sys
particles: ["goingDown"]
- image: "content/squarefacespriteXX.png"
+ source: "content/squarefacespriteXX.png"
rotation: 180
- yVector: PointVector{ y: 0.5; yVariation: 0.25; xVariation: 0.25; }
+ yVector: PointDirection{ y: 0.5; yVariation: 0.25; xVariation: 0.25; }
}
Timer{
running: true
interval: 8400
onTriggered: emitC.emitting = true;
}
- TrailEmitter{
+ Emitter{
id: emitA
x: 0
y: 120
system: sys
emitting: false
particle: "goingRight"
- speed: PointVector{ x: 100 }
- particleDuration: 4000
- particlesPerSecond: 2
- particleSize: 32
+ speed: PointDirection{ x: 100 }
+ lifeSpan: 4000
+ emitRate: 2
+ size: 32
}
- TrailEmitter{
+ Emitter{
id: emitB
x: 400
y: 240
system: sys
emitting: false
particle: "goingLeft"
- speed: PointVector{ x: -100 }
- particleDuration: 4000
- particlesPerSecond: 2
- particleSize: 32
+ speed: PointDirection{ x: -100 }
+ lifeSpan: 4000
+ emitRate: 2
+ size: 32
}
- TrailEmitter{
+ Emitter{
id: emitC
x: 0
y: 360
system: sys
emitting: false
particle: "goingDown"
- speed: PointVector{ x: 100 }
- particleDuration: 4000
- particlesPerSecond: 2
- particleSize: 32
+ speed: PointDirection{ x: 100 }
+ lifeSpan: 4000
+ emitRate: 2
+ size: 32
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "goldenrod"
width: 400
height: 400
- ColoredParticle{
+ ImageParticle{
id: test
particles: ["Test"]
- image: "content/particle.png"
+ source: "content/particle.png"
system: sys
z: 2
anchors.fill: parent
color: "#336666CC"
colorVariation: 0.0
}
- SpriteParticle{
+ ImageParticle{
id: single
particles: ["Face"]
system: sys
z: 2
anchors.fill: parent
- Sprite{
+ sprites: Sprite{
source: "content/squarefacesprite.png"
frames: 6
duration: 120
}
}
- Mask{
+ MaskShape{
id: mask
source: "content/smileMask.png"
}
- TrailEmitter{
+ Emitter{
system: sys
particle: "Test"
anchors.fill: parent
id: particles2
- particlesPerSecond: 6000
- particleDuration: 720
+ emitRate: 6000
+ lifeSpan: 720
emitting: true
- particleSize: 10
+ size: 10
shape: mask
}
- TrailEmitter{
+ Emitter{
system: sys
particle: "Face"
anchors.fill: parent
id: particles
- particlesPerSecond: 60
- particleDuration: 1440
+ emitRate: 60
+ lifeSpan: 1440
emitting: true
- speed: PointVector{xVariation: 10; yVariation: 10;}
- particleSize: 30
- particleSizeVariation: 10
+ speed: PointDirection{xVariation: 10; yVariation: 10;}
+ size: 30
+ sizeVariation: 10
shape: mask
}
ParticleSystem{
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "goldenrod"
z:4
}
ParticleSystem{ id: sys }
- SpriteParticle{
+ ImageParticle{
anchors.fill: parent
id: particles
system: sys
duration: 10000
}]
}
- TrailEmitter{
+ Emitter{
system: sys
- particlesPerSecond: 16
- particleDuration: 10000
+ emitRate: 16
+ lifeSpan: 10000
emitting: true
- speed: AngleVector{angle: 90; magnitude: 60; angleVariation: 5}
- acceleration: PointVector{ y: 10 }
- particleSize: 30
- particleSizeVariation: 10
+ speed: AngledDirection{angle: 90; magnitude: 60; angleVariation: 5}
+ acceleration: PointDirection{ y: 10 }
+ size: 30
+ sizeVariation: 10
width: parent.width
height: 100
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "goldenrod"
width: 800
height: 800
ParticleSystem{ id: sys }
- SpriteParticle{
+ ImageParticle{
system: sys
anchors.fill: parent
sprites: [Sprite{
duration: 120
}]
}
- TrailEmitter{
+ Emitter{
id: particleEmitter
system: sys
width: parent.width
- particlesPerSecond: 16
- particleDuration: 8000
+ emitRate: 16
+ lifeSpan: 8000
emitting: true
- speed: AngleVector{angle: 90; magnitude: 300; magnitudeVariation: 100; angleVariation: 5}
- acceleration: PointVector{ y: 10 }
- particleSize: 30
- particleSizeVariation: 10
+ speed: AngledDirection{angle: 90; magnitude: 300; magnitudeVariation: 100; angleVariation: 5}
+ acceleration: PointDirection{ y: 10 }
+ size: 30
+ sizeVariation: 10
}
Binding{
target: particleEmitter
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "white"
ParticleSystem{
id: sys
}
- UltraParticle{
+ ImageParticle{
sprites: [
Sprite{
name: "licking"
factor: 0.1
system: sys
}
- TrailEmitter{
+ Emitter{
system: sys
anchors.centerIn: parent
id: particles
- particlesPerSecond: 200
- particleDuration: 6000
+ emitRate: 200
+ lifeSpan: 6000
emitting: true
- speed: AngleVector{angleVariation: 360; magnitude: 80; magnitudeVariation: 40}
- particleSize: 40
- particleEndSize: 80
+ speed: AngledDirection{angleVariation: 360; magnitude: 80; magnitudeVariation: 40}
+ size: 40
+ endSize: 80
}
Text{
x: 16
**
****************************************************************************/
-import Qt.labs.particles 2.0
-import Qt.labs.particles 2.0 as Qlp
+import QtQuick.Particles 2.0
+import QtQuick.Particles 2.0 as Qlp
import QtQuick 2.0
Item {
}
}
- ColoredParticle {
+ ImageParticle {
system: sys
particles: ["starfield"]
- image: "content/star.png"
+ source: "content/star.png"
colorVariation: 0.3
color: "white"
}
- TrailEmitter {
+ Emitter {
id: starField
system: sys
particle: "starfield"
- particlesPerSecond: 80
- particleDuration: 2500
+ emitRate: 80
+ lifeSpan: 2500
anchors.centerIn: parent
- //acceleration: AngleVector{angleVariation: 360; magnitude: 200}//Is this a better effect, more consistent speed?
- acceleration: PointVector{ xVariation: 200; yVariation: 200; }
+ //acceleration: AngledDirection{angleVariation: 360; magnitude: 200}//Is this a better effect, more consistent speed?
+ acceleration: PointDirection{ xVariation: 200; yVariation: 200; }
- particleSize: 0
- particleEndSize: 80
- particleSizeVariation: 10
+ size: 0
+ endSize: 80
+ sizeVariation: 10
}
- TrailEmitter{
+ Emitter{
system: sys
particle: "meteor"
- particlesPerSecond: 12
- particleDuration: 5000
+ emitRate: 12
+ lifeSpan: 5000
emitting: true
- acceleration: PointVector{ xVariation: 80; yVariation: 80; }
- particleSize: 15
- particleEndSize: 300
+ acceleration: PointDirection{ xVariation: 80; yVariation: 80; }
+ size: 15
+ endSize: 300
anchors.centerIn: parent
}
- SpriteParticle{
+ ImageParticle{
system: sys
particles: ["meteor"]
sprites:[Sprite{
}
}
- ColoredParticle{
+ ImageParticle{
z:0
system: sys
particles: ["exhaust"]
- image: "content/particle4.png"
+ source: "content/particle4.png"
color: "orange"
SequentialAnimation on color {
colorVariation: 0.2
}
- TrailEmitter{
+ Emitter{
id: trailsNormal2
system: sys
particle: "exhaust"
- particlesPerSecond: 300
- particleDuration: 500
+ emitRate: 300
+ lifeSpan: 500
y: holder.y
x: holder.x
- speed: PointVector{ xVariation: 40; yVariation: 40; }
+ speed: PointDirection{ xVariation: 40; yVariation: 40; }
speedFromMovement: 16
- acceleration: PointVector{ xVariation: 10; yVariation: 10; }
+ acceleration: PointDirection{ xVariation: 10; yVariation: 10; }
- particleSize: 4
- particleSizeVariation: 4
+ size: 4
+ sizeVariation: 4
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
id: root
}
}
- TrailEmitter{
+ Emitter{
particle: "stars"
system: particles
- particlesPerSecond: 40
- particleDuration: 4000
+ emitRate: 40
+ lifeSpan: 4000
emitting: true
- particleSize: 30
- particleSizeVariation: 10
- speed: PointVector{ x: 220; xVariation: 40 }
+ size: 30
+ sizeVariation: 10
+ speed: PointDirection{ x: 220; xVariation: 40 }
height: parent.height
}
- TrailEmitter{
+ Emitter{
particle: "roids"
system: particles
- particlesPerSecond: 10
- particleDuration: 4000
+ emitRate: 10
+ lifeSpan: 4000
emitting: true
- particleSize: 30
- particleSizeVariation: 10
- speed: PointVector{ x: 220; xVariation: 40 }
+ size: 30
+ sizeVariation: 10
+ speed: PointDirection{ x: 220; xVariation: 40 }
height: parent.height
}
ParticleSystem{
id: particles
anchors.fill: parent
}
- ColoredParticle{
+ ImageParticle{
id: stars
particles: ["stars"]
system: particles
- image: "content/star.png"
+ source: "content/star.png"
color: "white"
colorVariation: 0.1
+ alpha: 0
}
- SpriteParticle{
+ ImageParticle{
id: roids
particles: ["roids"]
system: particles
speedModifiesDuration: -0.1
}
}
- ColoredParticle{
+ ImageParticle{
id: shot
particles: ["shot"]
system: particles
- image: "content/star.png"
+ source: "content/star.png"
color: "#0FF06600"
colorVariation: 0.3
}
- ColoredParticle{
+ ImageParticle{
id: engine
particles: ["engine"]
system: particles
- image: "content/particle4.png"
+ source: "content/particle4.png"
color: "orange"
SequentialAnimation on color {
colorVariation: 0.2
}
- GravitationalSingularity{
+ PointAttractor{
id: gs; x: root.width/2; y: root.height/2; strength: 4000000;
system: particles
+ physics: PointAttractor.Acceleration
+ proportionalToDistance: PointAttractor.Quadratic
}
Kill{
system: particles
drag.axis: Drag.XandYAxis
drag.target: ship
}
- TrailEmitter{
+ Emitter{
particle: "engine"
system: particles
- particlesPerSecond: 200
- particleDuration: 1000
+ emitRate: 200
+ lifeSpan: 1000
emitting: true
- particleSize: 10
- particleEndSize: 4
- particleSizeVariation: 4
- speed: PointVector{ x: -128; xVariation: 32 }
+ size: 10
+ endSize: 4
+ sizeVariation: 4
+ speed: PointDirection{ x: -128; xVariation: 32 }
height: parent.height
width: 20
}
- TrailEmitter{
+ Emitter{
particle: "shot"
system: particles
- particlesPerSecond: 32
- particleDuration: 2000
+ emitRate: 32
+ lifeSpan: 2000
emitting: spacePressed
- particleSize: 40
- speed: PointVector{ x: 256; }
+ size: 40
+ speed: PointDirection{ x: 256; }
x: parent.width
y: parent.height/2
}
--- /dev/null
+import QtQuick 2.0
+import QtQuick.Particles 2.0
+
+Rectangle{
+ color: "white"
+ width: 240
+ height: 360
+ ParticleSystem{
+ id: sys
+ }
+ Emitter{
+ system:sys
+ height: parent.height
+ emitRate: 1
+ lifeSpan: 12000
+ speed: PointDirection{x:20;}
+ size: 64
+ }
+ ShaderEffectSource{
+ id: theSource
+ sourceItem: theItem
+ hideSource: true
+ }
+ Image{
+ id: theItem
+ source: "content/smile.png"
+ }
+
+ CustomParticle{
+ system: sys
+ //TODO: Someway that you don't have to rewrite the basics for a simple addition
+ vertexShader:"
+ attribute highp vec2 vPos;
+ attribute highp vec2 vTex;
+ attribute highp vec4 vData; // x = time, y = lifeSpan, z = size, w = endSize
+ attribute highp vec4 vVec; // x,y = constant speed, z,w = acceleration
+ attribute highp float r;
+
+ uniform highp mat4 qt_ModelViewProjectionMatrix;
+ uniform highp float timestamp;
+ uniform lowp float qt_Opacity;
+
+ varying highp vec2 fTex;
+ varying lowp float fFade;
+ varying lowp float fBlur;
+
+ void main() {
+ fTex = vTex;
+ highp float size = vData.z;
+ highp float endSize = vData.w;
+
+ highp float t = (timestamp - vData.x) / vData.y;
+
+ highp float currentSize = mix(size, endSize, t * t);
+
+ if (t < 0. || t > 1.)
+ currentSize = 0.;
+
+ highp vec2 pos = vPos
+ - currentSize / 2. + currentSize * vTex // adjust size
+ + vVec.xy * t * vData.y // apply speed vector..
+ + 0.5 * vVec.zw * pow(t * vData.y, 2.);
+
+ gl_Position = qt_ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0, 1);
+
+ highp float fadeIn = min(t * 10., 1.);
+ highp float fadeOut = 1. - max(0., min((t - 0.75) * 4., 1.));
+
+ fFade = fadeIn * fadeOut * qt_Opacity;
+ fBlur = max(0.2 * t, t * r);
+ }
+ "
+ property variant source: theSource
+ property variant blurred: ShaderEffectSource {
+ smooth: true
+ sourceItem: ShaderEffectItem {
+ width: theItem.width
+ height: theItem.height
+ property variant delta: Qt.size(0.0, 1.0 / height)
+ property variant source: ShaderEffectSource {
+ smooth: true
+ sourceItem: ShaderEffectItem {
+ width: theItem.width
+ height: theItem.height
+ property variant delta: Qt.size(1.0 / width, 0.0)
+ property variant source: theSource
+ fragmentShader: "
+ uniform sampler2D source;
+ uniform highp vec2 delta;
+ varying highp vec2 qt_TexCoord0;
+ void main() {
+ gl_FragColor = 0.0538 * texture2D(source, qt_TexCoord0 - 3.182 * delta)
+ + 0.3229 * texture2D(source, qt_TexCoord0 - 1.364 * delta)
+ + 0.2466 * texture2D(source, qt_TexCoord0)
+ + 0.3229 * texture2D(source, qt_TexCoord0 + 1.364 * delta)
+ + 0.0538 * texture2D(source, qt_TexCoord0 + 3.182 * delta);
+ }"
+ }
+ }
+ fragmentShader: "
+ uniform sampler2D source;
+ uniform highp vec2 delta;
+ varying highp vec2 qt_TexCoord0;
+ void main() {
+ gl_FragColor = 0.0538 * texture2D(source, qt_TexCoord0 - 3.182 * delta)
+ + 0.3229 * texture2D(source, qt_TexCoord0 - 1.364 * delta)
+ + 0.2466 * texture2D(source, qt_TexCoord0)
+ + 0.3229 * texture2D(source, qt_TexCoord0 + 1.364 * delta)
+ + 0.0538 * texture2D(source, qt_TexCoord0 + 3.182 * delta);
+ }"
+ }
+ }
+ fragmentShader: "
+ uniform sampler2D source;
+ uniform sampler2D blurred;
+ varying highp vec2 fTex;
+ varying highp float fBlur;
+ varying highp float fFade;
+ void main() {
+ gl_FragColor = mix(texture2D(source, fTex), texture2D(blurred, fTex), min(1.0,fBlur*3.0)) * fFade;
+ }"
+
+ }
+}
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+** * Redistributions of source code must retain the above copyright
+** notice, this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright
+** notice, this list of conditions and the following disclaimer in
+** the documentation and/or other materials provided with the
+** distribution.
+** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
+** the names of its contributors may be used to endorse or promote
+** products derived from this software without specific prior written
+** permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+import QtQuick.Particles 2.0
+import "launcherContent/launcher.js" as Util
+import "launcherContent"
+
+Rectangle{
+ color: "black"
+ width: 360
+ height: 600
+ Shell{
+ z: 1
+ id: shell
+ anchors.fill: parent
+ }
+ VisualDataModel{//TODO: Transitions between modes
+ id: vdm
+ model: [
+ "../spaceexplorer/spaceexplorer.qml",
+ "../snow/snow.qml",
+ "../asteroid/asteroid.qml",
+ "../asteroid/blackhole.qml",
+ "../custom/blurparticles.qml",
+ "../modelparticles/bubbles.qml",
+ "../modelparticles/gridsplosion.qml",
+ "../modelparticles/package.qml",
+ "../modelparticles/stream.qml",
+ "../allsmiles/plain.qml",
+ "../allsmiles/smile.qml",
+ "../allsmiles/smilefactory.qml",
+ "../allsmiles/ultraparticles.qml",
+ "../allsmiles/spriteparticles.qml",
+ "../allsmiles/spritestateparticles.qml",
+ "../allsmiles/spritevariedparticles.qml",
+ "../trails/velocityfrommotion.qml",
+ "../trails/fireballs.qml",
+ "../trails/list.qml",
+ "../trails/portal.qml",
+ "../trails/rainbow.qml",
+ "../trails/dynamicemitters.qml",
+ "../trails/overburst.qml",
+ "../trails/layered.qml",
+ "../trails/shimmer.qml",
+ "../trails/turbulence.qml",
+ "../../../../demos/declarative/samegame/samegame.qml",
+ "../../../../demos/declarative/plasmapatrol/plasmapatrol.qml",
+ "../../../../demos/declarative/flickr/flickr.qml"
+ ]
+ delegate: Rectangle{
+ color: "white"
+ width: 96
+ height: 96
+ Image{
+ width: 72
+ height: 72
+ anchors.centerIn: parent
+ source: Util.iconFromPath(modelData)
+ }
+ Text{
+ text: Util.nameFromPath(modelData)
+ anchors.bottom: parent.bottom
+ anchors.horizontalCenter: parent.horizontalCenter
+ font.pixelSize: 8
+ }
+ MouseArea{
+ anchors.fill: parent
+ onClicked: shell.setDemo(modelData)
+ }
+ }
+ }
+ GridView{
+ anchors.fill: parent
+ cellWidth: 120
+ cellHeight: 120
+ model: vdm
+ }
+}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0 as QLP
-Rectangle{
- width: 200
- height: 200
- color: "black"
- QLP.ParticleSystem{ id: ps }
- QLP.ColoredParticle{
- system: ps
- particles: ["star1","star2"]
- anchors.fill: parent
- clip: true
- image: "content/star.png"
- }
- QLP.Swarm{
- system: ps
- leaders: ["star2"];
- anchors.fill: parent
- strength: 128
- }
- QLP.TrailEmitter{
- anchors.fill: parent
- system: ps
- particle: "star1"
- particlesPerSecond: 100
- particleDuration: 2000
+Rectangle {
+ id: container
+
+ property string text: "Button"
+ signal clicked
+
+ width: buttonLabel.width + 20; height: buttonLabel.height + 20
+ smooth: true
+ property color myCol: "#999999"
+ border { width: 1; color: Qt.darker(myCol) }
+ radius: 8
+
+ gradient: Gradient {
+ GradientStop {
+ position: 0.0
+ color: {
+ if (mouseArea.pressed)
+ return Qt.darker(myCol)
+ else
+ return Qt.lighter(myCol)
+ }
+ }
+ GradientStop { position: 1.0; color: myCol }
}
- QLP.TrailEmitter{
- anchors.fill: parent
- system: ps
- particle: "star2"
- particlesPerSecond: 0.4
- particleDuration: 10000
- particleSize: 64
- particleEndSize: 32
+
+ MouseArea { id: mouseArea; anchors.fill: parent; onClicked: container.clicked() }
+
+ Text {
+ id: buttonLabel; text: container.text; anchors.centerIn: container; color: "black"; font.pixelSize: 24
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
-Rectangle{
- width: 360
- height: 540
- ParticleSystem{ id: particles }
- SpriteParticle{
- system: particles
- Sprite{
- name: "snow"
- source: "content/flake-01.png"
- frames: 51
- duration: 40
+Loader{
+ id: ldr
+ visible: false
+ focus: visible
+ onVisibleChanged: source = ""
+ opacity: visible?1:0
+ Behavior on opacity{NumberAnimation{}}
+
+ function setDemo(str){
+ visible = true;
+ source = str;
+ }
+ Image{//TODO: Augment with PARTICLES
+ z: 1
+ source: "icons/close.png"
+ MouseArea{
+ anchors.fill: parent
+ onClicked: ldr.visible = false;
}
}
- Drift{
- system: particles
+ Rectangle{
+ z: -1
anchors.fill: parent
- xDrift: 400;
- }
- TrailEmitter{
- system: particles
- particlesPerSecond: 20
- particleDuration: 7000
- emitting: true
- speed: PointVector{ y:80; yVariation: 40; }
- acceleration: PointVector{ y: 4 }
- particleSize: 20
- particleSizeVariation: 10
- width: parent.width
- height: 100
+ color:"black"
+ Text{
+ color: "white"
+ anchors.centerIn: parent
+ text: ldr.Status == Loader.Error ? "Error :(" : "Loading..."
+ }
+ MouseArea{
+ id: graball
+ anchors.fill: parent
+ onClicked:;
+ }
}
}
--- /dev/null
+function nameFromPath(path){
+ var ret = path.split('/');
+ return ret[ret.length-1].split('.')[0];
+}
+function iconFromPath(path){
+ var ret = path.split('/');
+ return "launcherContent/icons/" + ret[ret.length-1].split('.')[0] + ".png";
+}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "../../modelviews/listview/content" as OtherDemo
import "content/script.js" as Script
import "content"
ParticleSystem{
id: sys;
}
- TrailEmitter{
+ Emitter{
system: sys
particle: "A"
width: parent.width/2
x: parent.width/4
y:parent.height
- speed: PointVector{ y: -64; yVariation: 16 }
- particlesPerSecond: 1
- particleDuration: 8000
+ speed: PointDirection{ y: -64; yVariation: 16 }
+ emitRate: 1
+ lifeSpan: 8000
}
- Drift{
+ Wander{
system: sys
- xDrift: 200
+ xVariance: 400
+ pace: 200
}
- DataParticle{
+ ModelParticle{
id: mp
z: 0
system: sys
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content"
Item{
height: 240
property bool inGrid: false
ParticleSystem{ id: sys }
- TrailEmitter{
+ Emitter{
system: sys
id: burster;
emitting: false
- particlesPerSecond: 1000
- particleDuration: 500
- speed: PointVector{xVariation: 400; yVariation: 400}
+ emitRate: 1000
+ lifeSpan: 50000
+ emitCap: 100;
+ speed: PointDirection{xVariation: 400; yVariation: 400}
anchors.centerIn: parent
Timer{
interval: 1000
onTriggered: {inGrid = true;}// sys.running = false;}
}
}
- ColoredParticle{
+ ImageParticle{
system: sys
- image: "../trails/content/particle.png"
+ source: "../trails/content/particle.png"
color: "black"
colorVariation: 0.0
}
width: 120
height: 120
}
- DataParticle{
+ ModelParticle{
system: sys
model: theModel.parts.particles
+ fade: false
}
Friction{
system: sys
- factor: 1
- }
- Stasis{
- system: sys
- targetLife: 400
+ factor: 5
}
VisualDataModel{
id: theModel
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content"
Rectangle {
width: 200; height:200
model: visualModel.parts.list
}
- DataParticle{
+ ModelParticle{
x: 200; width: 200; height:200
model: visualModel.parts.grid
system: sys
id: sys
anchors.fill: parent
}
- TrailEmitter{
+ Emitter{
system: sys
width: 100
x: 50
- speed: PointVector{ y: 40 }
- particleDuration: 5000
- particlesPerSecond: 1.6
+ speed: PointDirection{ y: 40 }
+ lifeSpan: 5000
+ emitRate: 1.6
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content/script.js" as Script
import "content"
overwrite: false
startTime: 12000//Doesn't actually work with the loading time though...
}
- TrailEmitter{
+ Emitter{
id: emitter
system: sys
height: parent.height - 132/2
x: -132/2
y: 132/2
- speed: PointVector{ x: 32; xVariation: 8 }
- particlesPerSecond: 0.5
- particleDuration: 120000 //TODO: A -1 or something which does 'infinite'? (but need disable fade first)
+ speed: PointDirection{ x: 32; xVariation: 8 }
+ emitRate: 0.5
+ lifeSpan: 120000 //TODO: A -1 or something which does 'infinite'? (but need disable fade first)
particle: "photos"
}
Kill{
height: parent.height
width: 1000
}
- ColoredParticle{
+ ImageParticle{
system: sys
particles: ["fireworks"]
- image: "../trails/content/star.png"
+ source: "../trails/content/star.png"
color: "lightsteelblue"
alpha: 0
colorVariation: 0
}
property Item alertItem;
function alert(){
- resetter.active = false
+ //resetter.active = false
force.active = true;
alertItem = alertDelegate.createObject(root);
alertItem.x = root.width/2 - alertItem.width/2
interval: 800
onTriggered: {
force.active = false
- resetter.active = true;
+ //resetter.active = true;
mp.take(alertItem, true);
centerEmitter.burst(1);
}
}
- Attractor{
+ PointAttractor{
id: force
system: sys
x: root.width/2
y: root.height/2
- strength: -30000
+ strength: -10000
active: false
anchors.centerIn: parent
width: parent.width/2
height: parent.height/2
particles:["photos"]
+ physics: PointAttractor.Position
}
- Reset{
- id: resetter
- system: sys
- particles:["photos"]
- }
- TrailEmitter{
+ Emitter{
id: centerEmitter
- speed: PointVector{ x: 32; xVariation: 8;}
- particlesPerSecond: 0.5
- particleDuration: 12000 //TODO: A -1 or something which does 'infinite'? (but need disable fade first)
- maxParticles: 20
+ speed: PointDirection{ x: 32; xVariation: 8;}
+ emitRate: 0.5
+ lifeSpan: 12000 //TODO: A -1 or something which does 'infinite'? (but need disable fade first)
+ emitCap: 20
particle: "photos"
system: sys
anchors.centerIn: parent
//TODO: Zoom in effect
}
- TrailEmitter{
+ Emitter{
id: spawnFireworks
particle: "fireworks"
system: sys
- maxParticles: 400
- particlesPerSecond: 400
- particleDuration: 2800
+ emitCap: 400
+ emitRate: 400
+ lifeSpan: 2800
x: parent.width/2
y: parent.height/2 - 64
width: 8
height: 8
emitting: false
- particleSize: 32
- particleEndSize: 8
- speed: AngleVector{ magnitude: 160; magnitudeVariation: 120; angleVariation: 90; angle: 270 }
- acceleration: PointVector{ y: 160 }
+ size: 32
+ endSize: 8
+ speed: AngledDirection{ magnitude: 160; magnitudeVariation: 120; angleVariation: 90; angle: 270 }
+ acceleration: PointDirection{ y: 160 }
}
Item{ x: -1000; y: -1000 //offscreen
Repeater{//Load them here, add to system on completed
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
+import "content"
+import "../launcherContent" as UI
Rectangle{
width: 360
height: 540
ParticleSystem { id: particles }
- SpriteParticle {
+ ImageParticle {
system: particles
- Sprite{
+ sprites: Sprite{
name: "snow"
source: "content/flake-01.png"
frames: 51
}
}
Wander {
+ id: wanderer
system: particles
anchors.fill: parent
- xVariance: 40;
- pace: 40;
+ xVariance: 360/(wanderer.physics+1);
+ pace: 100*(wanderer.physics+1);
}
- TrailEmitter {
+ Emitter {
system: particles
- particlesPerSecond: 20
- particleDuration: 7000
+ emitRate: 20
+ lifeSpan: 7000
emitting: true
- speed: PointVector{ y:80; yVariation: 40; }
- acceleration: PointVector{ y: 4 }
- particleSize: 20
- particleSizeVariation: 10
+ speed: PointDirection{ y:80; yVariation: 40; }
+ acceleration: PointDirection{ y: 4 }
+ size: 20
+ sizeVariation: 10
width: parent.width
height: 100
}
+ Row{
+ anchors.bottom: parent.bottom
+ anchors.horizontalCenter: parent.horizontalCenter
+ UI.Button{
+ text:"dx/dt"
+ onClicked: wanderer.physics = Wander.Position;
+ }
+ UI.Button{
+ text:"dv/dt"
+ onClicked: wanderer.physics = Wander.Velocity;
+ }
+ UI.Button{
+ text:"da/dt"
+ onClicked: wanderer.physics = Wander.Acceleration;
+ }
+ }
}
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the examples of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:BSD$
-** You may use this file under the terms of the BSD license as follows:
-**
-** "Redistribution and use in source and binary forms, with or without
-** modification, are permitted provided that the following conditions are
-** met:
-** * Redistributions of source code must retain the above copyright
-** notice, this list of conditions and the following disclaimer.
-** * Redistributions in binary form must reproduce the above copyright
-** notice, this list of conditions and the following disclaimer in
-** the documentation and/or other materials provided with the
-** distribution.
-** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
-** the names of its contributors may be used to endorse or promote
-** products derived from this software without specific prior written
-** permission.
-**
-** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-import QtQuick 2.0
-import Qt.labs.particles 2.0
-
-Rectangle{
- width: 360
- height: 540
- id: root
- ParticleSystem{ id: particles }
- SpriteParticle{
- system: particles
- sprites: Sprite{
- name: "snow"
- source: "content/flake-01.png"
- frames: 51
- duration: 40
- }
- }
- Drift{
- system: particles
- anchors.fill: parent
- xDrift: 200
- }
- SpeedLimit{
- system: particles
- anchors.fill: parent
- speedLimit: 100
- }
- TrailEmitter{
- system: particles
- particlesPerSecond: 20
- particleDuration: 7000
- emitting: true
- speed: PointVector{ y:80; yVariation: 40; }
- acceleration: PointVector{ y: 4 }
- particleSize: 20
- particleSizeVariation: 10
- width: parent.width
- height: 40
- }
-}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content/helpers.js" as Helpers
Rectangle{
property bool fakeMoving: false
property real fakeMovementDir: 0
- TrailEmitter{
+ Emitter{
particle: "stars2"
system: background
- particlesPerSecond: 60
- particleDuration: 4000
+ emitRate: 60
+ lifeSpan: 4000
emitting: true
- particleSize: 10
- particleSizeVariation: 10
+ size: 10
+ sizeVariation: 10
anchors.fill: parent
}
ParticleSystem{ id: background }
- ColoredParticle{
+ ImageParticle{
particles: ["stars2"]
system: background
anchors.fill: parent
- image: "content/star.png"
+ source: "content/star.png"
color: "white"
colorVariation: 0.1
}
ParticleSystem{ id: foreground }
- ColoredParticle{
+ ImageParticle{
particles: ["stars"]
anchors.fill: parent
system: foreground
- image: "content/star.png"
+ source: "content/star.png"
color: "white"
colorVariation: 0.1
}
- ColoredParticle{
+ ImageParticle{
particles: ["shot"]
anchors.fill: parent
system: foreground
- image: "content/star.png"
+ source: "content/star.png"
color: "orange"
colorVariation: 0.3
}
- ColoredParticle{
+ ImageParticle{
id: engine
particles: ["engine"]
anchors.fill: parent
system: foreground
- image: "content/particle4.png"
+ source: "content/particle4.png"
color: "orange"
SequentialAnimation on color {
colorVariation: 0.2
}
- SpriteParticle{
+ ImageParticle{
particles: ["powerups"]
anchors.fill: parent
system: foreground
- Sprite{
+ sprites:[Sprite{
name: "norm"
source: "content/powerupScore.png"
frames: 35
duration: 40
to: {"norm":1, "got":0}
- }
+ },
Sprite{
name: "got"
source: "content/powerupScore_got.png"
frames: 22
duration: 40
to: {"null":1}
- }
+ },
Sprite{
name: "null"
source: "content/powerupScore_gone.png"
frames: 1
duration: 1000
}
+ ]
}
SpriteGoal{
x: rocket.x - 30
onAffected: if(!gameOver) score += 1000
system: foreground
}
- GravitationalSingularity{
+ PointAttractor{
id: gs1; x: vorteX; y: vorteY; strength: 800000;
+ proportionalToDistance: PointAttractor.Quadratic;
system: foreground
}
Kill{
system: foreground
}
- GravitationalSingularity{
+ PointAttractor{
id: gs2; x: vorteX2; y: vorteY2; strength: 800000;
+ proportionalToDistance: PointAttractor.Quadratic;
system: foreground
}
Kill{
system: foreground
}
- GravitationalSingularity{
+ PointAttractor{
id: gs3; x: vorteX3; y: vorteY3; strength: 800000;
+ proportionalToDistance: PointAttractor.Quadratic;
system: foreground
}
Kill{
height: holeSize * 2
system: foreground
}
- GravitationalSingularity{
+ PointAttractor{
id: gs4; x: vorteX4; y: vorteY4; strength: 800000;
+ proportionalToDistance: PointAttractor.Quadratic;
system: foreground
}
Kill{
height: holeSize * 2
system: foreground
}
- TrailEmitter{
+ Emitter{
particle: "powerups"
system: foreground
- particlesPerSecond: 1
- particleDuration: 6000
+ emitRate: 1
+ lifeSpan: 6000
emitting: !gameOver
- particleSize: 60
- particleSizeVariation: 10
+ size: 60
+ sizeVariation: 10
anchors.fill: parent
}
- TrailEmitter{
+ Emitter{
particle: "stars"
system: foreground
- particlesPerSecond: 40
- particleDuration: 4000
+ emitRate: 40
+ lifeSpan: 4000
emitting: !gameOver
- particleSize: 30
- particleSizeVariation: 10
+ size: 30
+ sizeVariation: 10
anchors.fill: parent
}
SpriteImage{
drag.axis: Drag.XandYAxis
drag.target: rocket
},
- TrailEmitter{
+ Emitter{
system: foreground
particle: "engine"
- particlesPerSecond: 100
- particleDuration: 1000
+ emitRate: 100
+ lifeSpan: 1000
emitting: !gameOver
- particleSize: 10
- particleEndSize: 4
- particleSizeVariation: 4
- speed: PointVector{
+ size: 10
+ endSize: 4
+ sizeVariation: 4
+ speed: PointDirection{
x: -128 * Math.cos(rocket.rotation * (Math.PI / 180))
y: -128 * Math.sin(rocket.rotation * (Math.PI / 180))
}
width: 4
},
- TrailEmitter{
+ Emitter{
system: foreground
particle: "shot"
- particlesPerSecond: 16
- particleDuration: 1600
+ emitRate: 16
+ lifeSpan: 1600
emitting: !gameOver && shoot
- particleSize: 40
- speed: PointVector{
+ size: 40
+ speed: PointDirection{
x: 256 * Math.cos(rocket.rotation * (Math.PI / 180))
y: 256 * Math.sin(rocket.rotation * (Math.PI / 180))
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
id: root
ParticleSystem{
id: sys
}
- ColoredParticle{
+ ImageParticle{
system: sys
- image: "content/particle.png"
+ source: "content/particle.png"
color: "white"
colorVariation: 1.0
alpha: 0.1
}
Component{
id: emitterComp
- TrailEmitter{
+ Emitter{
id: container
- TrailEmitter{
+ Emitter{
id: emitMore
system: sys
emitting: true
- particlesPerSecond: 128
- particleDuration: 600
- particleSize: 16
- particleEndSize: 8
- speed: AngleVector{angleVariation:360; magnitude: 60}
+ emitRate: 128
+ lifeSpan: 600
+ size: 16
+ endSize: 8
+ speed: AngledDirection{angleVariation:360; magnitude: 60}
}
property int life: 2600
}
system: sys
emitting: true
- particlesPerSecond: 64
- particleDuration: 600
- particleSize: 24
- particleEndSize: 8
+ emitRate: 64
+ lifeSpan: 600
+ size: 24
+ endSize: 8
NumberAnimation on x{
id: xAnim;
to: targetX
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle {
id: root
}
/*
- ColoredParticle{
+ ImageParticle{
id: fireball
anchors.fill: parent
particles: ["E"]
system: particles
- image: "content/particleA.png"
+ source: "content/particleA.png"
colorVariation: 0.2
color: "#00ff400f"
}
*/
- ColoredParticle{
+ ImageParticle{
id: smoke
system: particles
anchors.fill: parent
particles: ["A", "B"]
- image: "content/particle.png"
+ source: "content/particle.png"
colorVariation: 0
color: "#00111111"
}
- ColoredParticle{
+ ImageParticle{
id: flame
anchors.fill: parent
system: particles
particles: ["C", "D"]
- image: "content/particle.png"
+ source: "content/particle.png"
colorVariation: 0.1
color: "#00ff400f"
}
- TrailEmitter{
+ Emitter{
id: fire
system: particles
particle: "C"
y: parent.height
width: parent.width
- particlesPerSecond: 350
- particleDuration: 3500
+ emitRate: 350
+ lifeSpan: 3500
- acceleration: PointVector{ y: -17; xVariation: 3 }
- speed: PointVector{xVariation: 3}
+ acceleration: PointDirection{ y: -17; xVariation: 3 }
+ speed: PointDirection{xVariation: 3}
- particleSize: 24
- particleSizeVariation: 8
- particleEndSize: 4
+ size: 24
+ sizeVariation: 8
+ endSize: 4
}
FollowEmitter{
id: fireSmoke
width: root.width
height: root.height - 68
- particlesPerParticlePerSecond: 1
- particleDuration: 2000
+ emitRatePerParticle: 1
+ lifeSpan: 2000
- speed: PointVector{y:-17*6; yVariation: -17; xVariation: 3}
- acceleration: PointVector{xVariation: 3}
+ speed: PointDirection{y:-17*6; yVariation: -17; xVariation: 3}
+ acceleration: PointDirection{xVariation: 3}
- particleSize: 36
- particleSizeVariation: 8
- particleEndSize: 16
+ size: 36
+ sizeVariation: 8
+ endSize: 16
}
FollowEmitter{
id: fireballFlame
particle: "D"
follow: "E"
- particlesPerParticlePerSecond: 120
- particleDuration: 180
- emissionWidth: 8
- emissionHeight: 8
+ emitRatePerParticle: 120
+ lifeSpan: 180
+ emitWidth: 8
+ emitHeight: 8
- particleSize: 16
- particleSizeVariation: 4
- particleEndSize: 4
+ size: 16
+ sizeVariation: 4
+ endSize: 4
}
FollowEmitter{
particle: "A"
follow: "E"
- particlesPerParticlePerSecond: 128
- particleDuration: 2400
- emissionWidth: 16
- emissionHeight: 16
+ emitRatePerParticle: 128
+ lifeSpan: 2400
+ emitWidth: 16
+ emitHeight: 16
- speed: PointVector{yVariation: 16; xVariation: 16}
- acceleration: PointVector{y: -16}
+ speed: PointDirection{yVariation: 16; xVariation: 16}
+ acceleration: PointDirection{y: -16}
- particleSize: 24
- particleSizeVariation: 8
- particleEndSize: 8
+ size: 24
+ sizeVariation: 8
+ endSize: 8
}
- TrailEmitter{
+ Emitter{
id: balls
system: particles
particle: "E"
y: parent.height
width: parent.width
- particlesPerSecond: 2
- particleDuration: 7000
+ emitRate: 2
+ lifeSpan: 7000
- speed: PointVector{y:-17*4*2; xVariation: 6*6}
- acceleration: PointVector{y: 17*2; xVariation: 6*6}
+ speed: PointDirection{y:-17*4*2; xVariation: 6*6}
+ acceleration: PointDirection{y: 17*2; xVariation: 6*6}
- particleSize: 12
- particleSizeVariation: 4
+ size: 12
+ sizeVariation: 4
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
id: root
id: sys
startTime: 4000
}
- TrailEmitter{
+ Emitter{
system: sys
y:root.height + 20
width: root.width
- particlesPerSecond: 200
- particleDuration: 4000
- speed: PointVector{ y: -120; }
+ emitRate: 200
+ lifeSpan: 4000
+ speed: PointDirection{ y: -120; }
}
- SpriteParticle{
+ ImageParticle{
system: sys
visible: !cloneMode
- Sprite{
- source: "content/particle2.png"
- }
+ source: "content/particle2.png"
}
- SpriteParticle{
+ ImageParticle{
system: sys
visible: cloneMode
z: 0
- Sprite{
- source: "content/particle3.png"
- }
+ source: "content/particle3.png"
}
- SpriteParticle{
+ ImageParticle{
system: sys
clip: true
visible: cloneMode
height: 240
width: root.width
z: 1
- Sprite{
- source: "content/particle.png"
- }
+ source: "content/particle.png"
}
}
// highlight bar is moved between items. + Particles.
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import "content"
Rectangle {
width: 200; height: 300
color: "black"
ParticleSystem{ id: particles }
- ColoredParticle{
+ ImageParticle{
anchors.fill: parent
system: particles
z: 10
- image: "content/star.png"
+ source: "content/star.png"
color: "white"
colorVariation: 0.0
}
y: listView.currentItem.y;
//Behavior on y { SpringAnimation { spring: 2; damping: 0.1 } }
Behavior on y { NumberAnimation {id: anim} }
- TrailEmitter{
+ Emitter{
anchors.fill: parent
system: particles;
emitting: anim.running
- particlesPerSecond: 600
- particleDuration: 600
- particleSize: 16
- particleEndSize: 8
+ emitRate: 600
+ lifeSpan: 600
+ size: 16
+ endSize: 8
}
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "black"
width: 360
height: 540
ParticleSystem{ id: sys }
- ColoredParticle{
+ ImageParticle{
system: sys
id: cp
- image: "content/particle.png"
+ source: "content/particle.png"
colorVariation: 0.4
color: "#000000FF"
}
- TrailEmitter{
+ Emitter{
//burst on click
id: bursty
system: sys
emitting: ma.pressed
x: ma.mouseX
y: ma.mouseY
- particlesPerSecond: 16000
- particleDuration: 1000
- maxParticles: 4000
- acceleration: AngleVector{angleVariation: 360; magnitude: 360; }
- particleSize: 8
- particleEndSize: 16
- particleSizeVariation: 4
+ emitRate: 16000
+ lifeSpan: 1000
+ emitCap: 4000
+ acceleration: AngledDirection{angleVariation: 360; magnitude: 360; }
+ size: 8
+ endSize: 16
+ sizeVariation: 4
}
MouseArea{
anchors.fill: parent
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
id: root
id: particles
startTime: 2000
}
- ColoredParticle{
+ ImageParticle{
particles: ["center","edge"]
anchors.fill: parent
system: particles
- image: "content/particle.png"
+ source: "content/particle.png"
colorVariation: 0.1
color: "#009999FF"
}
- TrailEmitter{
+ Emitter{
anchors.fill: parent
particle: "center"
system: particles
- particlesPerSecond: 200
- particleDuration: 2000
+ emitRate: 200
+ lifeSpan: 2000
emitting: true
- particleSize: 20
- particleSizeVariation: 2
- particleEndSize: 0
- shape: Ellipse{fill: false}
- speed: DirectedVector{
+ size: 20
+ sizeVariation: 2
+ endSize: 0
+ shape: EllipseShape{fill: false}
+ speed: TargetedDirection{
targetX: root.width/2
targetY: root.height/2
proportionalMagnitude: true
magnitude: 0.5
}
}
- TrailEmitter{
+ Emitter{
anchors.fill: parent
particle: "edge"
system: particles
- particlesPerSecond: 4000
- particleDuration: 2000
+ emitRate: 4000
+ lifeSpan: 2000
emitting: true
- particleSize: 20
- particleSizeVariation: 2
- particleEndSize: 0
- shape: Ellipse{fill: false}
- speed: DirectedVector{
+ size: 20
+ sizeVariation: 2
+ endSize: 0
+ shape: EllipseShape{fill: false}
+ speed: TargetedDirection{
targetX: root.width/2
targetY: root.height/2
proportionalMagnitude: true
magnitude: 0.1
magnitudeVariation: 0.1
}
- acceleration: DirectedVector{
+ acceleration: TargetedDirection{
targetX: root.width/2
targetY: root.height/2
targetVariation: 200
**
****************************************************************************/
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
import QtQuick 2.0
Rectangle {
color: "black"
ParticleSystem{ id: particles }
- ColoredParticle{
+ ImageParticle{
system: particles
colorVariation: 0.5
alpha: 0
- image: "content/particle.png"
+ source: "content/particle.png"
colorTable: "content/colortable.png"
sizeTable: "content/colortable.png"
}
- TrailEmitter{
+ Emitter{
system: particles
- particlesPerSecond: 500
- particleDuration: 2000
+ emitRate: 500
+ lifeSpan: 2000
y: root.height / 2 + Math.sin(t * 2) * root.height * 0.3
x: root.width / 2 + Math.cos(t) * root.width * 0.3
speedFromMovement: 20
- speed: PointVector{ xVariation: 5; yVariation: 5;}
- acceleration: PointVector{ xVariation: 5; yVariation: 5;}
+ speed: PointDirection{ xVariation: 5; yVariation: 5;}
+ acceleration: PointDirection{ xVariation: 5; yVariation: 5;}
- particleSize: 16
- //particleEndSize: 8
- //particleSizeVariation: 8
+ size: 16
+ //endSize: 8
+ //sizeVariation: 8
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
width: 360
id: particles
running: false
}
- ColoredParticle{
+ ImageParticle{
anchors.fill: parent
system: particles
- image: "content/star.png"
+ source: "content/star.png"
sizeTable: "content/sparkleSize.png"
alpha: 0
colorVariation: 0.6
}
- TrailEmitter{
+ Emitter{
anchors.fill: parent
system: particles
- particlesPerSecond: 2000
- particleDuration: 2000
+ emitRate: 2000
+ lifeSpan: 2000
emitting: true
- particleSize: 30
- particleSizeVariation: 10
+ size: 30
+ sizeVariation: 10
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
color: "black"
width: 360
height: 540
ParticleSystem{ id: sys }
- ColoredParticle{
+ ImageParticle{
system: sys
id: cp
- image: "content/particle.png"
+ source: "content/particle.png"
color: "#00FFFFFF"
colorVariation: 0.4
}
- TrailEmitter{
+ Emitter{
//burst on click
id: bursty
system: sys
emitting: false
- particlesPerSecond: 2000
- particleDuration: 500
- acceleration: AngleVector{ angle: 90; angleVariation: 360; magnitude: 640; }
- particleSize: 8
- particleEndSize: 16
- particleSizeVariation: 4
+ emitRate: 2000
+ lifeSpan: 500
+ acceleration: AngledDirection{ angle: 90; angleVariation: 360; magnitude: 640; }
+ size: 8
+ endSize: 16
+ sizeVariation: 4
}
- TrailEmitter{
+ Emitter{
system: sys
speedFromMovement: 4.0
emitting: ma.pressed
x: ma.mouseX
y: ma.mouseY
- particlesPerSecond: 400
- particleDuration: 2000
- acceleration: AngleVector{ angle: 90; angleVariation: 22; magnitude: 32; }
- particleSize: 8
- particleEndSize: 16
- particleSizeVariation: 8
+ emitRate: 400
+ lifeSpan: 2000
+ acceleration: AngledDirection{ angle: 90; angleVariation: 22; magnitude: 32; }
+ size: 8
+ endSize: 16
+ sizeVariation: 8
}
MouseArea{
id: ma
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle{
width: 360
frequency: 64
gridSize: 16
}
- ColoredParticle{
+ ImageParticle{
particles: ["smoke"]
system: ps
- image: "content/particle.png"
+ source: "content/particle.png"
color: "#11111111"
colorVariation: 0
}
- ColoredParticle{
+ ImageParticle{
particles: ["flame"]
system: ps
- image: "content/particle.png"
+ source: "content/particle.png"
color: "#11ff400f"
colorVariation: 0.1
}
- TrailEmitter{
+ Emitter{
anchors.centerIn: parent
system: ps
particle: "flame"
- particlesPerSecond: 120
- particleDuration: 1200
- particleSize: 20
- particleEndSize: 10
- particleSizeVariation: 10
- acceleration: PointVector{ y: -40 }
- speed: AngleVector{ angle: 270; magnitude: 20; angleVariation: 22; magnitudeVariation: 5 }
+ emitRate: 120
+ lifeSpan: 1200
+ size: 20
+ endSize: 10
+ sizeVariation: 10
+ acceleration: PointDirection{ y: -40 }
+ speed: AngledDirection{ angle: 270; magnitude: 20; angleVariation: 22; magnitudeVariation: 5 }
}
FollowEmitter{
id: smoke1
particle: "smoke"
follow: "flame"
- particlesPerParticlePerSecond: 4
- particleDuration: 2400
- particleDurationVariation: 400
- particleSize: 16
- particleEndSize: 8
- particleSizeVariation: 8
- acceleration: PointVector{ y: -40 }
- speed: AngleVector{ angle: 270; magnitude: 40; angleVariation: 22; magnitudeVariation: 5 }
+ emitRatePerParticle: 4
+ lifeSpan: 2400
+ lifeSpanVariation: 400
+ size: 16
+ endSize: 8
+ sizeVariation: 8
+ acceleration: PointDirection{ y: -40 }
+ speed: AngledDirection{ angle: 270; magnitude: 40; angleVariation: 22; magnitudeVariation: 5 }
}
FollowEmitter{
id: smoke2
particle: "smoke"
follow: "flame"
- particlesPerParticlePerSecond: 1
- particleDuration: 2400
- particleSize: 36
- particleEndSize: 24
- particleSizeVariation: 8
- acceleration: PointVector{ y: -40 }
- speed: AngleVector{ angle: 270; magnitude: 40; angleVariation: 22; magnitudeVariation: 5 }
+ emitRatePerParticle: 1
+ lifeSpan: 2400
+ size: 36
+ endSize: 24
+ sizeVariation: 8
+ acceleration: PointDirection{ y: -40 }
+ speed: AngledDirection{ angle: 270; magnitude: 40; angleVariation: 22; magnitudeVariation: 5 }
}
}
****************************************************************************/
import QtQuick 2.0
-import Qt.labs.particles 2.0
+import QtQuick.Particles 2.0
Rectangle {
}
ParticleSystem{ id: sys1 }
- ColoredParticle{
+ ImageParticle{
system: sys1
- image: "content/particle.png"
+ source: "content/particle.png"
color: "cyan"
alpha: 0
SequentialAnimation on color {
}
colorVariation: 0.3
}
- TrailEmitter{
+ Emitter{
id: trailsNormal
system: sys1
- particlesPerSecond: 500
- particleDuration: 2000
+ emitRate: 500
+ lifeSpan: 2000
y: mouseArea.pressed ? mouseArea.mouseY : circle.cy
x: mouseArea.pressed ? mouseArea.mouseX : circle.cx
- speed: PointVector{xVariation: 4; yVariation: 4;}
- acceleration: PointVector{xVariation: 10; yVariation: 10;}
+ speed: PointDirection{xVariation: 4; yVariation: 4;}
+ acceleration: PointDirection{xVariation: 10; yVariation: 10;}
speedFromMovement: 8
- particleSize: 8
- particleSizeVariation: 4
+ size: 8
+ sizeVariation: 4
}
ParticleSystem { id: sys2 }
- ColoredParticle{
+ ImageParticle{
color: "cyan"
system: sys2
alpha: 0
}
}
colorVariation: 0.5
- image: "content/star.png"
+ source: "content/star.png"
}
- TrailEmitter{
+ Emitter{
id: trailsStars
system: sys2
- particlesPerSecond: 100
- particleDuration: 2200
+ emitRate: 100
+ lifeSpan: 2200
y: mouseArea.pressed ? mouseArea.mouseY : circle.cy
x: mouseArea.pressed ? mouseArea.mouseX : circle.cx
- speed: PointVector{xVariation: 4; yVariation: 4;}
- acceleration: PointVector{xVariation: 10; yVariation: 10;}
+ speed: PointDirection{xVariation: 4; yVariation: 4;}
+ acceleration: PointDirection{xVariation: 10; yVariation: 10;}
speedFromMovement: 8
- particleSize: 22
- particleSizeVariation: 4
+ size: 22
+ sizeVariation: 4
}
ParticleSystem { id: sys3; }
- ColoredParticle{
- image: "content/particle.png"
+ ImageParticle{
+ source: "content/particle.png"
system: sys3
color: "orange"
alpha: 0
colorVariation: 0.2
}
- TrailEmitter{
+ Emitter{
id: trailsNormal2
system: sys3
- particlesPerSecond: 300
- particleDuration: 2000
+ emitRate: 300
+ lifeSpan: 2000
y: mouseArea.pressed ? mouseArea.mouseY : circle2.cy
x: mouseArea.pressed ? mouseArea.mouseX : circle2.cx
speedFromMovement: 16
- speed: PointVector{xVariation: 4; yVariation: 4;}
- acceleration: PointVector{xVariation: 10; yVariation: 10;}
+ speed: PointDirection{xVariation: 4; yVariation: 4;}
+ acceleration: PointDirection{xVariation: 10; yVariation: 10;}
- particleSize: 12
- particleSizeVariation: 4
+ size: 12
+ sizeVariation: 4
}
ParticleSystem { id: sys4; }
- ColoredParticle{
+ ImageParticle{
system: sys4
- image: "content/star.png"
+ source: "content/star.png"
color: "green"
alpha: 0
SequentialAnimation on color {
colorVariation: 0.5
}
- TrailEmitter{
+ Emitter{
id: trailsStars2
system: sys4
- particlesPerSecond: 50
- particleDuration: 2200
+ emitRate: 50
+ lifeSpan: 2200
y: mouseArea.pressed ? mouseArea.mouseY : circle2.cy
x: mouseArea.pressed ? mouseArea.mouseX : circle2.cx
speedFromMovement: 16
- speed: PointVector{xVariation: 2; yVariation: 2;}
- acceleration: PointVector{xVariation: 10; yVariation: 10;}
+ speed: PointDirection{xVariation: 2; yVariation: 2;}
+ acceleration: PointDirection{xVariation: 10; yVariation: 10;}
- particleSize: 22
- particleSizeVariation: 4
+ size: 22
+ sizeVariation: 4
}
PaletteItem {
anchors.verticalCenter: parent.verticalCenter
componentFile: "Sun.qml"
- image: "../images/sun.png"
+ source: "../images/sun.png"
}
PaletteItem {
anchors.verticalCenter: parent.verticalCenter
componentFile: "GenericSceneItem.qml"
- image: "../images/moon.png"
+ source: "../images/moon.png"
}
PaletteItem {
anchors.verticalCenter: parent.verticalCenter
componentFile: "PerspectiveItem.qml"
- image: "../images/tree_s.png"
+ source: "../images/tree_s.png"
}
PaletteItem {
anchors.verticalCenter: parent.verticalCenter
componentFile: "PerspectiveItem.qml"
- image: "../images/rabbit_brown.png"
+ source: "../images/rabbit_brown.png"
}
PaletteItem {
anchors.verticalCenter: parent.verticalCenter
componentFile: "PerspectiveItem.qml"
- image: "../images/rabbit_bw.png"
+ source: "../images/rabbit_bw.png"
}
}
}
id: sun
property bool created: false
- property string image: "../images/sun.png"
+ property string source: "../images/sun.png"
source: image
Flipable {
id: container
- property alias image: frontImage.source
+ property alias source: frontImage.source
property bool flipped: true
property int xAxis: 0
property int yAxis: 0
Row {
anchors.centerIn: parent; spacing: 30
- Card { image: "content/9_club.png"; angle: 180; yAxis: 1 }
- Card { image: "content/5_heart.png"; angle: 540; xAxis: 1 }
+ Card { source: "content/9_club.png"; angle: 180; yAxis: 1 }
+ Card { source: "content/5_heart.png"; angle: 540; xAxis: 1 }
}
}
$$PWD/qdeclarativedebug.cpp \
$$PWD/qdeclarativedebugtrace.cpp \
$$PWD/qdeclarativedebughelper.cpp \
- $$PWD/qdeclarativedebugserver.cpp
+ $$PWD/qdeclarativedebugserver.cpp \
+ $$PWD/qdeclarativeobserverservice.cpp \
+ $$PWD/qjsdebuggeragent.cpp \
+ $$PWD/qjsdebugservice.cpp
HEADERS += \
$$PWD/qdeclarativedebuggerstatus_p.h \
$$PWD/qdeclarativedebugtrace_p.h \
$$PWD/qdeclarativedebughelper_p.h \
$$PWD/qdeclarativedebugserver_p.h \
- debugger/qdeclarativedebugserverconnection_p.h
+ $$PWD/qdeclarativedebugserverconnection_p.h \
+ $$PWD/qdeclarativeobserverservice_p.h \
+ $$PWD/qdeclarativeobserverinterface_p.h \
+ $$PWD/qjsdebuggeragent_p.h \
+ $$PWD/qjsdebugservice_p.h
int separatorIndex = appD->qmljsDebugArgumentsString().indexOf(QLatin1Char(','));
port = appD->qmljsDebugArgumentsString().mid(5, separatorIndex - 5).toInt(&ok);
pluginName = QLatin1String("qmldbg_tcp");
- } else if (appD->qmljsDebugArgumentsString().contains("ost")) {
+ } else if (appD->qmljsDebugArgumentsString().contains(QLatin1String("ost"))) {
pluginName = QLatin1String("qmldbg_ost");
ok = true;
}
int version;
in >> version >> d->clientPlugins;
+ // Send the hello answer immediately, since it needs to arrive before
+ // the plugins below start sending messages.
+ QByteArray helloAnswer;
+ {
+ QDataStream out(&helloAnswer, QIODevice::WriteOnly);
+ out << QString(QLatin1String("QDeclarativeDebugClient")) << 0 << protocolVersion << d->plugins.keys();
+ }
+ d->connection->send(helloAnswer);
+
+ d->gotHello = true;
+
QHash<QString, QDeclarativeDebugService*>::Iterator iter = d->plugins.begin();
for (; iter != d->plugins.end(); ++iter) {
QDeclarativeDebugService::Status newStatus = QDeclarativeDebugService::Unavailable;
iter.value()->statusChanged(newStatus);
}
- QByteArray helloAnswer;
- {
- QDataStream out(&helloAnswer, QIODevice::WriteOnly);
- out << QString(QLatin1String("QDeclarativeDebugClient")) << 0 << protocolVersion << d->plugins.keys();
- }
- d->connection->send(helloAnswer);
-
- d->gotHello = true;
qWarning("QDeclarativeDebugServer: Connection established");
} else {
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef RESETAFFECTOR_H
-#define RESETAFFECTOR_H
-#include "particleaffector.h"
-#include <QHash>
+#ifndef QDECLARATIVEOBSERVERINTERFACE_H
+#define QDECLARATIVEOBSERVERINTERFACE_H
+
+#include <QtDeclarative/private/qdeclarativeglobal_p.h>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-struct TrajectoryData{
- qreal sx,sy,ax,ay;
-};
-
-class ResetAffector : public ParticleAffector
+class Q_DECLARATIVE_EXPORT QDeclarativeObserverInterface
{
- Q_OBJECT
public:
- explicit ResetAffector(QSGItem *parent = 0);
- virtual void reset(int systemIdx);
-
-signals:
+ QDeclarativeObserverInterface() {}
+ virtual ~QDeclarativeObserverInterface() {}
-public slots:
-protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
-private:
- QHash<int, TrajectoryData*> m_data;
+ virtual void activate() = 0;
+ virtual void deactivate() = 0;
};
+Q_DECLARE_INTERFACE(QDeclarativeObserverInterface, "com.trolltech.Qt.QDeclarativeObserverInterface/1.0")
+
QT_END_NAMESPACE
+
QT_END_HEADER
-#endif // RESETAFFECTOR_H
+
+#endif // QDECLARATIVEOBSERVERINTERFACE_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qdeclarativeobserverservice_p.h"
+#include "private/qdeclarativeobserverinterface_p.h"
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+#include <QtCore/QDir>
+#include <QtCore/QPluginLoader>
+
+#include <QtDeclarative/QDeclarativeView>
+
+QT_BEGIN_NAMESPACE
+
+Q_GLOBAL_STATIC(QDeclarativeObserverService, serviceInstance)
+
+QDeclarativeObserverService::QDeclarativeObserverService()
+ : QDeclarativeDebugService(QLatin1String("QDeclarativeObserverMode"))
+ , m_observer(0)
+{
+}
+
+QDeclarativeObserverService *QDeclarativeObserverService::instance()
+{
+ return serviceInstance();
+}
+
+void QDeclarativeObserverService::addView(QDeclarativeView *view)
+{
+ m_views.append(view);
+}
+
+void QDeclarativeObserverService::removeView(QDeclarativeView *view)
+{
+ m_views.removeAll(view);
+}
+
+void QDeclarativeObserverService::sendMessage(const QByteArray &message)
+{
+ if (status() != Enabled)
+ return;
+
+ QDeclarativeDebugService::sendMessage(message);
+}
+
+void QDeclarativeObserverService::statusChanged(Status status)
+{
+ if (m_views.isEmpty())
+ return;
+
+ if (status == Enabled) {
+ if (!m_observer)
+ m_observer = loadObserverPlugin();
+
+ if (!m_observer) {
+ qWarning() << "Error while loading observer plugin";
+ return;
+ }
+
+ m_observer->activate();
+ } else {
+ if (m_observer)
+ m_observer->deactivate();
+ }
+}
+
+void QDeclarativeObserverService::messageReceived(const QByteArray &message)
+{
+ emit gotMessage(message);
+}
+
+QDeclarativeObserverInterface *QDeclarativeObserverService::loadObserverPlugin()
+{
+ QStringList pluginCandidates;
+ const QStringList paths = QCoreApplication::libraryPaths();
+ foreach (const QString &libPath, paths) {
+ const QDir dir(libPath + QLatin1String("/qmltooling"));
+ if (dir.exists())
+ foreach (const QString &pluginPath, dir.entryList(QDir::Files))
+ pluginCandidates << dir.absoluteFilePath(pluginPath);
+ }
+
+ foreach (const QString &pluginPath, pluginCandidates) {
+ QPluginLoader loader(pluginPath);
+ if (!loader.load())
+ continue;
+
+ QDeclarativeObserverInterface *observer =
+ qobject_cast<QDeclarativeObserverInterface*>(loader.instance());
+
+ if (observer)
+ return observer;
+ loader.unload();
+ }
+ return 0;
+}
+
+QT_END_NAMESPACE
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef DRIFTAFFECTOR_H
-#define DRIFTAFFECTOR_H
-#include "particleaffector.h"
+#ifndef QDECLARATIVEOBSERVERSERVICE_H
+#define QDECLARATIVEOBSERVERSERVICE_H
+
+#include "private/qdeclarativedebugservice_p.h"
+#include <private/qdeclarativeglobal_p.h>
+
+#include <QtCore/QList>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
+class QDeclarativeView;
+class QDeclarativeObserverInterface;
-class DriftAffector : public ParticleAffector
+class Q_DECLARATIVE_EXPORT QDeclarativeObserverService : public QDeclarativeDebugService
{
Q_OBJECT
- Q_PROPERTY(qreal xDrift READ xDrift WRITE setXDrift NOTIFY xDriftChanged)
- Q_PROPERTY(qreal yDrift READ yDrift WRITE setYDrift NOTIFY yDriftChanged)
-public:
- explicit DriftAffector(QSGItem *parent = 0);
- ~DriftAffector();
- qreal yDrift() const
- {
- return m_yDrift;
- }
-
- qreal xDrift() const
- {
- return m_xDrift;
- }
-protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
-
-signals:
- void yDriftChanged(qreal arg);
+public:
+ QDeclarativeObserverService();
+ static QDeclarativeObserverService *instance();
- void xDriftChanged(qreal arg);
+ void addView(QDeclarativeView *);
+ void removeView(QDeclarativeView *);
+ QList<QDeclarativeView*> views() const { return m_views; }
-public slots:
+ void sendMessage(const QByteArray &message);
-void setYDrift(qreal arg)
-{
- if (m_yDrift != arg) {
- m_yDrift = arg;
- emit yDriftChanged(arg);
- }
-}
+Q_SIGNALS:
+ void gotMessage(const QByteArray &message);
-void setXDrift(qreal arg)
-{
- if (m_xDrift != arg) {
- m_xDrift = arg;
- emit xDriftChanged(arg);
- }
-}
+protected:
+ virtual void statusChanged(Status status);
+ virtual void messageReceived(const QByteArray &);
private:
- qreal m_yDrift;
- qreal m_xDrift;
+ static QDeclarativeObserverInterface *loadObserverPlugin();
+
+ QList<QDeclarativeView*> m_views;
+ QDeclarativeObserverInterface *m_observer;
};
QT_END_NAMESPACE
+
QT_END_HEADER
-#endif // DRIFTAFFECTOR_H
+
+#endif // QDECLARATIVEOBSERVERSERVICE_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qjsdebuggeragent_p.h"
+#include "private/qdeclarativedebughelper_p.h"
+
+#include <QtCore/qdatetime.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qset.h>
+#include <QtCore/qurl.h>
+#include <QtScript/qscriptcontextinfo.h>
+#include <QtScript/qscriptengine.h>
+#include <QtScript/qscriptvalueiterator.h>
+
+QT_BEGIN_NAMESPACE
+
+class QJSDebuggerAgentPrivate
+{
+public:
+ QJSDebuggerAgentPrivate(QJSDebuggerAgent *q)
+ : q(q), state(NoState)
+ {}
+
+ void continueExec();
+ void recordKnownObjects(const QList<JSAgentWatchData> &);
+ QList<JSAgentWatchData> getLocals(QScriptContext *);
+ void positionChange(qint64 scriptId, int lineNumber, int columnNumber);
+ QScriptEngine *engine() { return q->engine(); }
+ void stopped();
+
+public:
+ QJSDebuggerAgent *q;
+ JSDebuggerState state;
+ int stepDepth;
+ int stepCount;
+
+ QEventLoop loop;
+ QHash<qint64, QString> filenames;
+ JSAgentBreakpoints breakpoints;
+ // breakpoints by filename (without path)
+ QHash<QString, JSAgentBreakpointData> fileNameToBreakpoints;
+ QStringList watchExpressions;
+ QSet<qint64> knownObjectIds;
+};
+
+namespace {
+
+class SetupExecEnv
+{
+public:
+ SetupExecEnv(QJSDebuggerAgentPrivate *a)
+ : agent(a),
+ previousState(a->state),
+ hadException(a->engine()->hasUncaughtException())
+ {
+ agent->state = StoppedState;
+ }
+
+ ~SetupExecEnv()
+ {
+ if (!hadException && agent->engine()->hasUncaughtException())
+ agent->engine()->clearExceptions();
+ agent->state = previousState;
+ }
+
+private:
+ QJSDebuggerAgentPrivate *agent;
+ JSDebuggerState previousState;
+ bool hadException;
+};
+
+} // anonymous namespace
+
+static JSAgentWatchData fromScriptValue(const QString &expression,
+ const QScriptValue &value)
+{
+ static const QString arrayStr = QCoreApplication::translate
+ ("Debugger::JSAgentWatchData", "[Array of length %1]");
+ static const QString undefinedStr = QCoreApplication::translate
+ ("Debugger::JSAgentWatchData", "<undefined>");
+
+ JSAgentWatchData data;
+ data.exp = expression.toUtf8();
+ data.name = data.exp;
+ data.hasChildren = false;
+ data.value = value.toString().toUtf8();
+ data.objectId = value.objectId();
+ if (value.isArray()) {
+ data.type = "Array";
+ data.value = arrayStr.arg(value.property(QLatin1String("length")).toString()).toUtf8();
+ data.hasChildren = true;
+ } else if (value.isBool()) {
+ data.type = "Bool";
+ // data.value = value.toBool() ? "true" : "false";
+ } else if (value.isDate()) {
+ data.type = "Date";
+ data.value = value.toDateTime().toString().toUtf8();
+ } else if (value.isError()) {
+ data.type = "Error";
+ } else if (value.isFunction()) {
+ data.type = "Function";
+ } else if (value.isUndefined()) {
+ data.type = undefinedStr.toUtf8();
+ } else if (value.isNumber()) {
+ data.type = "Number";
+ } else if (value.isRegExp()) {
+ data.type = "RegExp";
+ } else if (value.isString()) {
+ data.type = "String";
+ } else if (value.isVariant()) {
+ data.type = "Variant";
+ } else if (value.isQObject()) {
+ const QObject *obj = value.toQObject();
+ data.type = "Object";
+ data.value += '[';
+ data.value += obj->metaObject()->className();
+ data.value += ']';
+ data.hasChildren = true;
+ } else if (value.isObject()) {
+ data.type = "Object";
+ data.hasChildren = true;
+ data.value = "[Object]";
+ } else if (value.isNull()) {
+ data.type = "<null>";
+ } else {
+ data.type = "<unknown>";
+ }
+ return data;
+}
+
+static QList<JSAgentWatchData> expandObject(const QScriptValue &object)
+{
+ QList<JSAgentWatchData> result;
+ QScriptValueIterator it(object);
+ while (it.hasNext()) {
+ it.next();
+ if (it.flags() & QScriptValue::SkipInEnumeration)
+ continue;
+ if (/*object.isQObject() &&*/ it.value().isFunction()) {
+ // Cosmetics: skip all functions and slot, there are too many of them,
+ // and it is not useful information in the debugger.
+ continue;
+ }
+ JSAgentWatchData data = fromScriptValue(it.name(), it.value());
+ result.append(data);
+ }
+ if (result.isEmpty()) {
+ JSAgentWatchData data;
+ data.name = "<no initialized data>";
+ data.hasChildren = false;
+ data.value = " ";
+ data.objectId = 0;
+ result.append(data);
+ }
+ return result;
+}
+
+static QString fileName(const QString &fileUrl)
+{
+ int lastDelimiterPos = fileUrl.lastIndexOf(QLatin1Char('/'));
+ return fileUrl.mid(lastDelimiterPos, fileUrl.size() - lastDelimiterPos);
+}
+
+void QJSDebuggerAgentPrivate::recordKnownObjects(const QList<JSAgentWatchData>& list)
+{
+ foreach (const JSAgentWatchData &data, list)
+ knownObjectIds << data.objectId;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgentPrivate::getLocals(QScriptContext *ctx)
+{
+ QList<JSAgentWatchData> locals;
+ if (ctx) {
+ QScriptValue activationObject = ctx->activationObject();
+ QScriptValue thisObject = ctx->thisObject();
+ locals = expandObject(activationObject);
+ if (thisObject.isObject()
+ && thisObject.objectId() != engine()->globalObject().objectId()
+ && QScriptValueIterator(thisObject).hasNext())
+ locals.prepend(fromScriptValue(QLatin1String("this"), thisObject));
+ recordKnownObjects(locals);
+ knownObjectIds << activationObject.objectId();
+ }
+ return locals;
+}
+
+/*!
+ Constructs a new agent for the given \a engine. The agent will
+ report debugging-related events (e.g. step completion) to the given
+ \a backend.
+*/
+QJSDebuggerAgent::QJSDebuggerAgent(QScriptEngine *engine, QObject *parent)
+ : QObject(parent)
+ , QScriptEngineAgent(engine)
+ , d(new QJSDebuggerAgentPrivate(this))
+{
+ QJSDebuggerAgent::engine()->setAgent(this);
+}
+
+QJSDebuggerAgent::QJSDebuggerAgent(QDeclarativeEngine *engine, QObject *parent)
+ : QObject(parent)
+ , QScriptEngineAgent(QDeclarativeDebugHelper::getScriptEngine(engine))
+ , d(new QJSDebuggerAgentPrivate(this))
+{
+ QJSDebuggerAgent::engine()->setAgent(this);
+}
+
+/*!
+ Destroys this QJSDebuggerAgent.
+*/
+QJSDebuggerAgent::~QJSDebuggerAgent()
+{
+ engine()->setAgent(0);
+ delete d;
+}
+
+void QJSDebuggerAgent::setBreakpoints(const JSAgentBreakpoints &breakpoints)
+{
+ d->breakpoints = breakpoints;
+
+ d->fileNameToBreakpoints.clear();
+ foreach (const JSAgentBreakpointData &bp, breakpoints)
+ d->fileNameToBreakpoints.insertMulti(fileName(QString::fromUtf8(bp.fileUrl)), bp);
+}
+
+void QJSDebuggerAgent::setWatchExpressions(const QStringList &watchExpressions)
+{
+ d->watchExpressions = watchExpressions;
+}
+
+void QJSDebuggerAgent::stepOver()
+{
+ d->stepDepth = 0;
+ d->state = SteppingOverState;
+ d->continueExec();
+}
+
+void QJSDebuggerAgent::stepInto()
+{
+ d->stepDepth = 0;
+ d->state = SteppingIntoState;
+ d->continueExec();
+}
+
+void QJSDebuggerAgent::stepOut()
+{
+ d->stepDepth = 0;
+ d->state = SteppingOutState;
+ d->continueExec();
+}
+
+void QJSDebuggerAgent::continueExecution()
+{
+ d->state = NoState;
+ d->continueExec();
+}
+
+JSAgentWatchData QJSDebuggerAgent::executeExpression(const QString &expr)
+{
+ SetupExecEnv execEnv(d);
+
+ JSAgentWatchData data = fromScriptValue(expr, engine()->evaluate(expr));
+ d->knownObjectIds << data.objectId;
+ return data;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::expandObjectById(quint64 objectId)
+{
+ SetupExecEnv execEnv(d);
+
+ QScriptValue v;
+ if (d->knownObjectIds.contains(objectId))
+ v = engine()->objectById(objectId);
+
+ QList<JSAgentWatchData> result = expandObject(v);
+ d->recordKnownObjects(result);
+ return result;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::locals()
+{
+ SetupExecEnv execEnv(d);
+ return d->getLocals(engine()->currentContext());
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::localsAtFrame(int frameId)
+{
+ SetupExecEnv execEnv(d);
+
+ int deep = 0;
+ QScriptContext *ctx = engine()->currentContext();
+ while (ctx && deep < frameId) {
+ ctx = ctx->parentContext();
+ deep++;
+ }
+
+ return d->getLocals(ctx);
+}
+
+QList<JSAgentStackData> QJSDebuggerAgent::backtrace()
+{
+ SetupExecEnv execEnv(d);
+
+ QList<JSAgentStackData> backtrace;
+
+ for (QScriptContext *ctx = engine()->currentContext(); ctx; ctx = ctx->parentContext()) {
+ QScriptContextInfo info(ctx);
+
+ JSAgentStackData frame;
+ frame.functionName = info.functionName().toUtf8();
+ if (frame.functionName.isEmpty()) {
+ if (ctx->parentContext()) {
+ switch (info.functionType()) {
+ case QScriptContextInfo::ScriptFunction:
+ frame.functionName = "<anonymous>";
+ break;
+ case QScriptContextInfo::NativeFunction:
+ frame.functionName = "<native>";
+ break;
+ case QScriptContextInfo::QtFunction:
+ case QScriptContextInfo::QtPropertyFunction:
+ frame.functionName = "<native slot>";
+ break;
+ }
+ } else {
+ frame.functionName = "<global>";
+ }
+ }
+ frame.lineNumber = info.lineNumber();
+ // if the line number is unknown, fallback to the function line number
+ if (frame.lineNumber == -1)
+ frame.lineNumber = info.functionStartLineNumber();
+
+ frame.fileUrl = info.fileName().toUtf8();
+ backtrace.append(frame);
+ }
+
+ return backtrace;
+}
+
+QList<JSAgentWatchData> QJSDebuggerAgent::watches()
+{
+ SetupExecEnv execEnv(d);
+
+ QList<JSAgentWatchData> watches;
+ foreach (const QString &expr, d->watchExpressions)
+ watches << fromScriptValue(expr, engine()->evaluate(expr));
+ d->recordKnownObjects(watches);
+ return watches;
+}
+
+void QJSDebuggerAgent::setProperty(qint64 objectId,
+ const QString &property,
+ const QString &value)
+{
+ SetupExecEnv execEnv(d);
+
+ if (d->knownObjectIds.contains(objectId)) {
+ QScriptValue object = engine()->objectById(objectId);
+ if (object.isObject()) {
+ QScriptValue result = engine()->evaluate(value);
+ object.setProperty(property, result);
+ }
+ }
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::scriptLoad(qint64 id, const QString &program,
+ const QString &fileName, int)
+{
+ Q_UNUSED(program);
+ d->filenames.insert(id, fileName);
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::scriptUnload(qint64 id)
+{
+ d->filenames.remove(id);
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::contextPush()
+{
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::contextPop()
+{
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::functionEntry(qint64 scriptId)
+{
+ Q_UNUSED(scriptId);
+ d->stepDepth++;
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::functionExit(qint64 scriptId, const QScriptValue &returnValue)
+{
+ Q_UNUSED(scriptId);
+ Q_UNUSED(returnValue);
+ d->stepDepth--;
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::positionChange(qint64 scriptId, int lineNumber, int columnNumber)
+{
+ d->positionChange(scriptId, lineNumber, columnNumber);
+}
+
+void QJSDebuggerAgentPrivate::positionChange(qint64 scriptId, int lineNumber, int columnNumber)
+{
+ Q_UNUSED(columnNumber);
+
+ if (state == StoppedState)
+ return; //no re-entrency
+
+ // check breakpoints
+ if (!breakpoints.isEmpty()) {
+ QHash<qint64, QString>::const_iterator it = filenames.constFind(scriptId);
+ QScriptContext *ctx = engine()->currentContext();
+ QScriptContextInfo info(ctx);
+ if (it == filenames.constEnd()) {
+ // It is possible that the scripts are loaded before the agent is attached
+ QString filename = info.fileName();
+
+ JSAgentStackData frame;
+ frame.functionName = info.functionName().toUtf8();
+
+ QPair<QString, qint32> key = qMakePair(filename, lineNumber);
+ it = filenames.insert(scriptId, filename);
+ }
+
+ const QString filePath = it.value();
+ JSAgentBreakpoints bps = fileNameToBreakpoints.values(fileName(filePath)).toSet();
+
+ foreach (const JSAgentBreakpointData &bp, bps) {
+ if (bp.lineNumber == lineNumber) {
+ stopped();
+ return;
+ }
+ }
+ }
+
+ switch (state) {
+ case NoState:
+ case StoppedState:
+ // Do nothing
+ break;
+ case SteppingOutState:
+ if (stepDepth >= 0)
+ break;
+ //fallthough
+ case SteppingOverState:
+ if (stepDepth > 0)
+ break;
+ //fallthough
+ case SteppingIntoState:
+ stopped();
+ break;
+ }
+
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::exceptionThrow(qint64 scriptId,
+ const QScriptValue &exception,
+ bool hasHandler)
+{
+ Q_UNUSED(scriptId);
+ Q_UNUSED(exception);
+ Q_UNUSED(hasHandler);
+// qDebug() << Q_FUNC_INFO << exception.toString() << hasHandler;
+#if 0 //sometimes, we get exceptions that we should just ignore.
+ if (!hasHandler && state != StoppedState)
+ stopped(true, exception);
+#endif
+}
+
+/*!
+ \reimp
+*/
+void QJSDebuggerAgent::exceptionCatch(qint64 scriptId, const QScriptValue &exception)
+{
+ Q_UNUSED(scriptId);
+ Q_UNUSED(exception);
+}
+
+bool QJSDebuggerAgent::supportsExtension(Extension extension) const
+{
+ return extension == QScriptEngineAgent::DebuggerInvocationRequest;
+}
+
+QVariant QJSDebuggerAgent::extension(Extension extension, const QVariant &argument)
+{
+ if (extension == QScriptEngineAgent::DebuggerInvocationRequest) {
+ d->stopped();
+ return QVariant();
+ }
+ return QScriptEngineAgent::extension(extension, argument);
+}
+
+void QJSDebuggerAgentPrivate::stopped()
+{
+ bool becauseOfException = false;
+ const QScriptValue &exception = QScriptValue();
+
+ knownObjectIds.clear();
+ state = StoppedState;
+
+ emit q->stopped(becauseOfException, exception.toString());
+
+ loop.exec(QEventLoop::ExcludeUserInputEvents);
+}
+
+void QJSDebuggerAgentPrivate::continueExec()
+{
+ loop.quit();
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QJSDEBUGGERAGENT_P_H
+#define QJSDEBUGGERAGENT_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtScript/qscriptengineagent.h>
+#include <QtCore/qset.h>
+
+QT_BEGIN_NAMESPACE
+class QScriptValue;
+class QDeclarativeEngine;
+QT_END_NAMESPACE
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QJSDebuggerAgentPrivate;
+
+enum JSDebuggerState
+{
+ NoState,
+ SteppingIntoState,
+ SteppingOverState,
+ SteppingOutState,
+ StoppedState
+};
+
+struct JSAgentWatchData
+{
+ QByteArray exp;
+ QByteArray name;
+ QByteArray value;
+ QByteArray type;
+ bool hasChildren;
+ quint64 objectId;
+};
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentWatchData &data)
+{
+ return s << data.exp << data.name << data.value
+ << data.type << data.hasChildren << data.objectId;
+}
+
+struct JSAgentStackData
+{
+ QByteArray functionName;
+ QByteArray fileUrl;
+ qint32 lineNumber;
+};
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentStackData &data)
+{
+ return s << data.functionName << data.fileUrl << data.lineNumber;
+}
+
+struct JSAgentBreakpointData
+{
+ QByteArray functionName;
+ QByteArray fileUrl;
+ qint32 lineNumber;
+};
+
+typedef QSet<JSAgentBreakpointData> JSAgentBreakpoints;
+
+inline QDataStream &operator<<(QDataStream &s, const JSAgentBreakpointData &data)
+{
+ return s << data.functionName << data.fileUrl << data.lineNumber;
+}
+
+inline QDataStream &operator>>(QDataStream &s, JSAgentBreakpointData &data)
+{
+ return s >> data.functionName >> data.fileUrl >> data.lineNumber;
+}
+
+inline bool operator==(const JSAgentBreakpointData &b1, const JSAgentBreakpointData &b2)
+{
+ return b1.lineNumber == b2.lineNumber && b1.fileUrl == b2.fileUrl;
+}
+
+inline uint qHash(const JSAgentBreakpointData &b)
+{
+ return b.lineNumber ^ qHash(b.fileUrl);
+}
+
+
+class QJSDebuggerAgent : public QObject, public QScriptEngineAgent
+{
+ Q_OBJECT
+
+public:
+ QJSDebuggerAgent(QScriptEngine *engine, QObject *parent = 0);
+ QJSDebuggerAgent(QDeclarativeEngine *engine, QObject *parent = 0);
+ ~QJSDebuggerAgent();
+
+ void setBreakpoints(const JSAgentBreakpoints &);
+ void setWatchExpressions(const QStringList &);
+
+ void stepOver();
+ void stepInto();
+ void stepOut();
+ void continueExecution();
+
+ JSAgentWatchData executeExpression(const QString &expr);
+ QList<JSAgentWatchData> expandObjectById(quint64 objectId);
+ QList<JSAgentWatchData> locals();
+ QList<JSAgentWatchData> localsAtFrame(int frameId);
+ QList<JSAgentStackData> backtrace();
+ QList<JSAgentWatchData> watches();
+ void setProperty(qint64 objectId,
+ const QString &property,
+ const QString &value);
+
+ // reimplemented
+ void scriptLoad(qint64 id, const QString &program,
+ const QString &fileName, int baseLineNumber);
+ void scriptUnload(qint64 id);
+
+ void contextPush();
+ void contextPop();
+
+ void functionEntry(qint64 scriptId);
+ void functionExit(qint64 scriptId,
+ const QScriptValue &returnValue);
+
+ void positionChange(qint64 scriptId,
+ int lineNumber, int columnNumber);
+
+ void exceptionThrow(qint64 scriptId,
+ const QScriptValue &exception,
+ bool hasHandler);
+ void exceptionCatch(qint64 scriptId,
+ const QScriptValue &exception);
+
+ bool supportsExtension(Extension extension) const;
+ QVariant extension(Extension extension,
+ const QVariant &argument = QVariant());
+
+Q_SIGNALS:
+ void stopped(bool becauseOfException,
+ const QString &exception);
+
+private:
+ friend class QJSDebuggerAgentPrivate;
+ QJSDebuggerAgentPrivate *d;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QJSDEBUGGERAGENT_P_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qjsdebugservice_p.h"
+#include "private/qjsdebuggeragent_p.h"
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qstringlist.h>
+#include <QtDeclarative/qdeclarativeengine.h>
+
+Q_GLOBAL_STATIC(QJSDebugService, serviceInstance)
+
+QJSDebugService::QJSDebugService(QObject *parent)
+ : QDeclarativeDebugService(QLatin1String("JSDebugger"), parent)
+ , m_agent(0)
+{
+}
+
+QJSDebugService::~QJSDebugService()
+{
+ delete m_agent;
+}
+
+QJSDebugService *QJSDebugService::instance()
+{
+ return serviceInstance();
+}
+
+void QJSDebugService::addEngine(QDeclarativeEngine *engine)
+{
+ Q_ASSERT(engine);
+ Q_ASSERT(!m_engines.contains(engine));
+
+ m_engines.append(engine);
+}
+
+void QJSDebugService::removeEngine(QDeclarativeEngine *engine)
+{
+ Q_ASSERT(engine);
+ Q_ASSERT(m_engines.contains(engine));
+
+ m_engines.removeAll(engine);
+}
+
+void QJSDebugService::statusChanged(Status status)
+{
+ if (status == Enabled && !m_engines.isEmpty() && !m_agent) {
+ // Multiple engines are currently unsupported
+ QDeclarativeEngine *engine = m_engines.first();
+ m_agent = new QJSDebuggerAgent(engine, engine);
+
+ connect(m_agent, SIGNAL(stopped(bool,QString)),
+ this, SLOT(executionStopped(bool,QString)));
+
+ } else if (status != Enabled && m_agent) {
+ delete m_agent;
+ m_agent = 0;
+ }
+}
+
+void QJSDebugService::messageReceived(const QByteArray &message)
+{
+ if (!m_agent) {
+ qWarning() << "QJSDebugService::messageReceived: No QJSDebuggerAgent available";
+ return;
+ }
+
+ QDataStream ds(message);
+ QByteArray command;
+ ds >> command;
+ if (command == "BREAKPOINTS") {
+ JSAgentBreakpoints breakpoints;
+ ds >> breakpoints;
+ m_agent->setBreakpoints(breakpoints);
+
+ //qDebug() << "BREAKPOINTS";
+ //foreach (const JSAgentBreakpointData &bp, breakpoints)
+ // qDebug() << "BREAKPOINT: " << bp.fileUrl << bp.lineNumber;
+ } else if (command == "WATCH_EXPRESSIONS") {
+ QStringList watchExpressions;
+ ds >> watchExpressions;
+ m_agent->setWatchExpressions(watchExpressions);
+ } else if (command == "STEPOVER") {
+ m_agent->stepOver();
+ } else if (command == "STEPINTO" || command == "INTERRUPT") {
+ m_agent->stepInto();
+ } else if (command == "STEPOUT") {
+ m_agent->stepOut();
+ } else if (command == "CONTINUE") {
+ m_agent->continueExecution();
+ } else if (command == "EXEC") {
+ QByteArray id;
+ QString expr;
+ ds >> id >> expr;
+
+ JSAgentWatchData data = m_agent->executeExpression(expr);
+
+ QByteArray reply;
+ QDataStream rs(&reply, QIODevice::WriteOnly);
+ rs << QByteArray("RESULT") << id << data;
+ sendMessage(reply);
+ } else if (command == "EXPAND") {
+ QByteArray requestId;
+ quint64 objectId;
+ ds >> requestId >> objectId;
+
+ QList<JSAgentWatchData> result = m_agent->expandObjectById(objectId);
+
+ QByteArray reply;
+ QDataStream rs(&reply, QIODevice::WriteOnly);
+ rs << QByteArray("EXPANDED") << requestId << result;
+ sendMessage(reply);
+ } else if (command == "ACTIVATE_FRAME") {
+ int frameId;
+ ds >> frameId;
+
+ QList<JSAgentWatchData> locals = m_agent->localsAtFrame(frameId);
+
+ QByteArray reply;
+ QDataStream rs(&reply, QIODevice::WriteOnly);
+ rs << QByteArray("LOCALS") << frameId << locals;
+ sendMessage(reply);
+ } else if (command == "SET_PROPERTY") {
+ QByteArray id;
+ qint64 objectId;
+ QString property;
+ QString value;
+ ds >> id >> objectId >> property >> value;
+
+ m_agent->setProperty(objectId, property, value);
+
+ //TODO: feedback
+ } else if (command == "PING") {
+ int ping;
+ ds >> ping;
+ QByteArray reply;
+ QDataStream rs(&reply, QIODevice::WriteOnly);
+ rs << QByteArray("PONG") << ping;
+ sendMessage(reply);
+ } else {
+ qDebug() << Q_FUNC_INFO << "Unknown command" << command;
+ }
+
+ QDeclarativeDebugService::messageReceived(message);
+}
+
+void QJSDebugService::executionStopped(bool becauseOfException,
+ const QString &exception)
+{
+ const QList<JSAgentStackData> backtrace = m_agent->backtrace();
+ const QList<JSAgentWatchData> watches = m_agent->watches();
+ const QList<JSAgentWatchData> locals = m_agent->locals();
+
+ QByteArray reply;
+ QDataStream rs(&reply, QIODevice::WriteOnly);
+ rs << QByteArray("STOPPED") << backtrace << watches << locals
+ << becauseOfException << exception;
+ sendMessage(reply);
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QJSDEBUGSERVICE_P_H
+#define QJSDEBUGSERVICE_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/QPointer>
+
+#include "private/qdeclarativedebugservice_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeEngine;
+class QJSDebuggerAgent;
+
+class QJSDebugService : public QDeclarativeDebugService
+{
+ Q_OBJECT
+
+public:
+ QJSDebugService(QObject *parent = 0);
+ ~QJSDebugService();
+
+ static QJSDebugService *instance();
+
+ void addEngine(QDeclarativeEngine *);
+ void removeEngine(QDeclarativeEngine *);
+
+protected:
+ void statusChanged(Status status);
+ void messageReceived(const QByteArray &);
+
+private Q_SLOTS:
+ void executionStopped(bool becauseOfException,
+ const QString &exception);
+
+private:
+ QList<QDeclarativeEngine *> m_engines;
+ QPointer<QJSDebuggerAgent> m_agent;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QJSDEBUGSERVICE_P_H
include($$QT_SOURCE_TREE/src/qbase.pri)
+HEADERS += qtdeclarativeversion.h
+
#INCLUDEPATH -= $$QMAKE_INCDIR_QT/$$TARGET
#DESTDIR=.
include(debugger/debugger.pri)
include(scenegraph/scenegraph.pri)
include(items/items.pri)
+include(particles/particles.pri)
symbian: {
TARGET.UID3=0x2001E623
{
Q_DECLARE_PUBLIC(QDeclarativeTextInput)
public:
- QDeclarativeTextInputPrivate() : control(new QLineControl(QString())),
+ QDeclarativeTextInputPrivate() : control(new QLineControl),
color((QRgb)0), style(QDeclarativeText::Normal),
styleColor((QRgb)0), hAlign(QDeclarativeTextInput::AlignLeft),
mouseSelectionMode(QDeclarativeTextInput::SelectCharacters), inputMethodHints(Qt::ImhNone),
$$PWD/qsgcanvasitem_p.h \
$$PWD/qsgcontext2d_p.h \
$$PWD/qsgcontext2d_p_p.h \
+ $$PWD/qsgspriteengine_p.h \
+ $$PWD/qsgsprite_p.h \
+ $$PWD/qsgspriteimage_p.h \
SOURCES += \
$$PWD/qsgevents.cpp \
$$PWD/qsgimplicitsizeitem.cpp \
$$PWD/qsgcanvasitem.cpp \
$$PWD/qsgcontext2d.cpp \
+ $$PWD/qsgspriteengine.cpp \
+ $$PWD/qsgsprite.cpp \
+ $$PWD/qsgspriteimage.cpp \
SOURCES += \
$$PWD/qsgshadereffectitem.cpp \
//#include "private/qsgpincharea_p.h"
#include "qsgcanvasitem_p.h"
#include "qsgcontext2d_p.h"
+#include "qsgsprite_p.h"
+#include "qsgspriteimage_p.h"
static QDeclarativePrivate::AutoParentResult qsgitem_autoParent(QObject *obj, QObject *parent)
{
qmlRegisterType<QSGContext2D>();
qmlRegisterType<QSGCanvasGradient>();
+ qmlRegisterType<QSGSprite>("QtQuick", 2, 0, "Sprite");
+ qmlRegisterType<QSGSpriteImage>("QtQuick", 2, 0, "SpriteImage");
qmlRegisterType<QSGParentChange>(uri, major, minor,"ParentChange");
qmlRegisterType<QSGAnchorChanges>(uri, major, minor,"AnchorChanges");
**
****************************************************************************/
-#include "spritestate.h"
+#include "qsgsprite_p.h"
QT_BEGIN_NAMESPACE
-SpriteState::SpriteState(QObject *parent) :
+QSGSprite::QSGSprite(QObject *parent) :
QObject(parent)
, m_generatedCount(0)
, m_framesPerRow(0)
QT_MODULE(Declarative)
-class SpriteState : public QObject
+class QSGSprite : public QObject
{
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
Q_PROPERTY(QVariantMap to READ to WRITE setTo NOTIFY toChanged)
public:
- explicit SpriteState(QObject *parent = 0);
+ explicit QSGSprite(QObject *parent = 0);
QUrl source() const
{
}
private:
- friend class SpriteParticle;
- friend class SpriteEngine;
+ friend class QSGImageParticle;
+ friend class QSGSpriteEngine;
int m_generatedCount;
int m_framesPerRow;
QUrl m_source;
**
****************************************************************************/
-#include "spriteengine.h"
-#include "spritestate.h"
+#include "qsgspriteengine_p.h"
+#include "qsgsprite_p.h"
#include <QDebug>
#include <QPainter>
#include <QSet>
QT_BEGIN_NAMESPACE
-SpriteEngine::SpriteEngine(QObject *parent) :
+QSGSpriteEngine::QSGSpriteEngine(QObject *parent) :
QObject(parent), m_timeOffset(0)
{
//Default size 1
m_advanceTime.start();
}
-SpriteEngine::SpriteEngine(QList<SpriteState*> states, QObject *parent) :
+QSGSpriteEngine::QSGSpriteEngine(QList<QSGSprite*> states, QObject *parent) :
QObject(parent), m_states(states), m_timeOffset(0)
{
//Default size 1
m_advanceTime.start();
}
-SpriteEngine::~SpriteEngine()
+QSGSpriteEngine::~QSGSpriteEngine()
{
}
-int SpriteEngine::maxFrames()
+int QSGSpriteEngine::maxFrames()
{
return m_maxFrames;
}
But States maintain their listed index for internal structures
TODO: All these calculations should be pre-calculated and cached during initialization for a significant performance boost
*/
-int SpriteEngine::spriteState(int sprite)
+int QSGSpriteEngine::spriteState(int sprite)
{
int state = m_sprites[sprite];
if(!m_states[state]->m_generatedCount)
return state + extra;
}
-int SpriteEngine::spriteStart(int sprite)
+int QSGSpriteEngine::spriteStart(int sprite)
{
int state = m_sprites[sprite];
if(!m_states[state]->m_generatedCount)
return state + extra*rowDuration;
}
-int SpriteEngine::spriteFrames(int sprite)
+int QSGSpriteEngine::spriteFrames(int sprite)
{
int state = m_sprites[sprite];
if(!m_states[state]->m_generatedCount)
return m_states[state]->m_framesPerRow;
}
-int SpriteEngine::spriteDuration(int sprite)
+int QSGSpriteEngine::spriteDuration(int sprite)
{
int state = m_sprites[sprite];
if(!m_states[state]->m_generatedCount)
return rowDuration;
}
-int SpriteEngine::spriteCount()//TODO: Actually image state count, need to rename these things to make sense together
+int QSGSpriteEngine::spriteCount()//TODO: Actually image state count, need to rename these things to make sense together
{
return m_imageStateCount;
}
-void SpriteEngine::setGoal(int state, int sprite, bool jump)
+void QSGSpriteEngine::setGoal(int state, int sprite, bool jump)
{
if(sprite >= m_sprites.count() || state >= m_states.count())
return;
return;
}
-QImage SpriteEngine::assembledImage()
+QImage QSGSpriteEngine::assembledImage()
{
int frameHeight = 0;
int frameWidth = 0;
int maxSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
- foreach(SpriteState* state, m_states){
+ foreach(QSGSprite* state, m_states){
if(state->frames() > m_maxFrames)
m_maxFrames = state->frames();
image.fill(0);
QPainter p(&image);
int y = 0;
- foreach(SpriteState* state, m_states){
+ foreach(QSGSprite* state, m_states){
QImage img(state->source().toLocalFile());
if(img.height() == frameHeight && img.width() < maxSize){//Simple case
p.drawImage(0,y,img);
return image;
}
-void SpriteEngine::setCount(int c)
+void QSGSpriteEngine::setCount(int c)
{
m_sprites.resize(c);
m_goals.resize(c);
m_startTimes.resize(c);
}
-void SpriteEngine::startSprite(int index)
+void QSGSpriteEngine::startSprite(int index)
{
if(index >= m_sprites.count())
return;
restartSprite(index);
}
-void SpriteEngine::restartSprite(int index)
+void QSGSpriteEngine::restartSprite(int index)
{
m_startTimes[index] = m_timeOffset + m_advanceTime.elapsed();
int time = m_states[m_sprites[index]]->duration() * m_states[m_sprites[index]]->frames() + m_startTimes[index];
addToUpdateList(time, index);
}
-uint SpriteEngine::updateSprites(uint time)
+uint QSGSpriteEngine::updateSprites(uint time)
{
//Sprite State Update;
while(!m_stateUpdates.isEmpty() && time >= m_stateUpdates.first().first){
return m_stateUpdates.first().first;
}
-int SpriteEngine::goalSeek(int curIdx, int spriteIdx, int dist)
+int QSGSpriteEngine::goalSeek(int curIdx, int spriteIdx, int dist)
{
QString goalName;
if(m_goals[spriteIdx] != -1)
return curIdx;
if(dist < 0)
dist = m_states.count();
- SpriteState* curState = m_states[curIdx];
+ QSGSprite* curState = m_states[curIdx];
for(QVariantMap::const_iterator iter = curState->m_to.constBegin();
iter!=curState->m_to.constEnd(); iter++){
if(iter.key() == goalName)
return -1;
}
-void SpriteEngine::addToUpdateList(uint t, int idx)
+void QSGSpriteEngine::addToUpdateList(uint t, int idx)
{
for(int i=0; i<m_stateUpdates.count(); i++){
if(m_stateUpdates[i].first==t){
QT_MODULE(Declarative)
-class SpriteState;
+class QSGSprite;
-class SpriteEngine : public QObject
+class QSGSpriteEngine : public QObject
{
Q_OBJECT
//TODO: Optimize single sprite case
- Q_PROPERTY(QDeclarativeListProperty<SpriteState> sprites READ sprites)
+ Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
Q_PROPERTY(QString globalGoal READ globalGoal WRITE setGlobalGoal NOTIFY globalGoalChanged)
public:
- explicit SpriteEngine(QObject *parent = 0);
- SpriteEngine(QList<SpriteState*> sprites, QObject *parent=0);
- ~SpriteEngine();
+ explicit QSGSpriteEngine(QObject *parent = 0);
+ QSGSpriteEngine(QList<QSGSprite*> sprites, QObject *parent=0);
+ ~QSGSpriteEngine();
- QDeclarativeListProperty<SpriteState> sprites()
+ QDeclarativeListProperty<QSGSprite> sprites()
{
- return QDeclarativeListProperty<SpriteState>(this, m_states);
+ return QDeclarativeListProperty<QSGSprite>(this, m_states);
}
QString globalGoal() const
{
void startSprite(int index=0);
private://Nothing outside should use this?
- friend class SpriteGoalAffector;//XXX: Fix interface
+ friend class QSGSpriteGoalAffector;//XXX: Fix interface
int stateCount() {return m_states.count();}
- int stateIndex(SpriteState* s){return m_states.indexOf(s);}//TODO: Does this need to be hidden?
- SpriteState* state(int idx){return m_states[idx];}//Used by spritegoal affector
+ int stateIndex(QSGSprite* s){return m_states.indexOf(s);}//TODO: Does this need to be hidden?
+ QSGSprite* state(int idx){return m_states[idx];}//Used by spritegoal affector
signals:
void globalGoalChanged(QString arg);
void restartSprite(int sprite);
void addToUpdateList(uint t, int idx);
int goalSeek(int curState, int spriteIdx, int dist=-1);
- QList<SpriteState*> m_states;
+ QList<QSGSprite*> m_states;
QVector<int> m_sprites;//int is the index in m_states of the current state
QVector<int> m_goals;
QVector<int> m_startTimes;
};
//Common use is to have your own list property which is transparently an engine
-inline void spriteAppend(QDeclarativeListProperty<SpriteState> *p, SpriteState* s)
+inline void spriteAppend(QDeclarativeListProperty<QSGSprite> *p, QSGSprite* s)
{
- reinterpret_cast<QList<SpriteState *> *>(p->data)->append(s);
+ reinterpret_cast<QList<QSGSprite *> *>(p->data)->append(s);
p->object->metaObject()->invokeMethod(p->object, "createEngine");
}
-inline SpriteState* spriteAt(QDeclarativeListProperty<SpriteState> *p, int idx)
+inline QSGSprite* spriteAt(QDeclarativeListProperty<QSGSprite> *p, int idx)
{
- return reinterpret_cast<QList<SpriteState *> *>(p->data)->at(idx);
+ return reinterpret_cast<QList<QSGSprite *> *>(p->data)->at(idx);
}
-inline void spriteClear(QDeclarativeListProperty<SpriteState> *p)
+inline void spriteClear(QDeclarativeListProperty<QSGSprite> *p)
{
- reinterpret_cast<QList<SpriteState *> *>(p->data)->clear();
+ reinterpret_cast<QList<QSGSprite *> *>(p->data)->clear();
p->object->metaObject()->invokeMethod(p->object, "createEngine");
}
-inline int spriteCount(QDeclarativeListProperty<SpriteState> *p)
+inline int spriteCount(QDeclarativeListProperty<QSGSprite> *p)
{
- return reinterpret_cast<QList<SpriteState *> *>(p->data)->count();
+ return reinterpret_cast<QList<QSGSprite *> *>(p->data)->count();
}
QT_END_NAMESPACE
**
****************************************************************************/
-#include "spriteimage.h"
-#include "spritestate.h"
-#include "spriteengine.h"
+#include "qsgspriteimage_p.h"
+#include "qsgsprite_p.h"
+#include "qsgspriteengine_p.h"
#include <private/qsgcontext_p.h>
#include <private/qsgadaptationlayer_p.h>
#include <qsgnode.h>
QT_BEGIN_NAMESPACE
-class SpriteMaterial : public QSGMaterial
+class QSGSpriteMaterial : public QSGMaterial
{
public:
- SpriteMaterial();
- virtual ~SpriteMaterial();
+ QSGSpriteMaterial();
+ virtual ~QSGSpriteMaterial();
virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
virtual QSGMaterialShader *createShader() const;
virtual int compare(const QSGMaterial *other) const
{
- return this - static_cast<const SpriteMaterial *>(other);
+ return this - static_cast<const QSGSpriteMaterial *>(other);
}
QSGTexture *texture;
int height;
};
-SpriteMaterial::SpriteMaterial()
+QSGSpriteMaterial::QSGSpriteMaterial()
: timestamp(0)
, timelength(1)
, framecount(1)
setFlag(Blending, true);
}
-SpriteMaterial::~SpriteMaterial()
+QSGSpriteMaterial::~QSGSpriteMaterial()
{
delete texture;
}
public:
SpriteMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
{
- QFile vf(vertexFile ? vertexFile : ":resources/spriteimagevertex.shader");
+ QFile vf(vertexFile ? vertexFile : ":defaultshaders/spriteimagevertex.shader");
vf.open(QFile::ReadOnly);
m_vertex_code = vf.readAll();
- QFile ff(fragmentFile ? fragmentFile : ":resources/spriteimagefragment.shader");
+ QFile ff(fragmentFile ? fragmentFile : ":defaultshaders/spriteimagefragment.shader");
ff.open(QFile::ReadOnly);
m_fragment_code = ff.readAll();
virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
{
- SpriteMaterial *m = static_cast<SpriteMaterial *>(newEffect);
+ QSGSpriteMaterial *m = static_cast<QSGSpriteMaterial *>(newEffect);
m->texture->bind();
program()->setUniformValue(m_opacity_id, state.opacity());
};
float SpriteMaterialData::chunkOfBytes[1024];
-QSGMaterialShader *SpriteMaterial::createShader() const
+QSGMaterialShader *QSGSpriteMaterial::createShader() const
{
return new SpriteMaterialData;
}
SpriteVertex v4;
};
-SpriteImage::SpriteImage(QSGItem *parent) :
+QSGSpriteImage::QSGSpriteImage(QSGItem *parent) :
QSGItem(parent)
, m_node(0)
, m_material(0)
this, SLOT(update()));
}
-QDeclarativeListProperty<SpriteState> SpriteImage::sprites()
+QDeclarativeListProperty<QSGSprite> QSGSpriteImage::sprites()
{
- return QDeclarativeListProperty<SpriteState>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
+ return QDeclarativeListProperty<QSGSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
}
-void SpriteImage::createEngine()
+void QSGSpriteImage::createEngine()
{
//TODO: delay until component complete
if(m_spriteEngine)
delete m_spriteEngine;
if(m_sprites.count())
- m_spriteEngine = new SpriteEngine(m_sprites, this);
+ m_spriteEngine = new QSGSpriteEngine(m_sprites, this);
else
m_spriteEngine = 0;
reset();
SpriteImage_Attributes
};
-QSGGeometryNode* SpriteImage::buildNode()
+QSGGeometryNode* QSGSpriteImage::buildNode()
{
if (!m_spriteEngine) {
qWarning() << "SpriteImage: No sprite engine...";
m_material = 0;
}
- m_material = new SpriteMaterial();
+ m_material = new QSGSpriteMaterial();
QImage image = m_spriteEngine->assembledImage();
if(image.isNull())
return m_node;
}
-void SpriteImage::reset()
+void QSGSpriteImage::reset()
{
m_pleaseReset = true;
}
-QSGNode *SpriteImage::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
+QSGNode *QSGSpriteImage::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
{
if(m_pleaseReset){
delete m_node;
return m_node;
}
-void SpriteImage::prepareNextFrame()
+void QSGSpriteImage::prepareNextFrame()
{
if (m_node == 0)
m_node = buildNode();
QT_MODULE(Declarative)
class QSGContext;
-class SpriteState;
-class SpriteEngine;
+class QSGSprite;
+class QSGSpriteEngine;
class QSGGeometryNode;
-class SpriteMaterial;
-class SpriteImage : public QSGItem
+class QSGSpriteMaterial;
+class QSGSpriteImage : public QSGItem
{
Q_OBJECT
Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
//###try to share similar spriteEngines for less overhead?
- Q_PROPERTY(QDeclarativeListProperty<SpriteState> sprites READ sprites)
+ Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
Q_CLASSINFO("DefaultProperty", "sprites")
public:
- explicit SpriteImage(QSGItem *parent = 0);
+ explicit QSGSpriteImage(QSGItem *parent = 0);
- QDeclarativeListProperty<SpriteState> sprites();
+ QDeclarativeListProperty<QSGSprite> sprites();
bool running() const
{
void prepareNextFrame();
QSGGeometryNode* buildNode();
QSGGeometryNode *m_node;
- SpriteMaterial *m_material;
- QList<SpriteState*> m_sprites;
- SpriteEngine* m_spriteEngine;
+ QSGSpriteMaterial *m_material;
+ QList<QSGSprite*> m_sprites;
+ QSGSpriteEngine* m_spriteEngine;
QTime m_timestamp;
int m_maxFrames;
bool m_pleaseReset;
--- /dev/null
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+ $$PWD/qsgangleddirection_p.h \
+ $$PWD/qsgcustomparticle_p.h \
+ $$PWD/qsgellipseextruder_p.h \
+ $$PWD/qsgemitter_p.h \
+ $$PWD/qsgfollowemitter_p.h \
+ $$PWD/qsgfriction_p.h \
+ $$PWD/qsggravity_p.h \
+ $$PWD/qsgimageparticle_p.h \
+ $$PWD/qsgitemparticle_p.h \
+ $$PWD/qsgkill_p.h \
+ $$PWD/qsglineextruder_p.h \
+ $$PWD/qsgmaskextruder_p.h \
+ $$PWD/qsgmodelparticle_p.h \
+ $$PWD/qsgparticleaffector_p.h \
+ $$PWD/qsgparticleemitter_p.h \
+ $$PWD/qsgparticleextruder_p.h \
+ $$PWD/qsgparticlepainter_p.h \
+ $$PWD/qsgparticlesmodule_p.h \
+ $$PWD/qsgparticlesystem_p.h \
+ $$PWD/qsgpointattractor_p.h \
+ $$PWD/qsgpointdirection_p.h \
+ $$PWD/qsgspritegoal_p.h \
+ $$PWD/qsgstochasticdirection_p.h \
+ $$PWD/qsgtargeteddirection_p.h \
+ $$PWD/qsgturbulence_p.h \
+ $$PWD/qsgwander_p.h
+
+SOURCES += \
+ $$PWD/qsgangleddirection.cpp \
+ $$PWD/qsgcustomparticle.cpp \
+ $$PWD/qsgellipseextruder.cpp \
+ $$PWD/qsgemitter.cpp \
+ $$PWD/qsgfollowemitter.cpp \
+ $$PWD/qsgfriction.cpp \
+ $$PWD/qsggravity.cpp \
+ $$PWD/qsgimageparticle.cpp \
+ $$PWD/qsgitemparticle.cpp \
+ $$PWD/qsgkill.cpp \
+ $$PWD/qsglineextruder.cpp \
+ $$PWD/qsgmaskextruder.cpp \
+ $$PWD/qsgmodelparticle.cpp \
+ $$PWD/qsgparticleaffector.cpp \
+ $$PWD/qsgparticleemitter.cpp \
+ $$PWD/qsgparticleextruder.cpp \
+ $$PWD/qsgparticlepainter.cpp \
+ $$PWD/qsgparticlesmodule.cpp \
+ $$PWD/qsgparticlesystem.cpp \
+ $$PWD/qsgpointattractor.cpp \
+ $$PWD/qsgpointdirection.cpp \
+ $$PWD/qsgspritegoal.cpp \
+ $$PWD/qsgstochasticdirection.cpp \
+ $$PWD/qsgtargeteddirection.cpp \
+ $$PWD/qsgturbulence.cpp \
+ $$PWD/qsgwander.cpp
+
+RESOURCES += \
+ $$PWD/particles.qrc
--- /dev/null
+<RCC>
+ <qresource prefix="/">
+ <file>defaultshaders/spritefragment.shader</file>
+ <file>defaultshaders/spritevertex.shader</file>
+ <file>defaultshaders/ctfragment.shader</file>
+ <file>defaultshaders/ctvertex.shader</file>
+ <file>defaultshaders/trailsfragment.shader</file>
+ <file>defaultshaders/trailsvertex.shader</file>
+ <file>defaultshaders/spriteimagefragment.shader</file>
+ <file>defaultshaders/spriteimagevertex.shader</file>
+ <file>defaultshaders/identitytable.png</file>
+ <file>defaultshaders/defaultFadeInOut.png</file>
+ <file>defaultshaders/deformablefragment.shader</file>
+ <file>defaultshaders/deformablevertex.shader</file>
+ <file>defaultshaders/ultravertex.shader</file>
+ <file>defaultshaders/ultrafragment.shader</file>
+ <file>defaultshaders/supervertex.shader</file>
+ <file>defaultshaders/superfragment.shader</file>
+ <file>defaultshaders/simplevertex.shader</file>
+ <file>defaultshaders/simplefragment.shader</file>
+ </qresource>
+</RCC>
**
****************************************************************************/
-#include "angledvector.h"
+#include "qsgangleddirection_p.h"
#include <cmath>
QT_BEGIN_NAMESPACE
const qreal CONV = 0.017453292519943295;
-AngledVector::AngledVector(QObject *parent) :
- VaryingVector(parent)
+QSGAngledDirection::QSGAngledDirection(QObject *parent) :
+ QSGStochasticDirection(parent)
, m_angle(0)
, m_magnitude(0)
, m_angleVariation(0)
}
-const QPointF &AngledVector::sample(const QPointF &from)
+const QPointF &QSGAngledDirection::sample(const QPointF &from)
{
//TODO: Faster
qreal theta = m_angle*CONV - m_angleVariation*CONV + rand()/float(RAND_MAX) * m_angleVariation*CONV * 2;
**
****************************************************************************/
-#ifndef ANGLEDVECTOR_H
-#define ANGLEDVECTOR_H
-#include "varyingvector.h"
+#ifndef QSGANGLEDDIRECTION_H
+#define QSGANGLEDDIRECTION_H
+#include "qsgstochasticdirection_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
-class AngledVector : public VaryingVector
+class QSGAngledDirection : public QSGStochasticDirection
{
Q_OBJECT
Q_PROPERTY(qreal angle READ angle WRITE setAngle NOTIFY angleChanged)
Q_PROPERTY(qreal angleVariation READ angleVariation WRITE setAngleVariation NOTIFY angleVariationChanged)
Q_PROPERTY(qreal magnitudeVariation READ magnitudeVariation WRITE setMagnitudeVariation NOTIFY magnitudeVariationChanged)
public:
- explicit AngledVector(QObject *parent = 0);
+ explicit QSGAngledDirection(QObject *parent = 0);
const QPointF &sample(const QPointF &from);
qreal angle() const
{
QT_END_NAMESPACE
QT_END_HEADER
-#endif // ANGLEDVECTOR_H
+#endif // QSGANGLEDDIRECTION_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsgcustomparticle_p.h"
+#include <private/qsgshadereffectmesh_p.h>
+#include <cstdlib>
+
+QT_BEGIN_NAMESPACE
+/*
+ "uniform highp mat4 qt_ModelViewProjectionMatrix; \n"
+ "attribute highp vec4 qt_Vertex; \n"
+ "attribute highp vec2 qt_MultiTexCoord0; \n"
+ "varying highp vec2 qt_TexCoord0; \n"
+ "void main() { \n"
+ " qt_TexCoord0 = qt_MultiTexCoord0; \n"
+ " gl_Position = qt_ModelViewProjectionMatrix * qt_Vertex; \n"
+ "}";
+*/
+//Includes comments because the code isn't self explanatory
+static const char qt_particles_default_vertex_code[] =
+ "attribute highp vec2 vPos; \n"
+ "attribute highp vec2 vTex; \n"
+ "attribute highp vec4 vData; // x = time, y = lifeSpan, z = size, w = endSize \n"
+ "attribute highp vec4 vVec; // x,y = constant speed, z,w = acceleration \n"
+ "uniform highp mat4 qt_ModelViewProjectionMatrix; \n"
+ "uniform highp float timestamp; \n"
+ "varying highp vec2 fTex; \n"
+ "void main() { \n"
+ " fTex = vTex; \n"
+ " highp float size = vData.z; \n"
+ " highp float endSize = vData.w; \n"
+ " highp float t = (timestamp - vData.x) / vData.y; \n"
+ " highp float currentSize = mix(size, endSize, t * t); \n"
+ " if (t < 0. || t > 1.) \n"
+ " currentSize = 0.; \n"
+ " highp vec2 pos = vPos \n"
+ " - currentSize / 2. + currentSize * vTex // adjust size \n"
+ " + vVec.xy * t * vData.y // apply speed vector.. \n"
+ " + 0.5 * vVec.zw * pow(t * vData.y, 2.); \n"
+ " gl_Position = qt_ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0, 1); \n"
+ "}";
+
+static const char qt_particles_default_fragment_code[] =//TODO: Default frag requires source?
+ "uniform sampler2D source; \n"
+ "varying highp vec2 fTex; \n"
+ "uniform lowp float qt_Opacity; \n"
+ "void main() { \n"
+ " gl_FragColor = texture2D(source, fTex) * qt_Opacity; \n"
+ "}";
+
+/*
+static const char qt_particles_default_vertex_code[] =
+ "attribute highp vec2 vPos; \n"
+ "attribute highp vec2 vTex; \n"
+ "uniform highp mat4 qt_ModelViewProjectionMatrix; \n"
+ "void main() { \n"
+ " highp float currentSize = 1000.0; \n"
+ " highp vec2 pos = vec2(100.0,100.0) \n"
+ " - currentSize / 2. + currentSize * vTex; // adjust size \n"
+ " gl_Position = qt_ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0, 1); \n"
+ "}";
+static const char qt_particles_default_fragment_code[] =//TODO: Default frag requires source?
+ "void main() { \n"
+ " gl_FragColor = vec4(0,255,0,255); \n"
+ "}";
+*/
+
+static const char qt_position_attribute_name[] = "qt_Vertex";
+static const char qt_texcoord_attribute_name[] = "qt_MultiTexCoord0";
+
+static QSGGeometry::Attribute PlainParticle_Attributes[] = {
+ { 0, 2, GL_FLOAT }, // Position
+ { 1, 2, GL_FLOAT }, // TexCoord
+ { 2, 4, GL_FLOAT }, // Data
+ { 3, 4, GL_FLOAT }, // Vectors
+ { 4, 1, GL_FLOAT } // r
+};
+
+static QSGGeometry::AttributeSet PlainParticle_AttributeSet =
+{
+ 5, // Attribute Count
+ (2 + 2 + 4 + 4 + 1) * sizeof(float),
+ PlainParticle_Attributes
+};
+
+struct PlainVertex {
+ float x;
+ float y;
+ float tx;
+ float ty;
+ float t;
+ float lifeSpan;
+ float size;
+ float endSize;
+ float sx;
+ float sy;
+ float ax;
+ float ay;
+ float r;
+};
+
+struct PlainVertices {
+ PlainVertex v1;
+ PlainVertex v2;
+ PlainVertex v3;
+ PlainVertex v4;
+};
+
+QSGCustomParticle::QSGCustomParticle(QSGItem* parent)
+ : QSGParticlePainter(parent)
+ , m_pleaseReset(true)
+ , m_dirtyData(true)
+{
+ setFlag(QSGItem::ItemHasContents);
+}
+
+void QSGCustomParticle::componentComplete()
+{
+ reset();
+ QSGParticlePainter::componentComplete();
+}
+
+
+//Trying to keep the shader conventions the same as in qsgshadereffectitem
+/*!
+ \qmlproperty string CustomParticle::fragmentShader
+
+ This property holds the fragment shader's GLSL source code.
+ The default shader passes the texture coordinate along to the fragment
+ shader as "varying highp vec2 qt_TexCoord0".
+*/
+
+void QSGCustomParticle::setFragmentShader(const QByteArray &code)
+{
+ if (m_source.fragmentCode.constData() == code.constData())
+ return;
+ m_source.fragmentCode = code;
+ if (isComponentComplete()) {
+ reset();
+ }
+ emit fragmentShaderChanged();
+}
+
+/*!
+ \qmlproperty string CustomParticle::vertexShader
+
+ This property holds the vertex shader's GLSL source code.
+ The default shader expects the texture coordinate to be passed from the
+ vertex shader as "varying highp vec2 qt_TexCoord0", and it samples from a
+ sampler2D named "source".
+*/
+
+void QSGCustomParticle::setVertexShader(const QByteArray &code)
+{
+ if (m_source.vertexCode.constData() == code.constData())
+ return;
+ m_source.vertexCode = code;
+ if (isComponentComplete()) {
+ reset();
+ }
+ emit vertexShaderChanged();
+}
+
+void QSGCustomParticle::setCount(int c)
+{
+ QSGParticlePainter::setCount(c);
+ m_pleaseReset = true;
+}
+
+void QSGCustomParticle::reset()
+{
+ disconnectPropertySignals();
+
+ m_source.attributeNames.clear();
+ m_source.uniformNames.clear();
+ m_source.respectsOpacity = false;
+ m_source.respectsMatrix = false;
+ m_source.className = metaObject()->className();
+
+ for (int i = 0; i < m_sources.size(); ++i) {
+ const SourceData &source = m_sources.at(i);
+ delete source.mapper;
+ if (source.item && source.item->parentItem() == this)
+ source.item->setParentItem(0);
+ }
+ m_sources.clear();
+
+ QSGParticlePainter::reset();
+ m_pleaseReset = true;
+}
+
+
+void QSGCustomParticle::changeSource(int index)
+{
+ Q_ASSERT(index >= 0 && index < m_sources.size());
+ QVariant v = property(m_sources.at(index).name.constData());
+ setSource(v, index);
+}
+
+void QSGCustomParticle::updateData()
+{
+ m_dirtyData = true;
+ update();
+}
+
+void QSGCustomParticle::setSource(const QVariant &var, int index)
+{
+ Q_ASSERT(index >= 0 && index < m_sources.size());
+
+ SourceData &source = m_sources[index];
+
+ source.item = 0;
+ if (var.isNull()) {
+ return;
+ } else if (!qVariantCanConvert<QObject *>(var)) {
+ qWarning("Could not assign source of type '%s' to property '%s'.", var.typeName(), source.name.constData());
+ return;
+ }
+
+ QObject *obj = qVariantValue<QObject *>(var);
+
+ QSGTextureProvider *int3rface = QSGTextureProvider::from(obj);
+ if (!int3rface) {
+ qWarning("Could not assign property '%s', did not implement QSGTextureProvider.", source.name.constData());
+ }
+
+ source.item = qobject_cast<QSGItem *>(obj);
+
+ // TODO: Copy better solution in QSGShaderEffectItem when they find it.
+ // 'source.item' needs a canvas to get a scenegraph node.
+ // The easiest way to make sure it gets a canvas is to
+ // make it a part of the same item tree as 'this'.
+ if (source.item && source.item->parentItem() == 0) {
+ source.item->setParentItem(this);
+ source.item->setVisible(false);
+ }
+}
+
+void QSGCustomParticle::disconnectPropertySignals()
+{
+ disconnect(this, 0, this, SLOT(updateData()));
+ for (int i = 0; i < m_sources.size(); ++i) {
+ SourceData &source = m_sources[i];
+ disconnect(this, 0, source.mapper, 0);
+ disconnect(source.mapper, 0, this, 0);
+ }
+}
+
+void QSGCustomParticle::connectPropertySignals()
+{
+ QSet<QByteArray>::const_iterator it;
+ for (it = m_source.uniformNames.begin(); it != m_source.uniformNames.end(); ++it) {
+ int pi = metaObject()->indexOfProperty(it->constData());
+ if (pi >= 0) {
+ QMetaProperty mp = metaObject()->property(pi);
+ if (!mp.hasNotifySignal())
+ qWarning("QSGShaderEffectItem: property '%s' does not have notification method!", it->constData());
+ QByteArray signalName("2");
+ signalName.append(mp.notifySignal().signature());
+ connect(this, signalName, this, SLOT(updateData()));
+ } else {
+ qWarning("QSGShaderEffectItem: '%s' does not have a matching property!", it->constData());
+ }
+ }
+ for (int i = 0; i < m_sources.size(); ++i) {
+ SourceData &source = m_sources[i];
+ int pi = metaObject()->indexOfProperty(source.name.constData());
+ if (pi >= 0) {
+ QMetaProperty mp = metaObject()->property(pi);
+ QByteArray signalName("2");
+ signalName.append(mp.notifySignal().signature());
+ connect(this, signalName, source.mapper, SLOT(map()));
+ source.mapper->setMapping(this, i);
+ connect(source.mapper, SIGNAL(mapped(int)), this, SLOT(changeSource(int)));
+ } else {
+ qWarning("QSGShaderEffectItem: '%s' does not have a matching source!", source.name.constData());
+ }
+ }
+}
+
+void QSGCustomParticle::updateProperties()
+{
+ QByteArray vertexCode = m_source.vertexCode;
+ QByteArray fragmentCode = m_source.fragmentCode;
+ if (vertexCode.isEmpty())
+ vertexCode = qt_particles_default_vertex_code;
+ if (fragmentCode.isEmpty())
+ fragmentCode = qt_particles_default_fragment_code;
+
+ m_source.attributeNames.clear();
+ m_source.attributeNames << "vPos" << "vTex" << "vData" << "vVec" << "r";
+
+ lookThroughShaderCode(vertexCode);
+ lookThroughShaderCode(fragmentCode);
+
+ if (!m_source.attributeNames.contains(qt_position_attribute_name))
+ qWarning("QSGShaderEffectItem: Missing reference to \'%s\'.", qt_position_attribute_name);
+ if (!m_source.attributeNames.contains(qt_texcoord_attribute_name))
+ qWarning("QSGShaderEffectItem: Missing reference to \'%s\'.", qt_texcoord_attribute_name);
+ if (!m_source.respectsMatrix)
+ qWarning("QSGShaderEffectItem: Missing reference to \'qt_ModelViewProjectionMatrix\'.");
+ if (!m_source.respectsOpacity)
+ qWarning("QSGShaderEffectItem: Missing reference to \'qt_Opacity\'.");
+
+ for (int i = 0; i < m_sources.size(); ++i) {
+ QVariant v = property(m_sources.at(i).name);
+ setSource(v, i);
+ }
+
+ connectPropertySignals();
+}
+
+void QSGCustomParticle::lookThroughShaderCode(const QByteArray &code)
+{
+ // Regexp for matching attributes and uniforms.
+ // In human readable form: attribute|uniform [lowp|mediump|highp] <type> <name>
+ static QRegExp re(QLatin1String("\\b(attribute|uniform)\\b\\s*\\b(?:lowp|mediump|highp)?\\b\\s*\\b(\\w+)\\b\\s*\\b(\\w+)"));
+ Q_ASSERT(re.isValid());
+
+ int pos = -1;
+
+ QString wideCode = QString::fromLatin1(code.constData(), code.size());
+
+ while ((pos = re.indexIn(wideCode, pos + 1)) != -1) {
+ QByteArray decl = re.cap(1).toLatin1(); // uniform or attribute
+ QByteArray type = re.cap(2).toLatin1(); // type
+ QByteArray name = re.cap(3).toLatin1(); // variable name
+
+ if (decl == "attribute") {
+ if(!m_source.attributeNames.contains(name))//TODO: Can they add custom attributes?
+ qWarning() << "Custom Particle: Unknown attribute " << name;
+ } else {
+ Q_ASSERT(decl == "uniform");//TODO: Shouldn't assert
+
+ if (name == "qt_ModelViewProjectionMatrix") {
+ m_source.respectsMatrix = true;
+ } else if (name == "qt_Opacity") {
+ m_source.respectsOpacity = true;
+ } else if (name == "timestamp") {
+ //TODO: Copy the whole thing just because I have one more uniform?
+ } else {
+ m_source.uniformNames.insert(name);
+ if (type == "sampler2D") {
+ SourceData d;
+ d.mapper = new QSignalMapper;
+ d.name = name;
+ d.item = 0;
+ m_sources.append(d);
+ }
+ }
+ }
+ }
+}
+
+QSGNode *QSGCustomParticle::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
+{
+ if(m_pleaseReset){
+ if(m_node)
+ delete m_node;
+ //delete m_material;//Shader effect item doesn't regen material?
+
+ m_node = 0;
+ m_pleaseReset = false;
+ m_dirtyData = false;
+ }
+
+ if(m_system && m_system->isRunning())
+ prepareNextFrame();
+ if (m_node){
+ if(oldNode)
+ Q_ASSERT(oldNode == m_node);
+ update();
+ m_node->markDirty(QSGNode::DirtyMaterial); //done in buildData?
+ }
+
+ return m_node;
+}
+
+void QSGCustomParticle::prepareNextFrame(){
+ if(!m_node)
+ m_node = buildCustomNode();
+ if(!m_node)
+ return;
+
+ m_lastTime = m_system->systemSync(this) / 1000.;
+ if(m_dirtyData || true)//Currently this is how we update timestamp... potentially over expensive.
+ buildData();
+}
+
+QSGShaderEffectNode* QSGCustomParticle::buildCustomNode()
+{
+ if (m_count * 4 > 0xffff) {
+ printf("CustomParticle: Too many particles... \n");//####Why is this here?
+ return 0;
+ }
+
+ if(m_count <= 0) {
+ printf("CustomParticle: Too few particles... \n");
+ return 0;
+ }
+
+
+ //Create Particle Geometry
+ int vCount = m_count * 4;
+ int iCount = m_count * 6;
+ QSGGeometry *g = new QSGGeometry(PlainParticle_AttributeSet, vCount, iCount);
+ g->setDrawingMode(GL_TRIANGLES);
+ PlainVertex *vertices = (PlainVertex *) g->vertexData();
+ for (int p=0; p<m_count; ++p) {
+ double r = rand()/(double)RAND_MAX;//TODO: Seed?
+ for (int i=0; i<4; ++i) {
+ vertices[i].x = 0;
+ vertices[i].y = 0;
+ vertices[i].t = -1;
+ vertices[i].lifeSpan = 0;
+ vertices[i].size = 0;
+ vertices[i].endSize = 0;
+ vertices[i].sx = 0;
+ vertices[i].sy = 0;
+ vertices[i].ax = 0;
+ vertices[i].ay = 0;
+ vertices[i].r = r;
+ }
+
+ vertices[0].tx = 0;
+ vertices[0].ty = 0;
+
+ vertices[1].tx = 1;
+ vertices[1].ty = 0;
+
+ vertices[2].tx = 0;
+ vertices[2].ty = 1;
+
+ vertices[3].tx = 1;
+ vertices[3].ty = 1;
+
+ vertices += 4;
+ }
+ quint16 *indices = g->indexDataAsUShort();
+ for (int i=0; i<m_count; ++i) {
+ int o = i * 4;
+ indices[0] = o;
+ indices[1] = o + 1;
+ indices[2] = o + 2;
+ indices[3] = o + 1;
+ indices[4] = o + 3;
+ indices[5] = o + 2;
+ indices += 6;
+ }
+
+ updateProperties();
+ QSGShaderEffectNode* node = new QSGShaderEffectNode();
+
+
+ node->setGeometry(g);
+ node->setMaterial(&m_material);
+
+ /*
+ //For debugging, just use grid vertices like ShaderEffect
+ node->setGeometry(0);
+ QSGShaderEffectMesh* mesh = new QSGGridMesh();
+ node->setFlag(QSGNode::OwnsGeometry, false);
+
+ qDebug() << m_source.attributeNames;
+ QSGGeometry* geometry = node->geometry();
+ geometry = mesh->updateGeometry(geometry, m_source.attributeNames, QRectF(0,0,width(),height()));
+ if(!geometry)
+ qDebug() << "Should have written the error handling";
+ else
+ qDebug() << "Mesh Loaded";
+ node->setGeometry(geometry);
+ qDebug() << QString("INIT") << geometry << (QObject*)node;
+ node->setFlag(QSGNode::OwnsGeometry, true);
+ */
+ QSGShaderEffectProgram s = m_source;
+ if (s.fragmentCode.isEmpty())
+ s.fragmentCode = qt_particles_default_fragment_code;
+ if (s.vertexCode.isEmpty())
+ s.vertexCode = qt_particles_default_vertex_code;
+ m_material.setProgramSource(s);
+ node->markDirty(QSGNode::DirtyMaterial);
+ node->markDirty(QSGNode::DirtyAll);
+ return node;
+}
+
+static const QByteArray timestampName("timestamp");
+
+void QSGCustomParticle::buildData()
+{
+ if(!m_node)//Operates on m_node
+ return;
+ QVector<QPair<QByteArray, QVariant> > values;
+ QVector<QPair<QByteArray, QPointer<QSGItem> > > textures;
+ const QVector<QPair<QByteArray, QPointer<QSGItem> > > &oldTextures = m_material.textureProviders();
+
+ for (QSet<QByteArray>::const_iterator it = m_source.uniformNames.begin();
+ it != m_source.uniformNames.end(); ++it) {
+ values.append(qMakePair(*it, property(*it)));
+ }
+ for (int i = 0; i < oldTextures.size(); ++i) {
+ QSGTextureProvider *oldSource = QSGTextureProvider::from(oldTextures.at(i).second);
+ if (oldSource && oldSource->textureChangedSignal())
+ disconnect(oldTextures.at(i).second, oldSource->textureChangedSignal(), m_node, SLOT(markDirtyTexture()));
+ }
+ for (int i = 0; i < m_sources.size(); ++i) {
+ const SourceData &source = m_sources.at(i);
+ textures.append(qMakePair(source.name, source.item));
+ QSGTextureProvider *t = QSGTextureProvider::from(source.item);
+ if (t && t->textureChangedSignal())
+ connect(source.item, t->textureChangedSignal(), m_node, SLOT(markDirtyTexture()), Qt::DirectConnection);
+ }
+ values.append(qMakePair(timestampName, QVariant(m_lastTime)));
+ m_material.setUniforms(values);
+ m_material.setTextureProviders(textures);
+ m_node->markDirty(QSGNode::DirtyMaterial);
+ m_dirtyData = false;
+}
+
+void QSGCustomParticle::load(QSGParticleData *d)
+{
+ reload(d);//We don't do anything special in C++ here.
+}
+
+void QSGCustomParticle::reload(QSGParticleData *d)
+{
+ if (m_node == 0)
+ return;
+
+ PlainVertices *particles = (PlainVertices *) m_node->geometry()->vertexData();
+
+ int pos = particleTypeIndex(d);
+
+ PlainVertices &p = particles[pos];
+
+ //Perhaps we could be more efficient?
+ vertexCopy(p.v1, d->pv);
+ vertexCopy(p.v2, d->pv);
+ vertexCopy(p.v3, d->pv);
+ vertexCopy(p.v4, d->pv);
+
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef CUSTOM_PARTICLE_H
+#define CUSTOM_PARTICLE_H
+#include "qsgparticlepainter_p.h"
+#include <QtDeclarative/private/qsgshadereffectnode_p.h>
+#include <QSignalMapper>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QSGNode;
+
+//Genealogy: Hybrid of UltraParticle and ShaderEffectItem
+class QSGCustomParticle : public QSGParticlePainter
+{
+ Q_OBJECT
+ Q_PROPERTY(QByteArray fragmentShader READ fragmentShader WRITE setFragmentShader NOTIFY fragmentShaderChanged)
+ Q_PROPERTY(QByteArray vertexShader READ vertexShader WRITE setVertexShader NOTIFY vertexShaderChanged)
+
+public:
+ explicit QSGCustomParticle(QSGItem* parent=0);
+ virtual void load(QSGParticleData*);
+ virtual void reload(QSGParticleData*);
+ virtual void setCount(int c);
+
+ QByteArray fragmentShader() const { return m_source.fragmentCode; }
+ void setFragmentShader(const QByteArray &code);
+
+ QByteArray vertexShader() const { return m_source.vertexCode; }
+ void setVertexShader(const QByteArray &code);
+public Q_SLOTS:
+ void updateData();
+ void changeSource(int);
+Q_SIGNALS:
+ void fragmentShaderChanged();
+ void vertexShaderChanged();
+protected:
+ QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
+ void prepareNextFrame();
+ void setSource(const QVariant &var, int index);
+ void disconnectPropertySignals();
+ void connectPropertySignals();
+ void reset();
+ void updateProperties();
+ void lookThroughShaderCode(const QByteArray &code);
+ virtual void componentComplete();
+ QSGShaderEffectNode *buildCustomNode();
+
+private:
+ void buildData();
+
+ bool m_pleaseReset;
+ bool m_dirtyData;
+ QSGShaderEffectProgram m_source;
+ struct SourceData
+ {
+ QSignalMapper *mapper;
+ QPointer<QSGItem> item;
+ QByteArray name;
+ };
+ QVector<SourceData> m_sources;
+ QSGShaderEffectMaterial m_material;
+ QSGShaderEffectNode* m_node;
+ qreal m_lastTime;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif //HEADER_GUARD
**
****************************************************************************/
-#include "ellipseextruder.h"
+#include "qsgellipseextruder_p.h"
#include <cmath>
QT_BEGIN_NAMESPACE
-EllipseExtruder::EllipseExtruder(QObject *parent) :
- ParticleExtruder(parent)
+QSGEllipseExtruder::QSGEllipseExtruder(QObject *parent) :
+ QSGParticleExtruder(parent)
, m_fill(true)
{
}
-QPointF EllipseExtruder::extrude(const QRectF & r)
+QPointF QSGEllipseExtruder::extrude(const QRectF & r)
{
qreal theta = ((qreal)rand()/RAND_MAX) * 6.2831853071795862;
qreal mag = m_fill ? ((qreal)rand()/RAND_MAX) : 1;
r.y() + r.height()/2 + mag * (r.height()/2) * sin(theta));
}
-bool EllipseExtruder::contains(const QRectF &bounds, const QPointF &point)
+bool QSGEllipseExtruder::contains(const QRectF &bounds, const QPointF &point)
{
return bounds.contains(point);//TODO: Ellipse
}
#ifndef ELLIPSEEXTRUDER_H
#define ELLIPSEEXTRUDER_H
-#include "particleextruder.h"
+#include "qsgparticleextruder_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class EllipseExtruder : public ParticleExtruder
+class QSGEllipseExtruder : public QSGParticleExtruder
{
Q_OBJECT
Q_PROPERTY(bool fill READ fill WRITE setFill NOTIFY fillChanged)//###Use base class? If it's still box
public:
- explicit EllipseExtruder(QObject *parent = 0);
+ explicit QSGEllipseExtruder(QObject *parent = 0);
virtual QPointF extrude(const QRectF &);
virtual bool contains(const QRectF &bounds, const QPointF &point);
**
****************************************************************************/
-#include "trailsemitter.h"
-#include "particlesystem.h"
-#include "particle.h"
+#include "qsgemitter_p.h"
+#include "qsgparticlesystem_p.h"
+#include "qsgparticlepainter_p.h"//TODO: What was this for again?
QT_BEGIN_NAMESPACE
-TrailsEmitter::TrailsEmitter(QSGItem* parent)
- : ParticleEmitter(parent)
+QSGBasicEmitter::QSGBasicEmitter(QSGItem* parent)
+ : QSGParticleEmitter(parent)
, m_speed_from_movement(0)
, m_particle_count(0)
, m_reset_last(true)
// setFlag(ItemHasContents);
}
-void TrailsEmitter::setSpeedFromMovement(qreal t)
+void QSGBasicEmitter::setSpeedFromMovement(qreal t)
{
if (t == m_speed_from_movement)
return;
emit speedFromMovementChanged();
}
-void TrailsEmitter::reset()
+void QSGBasicEmitter::reset()
{
m_reset_last = true;
}
-void TrailsEmitter::emitWindow(int timeStamp)
+void QSGBasicEmitter::emitWindow(int timeStamp)
{
if (m_system == 0)
return;
pt = time;
while (pt < time || !m_burstQueue.isEmpty()) {
//int pos = m_last_particle % m_particle_count;
- ParticleData* datum = m_system->newDatum(m_system->m_groupIds[m_particle]);
+ QSGParticleData* datum = m_system->newDatum(m_system->m_groupIds[m_particle]);
if(datum){//actually emit(otherwise we've been asked to skip this one)
datum->e = this;//###useful?
ParticleVertex &p = datum->pv;
#include <QtCore>
#include <QtGui>
-#include "particleemitter.h"
+#include "qsgparticleemitter_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class ParticleTrailsMaterial;
class QSGGeometryNode;
-class TrailsEmitter : public ParticleEmitter
+class QSGBasicEmitter : public QSGParticleEmitter
{
Q_OBJECT
Q_PROPERTY(qreal speedFromMovement READ speedFromMovement WRITE setSpeedFromMovement NOTIFY speedFromMovementChanged)
public:
- explicit TrailsEmitter(QSGItem* parent=0);
- virtual ~TrailsEmitter(){}
+ explicit QSGBasicEmitter(QSGItem* parent=0);
+ virtual ~QSGBasicEmitter(){}
virtual void emitWindow(int timeStamp);
**
****************************************************************************/
-#include "followemitter.h"
-#include "particle.h"
+#include "qsgfollowemitter_p.h"
+#include "qsgparticlepainter_p.h"//TODO: What was this for again?
#include <cmath>
QT_BEGIN_NAMESPACE
-FollowEmitter::FollowEmitter(QSGItem *parent) :
- ParticleEmitter(parent)
+QSGFollowEmitter::QSGFollowEmitter(QSGItem *parent) :
+ QSGParticleEmitter(parent)
, m_particlesPerParticlePerSecond(0)
, m_lastTimeStamp(0)
, m_emitterXVariation(0)
, m_emitterYVariation(0)
, m_followCount(0)
, m_emissionExtruder(0)
- , m_defaultEmissionExtruder(new ParticleExtruder(this))
+ , m_defaultEmissionExtruder(new QSGParticleExtruder(this))
{
connect(this, SIGNAL(followChanged(QString)),
this, SLOT(recalcParticlesPerSecond()));
this, SLOT(recalcParticlesPerSecond()));
}
-void FollowEmitter::recalcParticlesPerSecond(){
+void QSGFollowEmitter::recalcParticlesPerSecond(){
if(!m_system)
return;
m_followCount = m_system->m_groupData[m_system->m_groupIds[m_follow]]->size;
}
}
-void FollowEmitter::reset()
+void QSGFollowEmitter::reset()
{
m_followCount = 0;
}
-void FollowEmitter::emitWindow(int timeStamp)
+void QSGFollowEmitter::emitWindow(int timeStamp)
{
if (m_system == 0)
return;
int gId2 = m_system->m_groupIds[m_particle];
for(int i=0; i<m_system->m_groupData[gId]->size; i++){
pt = m_lastEmission[i];
- ParticleData* d = m_system->m_data[i + m_system->m_groupData[gId]->start];
+ QSGParticleData* d = m_system->m_data[i + m_system->m_groupData[gId]->start];
if(!d || !d->stillAlive())
continue;
if(pt < d->pv.t)
continue;
}
while(pt < time || !m_burstQueue.isEmpty()){
- ParticleData* datum = m_system->newDatum(gId2);
+ QSGParticleData* datum = m_system->newDatum(gId2);
if(datum){//else, skip this emission
datum->e = this;//###useful?
ParticleVertex &p = datum->pv;
// sizeOffset*2,
// sizeOffset*2);
- ParticleExtruder* effectiveEmissionExtruder = m_emissionExtruder ? m_emissionExtruder : m_defaultEmissionExtruder;
+ QSGParticleExtruder* effectiveEmissionExtruder = m_emissionExtruder ? m_emissionExtruder : m_defaultEmissionExtruder;
const QPointF &newPos = effectiveEmissionExtruder->extrude(boundsRect);
p.x = newPos.x();
p.y = newPos.y();
#ifndef FOLLOWEMITTER_H
#define FOLLOWEMITTER_H
-#include "particleemitter.h"
-#include "particleaffector.h"
+#include "qsgparticleemitter_p.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class FollowEmitter : public ParticleEmitter
+class QSGFollowEmitter : public QSGParticleEmitter
{
Q_OBJECT
Q_PROPERTY(QString follow READ follow WRITE setFollow NOTIFY followChanged)
//### Remove, and just document that particles per second is per particle? But has count issues
- Q_PROPERTY(int particlesPerParticlePerSecond READ particlesPerParticlePerSecond WRITE setParticlesPerParticlePerSecond NOTIFY particlesPerParticlePerSecondChanged)
+ Q_PROPERTY(int emitRatePerParticle READ particlesPerParticlePerSecond WRITE setParticlesPerParticlePerSecond NOTIFY particlesPerParticlePerSecondChanged)
//TODO: Document that FollowEmitter's box is where it follows. It emits in a rect centered on the followed particle
//TODO: A set of properties that can involve the particle size of the followed
- Q_PROPERTY(ParticleExtruder* emissionShape READ emissonShape WRITE setEmissionShape NOTIFY emissionShapeChanged)
- Q_PROPERTY(qreal emissionHeight READ emitterYVariation WRITE setEmitterYVariation NOTIFY emitterYVariationChanged)
- Q_PROPERTY(qreal emissionWidth READ emitterXVariation WRITE setEmitterXVariation NOTIFY emitterXVariationChanged)
+ Q_PROPERTY(QSGParticleExtruder* emitShape READ emissonShape WRITE setEmissionShape NOTIFY emissionShapeChanged)
+ Q_PROPERTY(qreal emitHeight READ emitterYVariation WRITE setEmitterYVariation NOTIFY emitterYVariationChanged)
+ Q_PROPERTY(qreal emitWidth READ emitterXVariation WRITE setEmitterXVariation NOTIFY emitterXVariationChanged)
public:
- explicit FollowEmitter(QSGItem *parent = 0);
+ explicit QSGFollowEmitter(QSGItem *parent = 0);
virtual void emitWindow(int timeStamp);
virtual void reset();
return m_follow;
}
- ParticleExtruder* emissonShape() const
+ QSGParticleExtruder* emissonShape() const
{
return m_emissionExtruder;
}
void followChanged(QString arg);
- void emissionShapeChanged(ParticleExtruder* arg);
+ void emissionShapeChanged(QSGParticleExtruder* arg);
public slots:
}
}
- void setEmissionShape(ParticleExtruder* arg)
+ void setEmissionShape(QSGParticleExtruder* arg)
{
if (m_emissionExtruder != arg) {
m_emissionExtruder = arg;
void recalcParticlesPerSecond();
private:
- QSet<ParticleData*> m_pending;
+ QSet<QSGParticleData*> m_pending;
QVector<qreal> m_lastEmission;
int m_particlesPerParticlePerSecond;
qreal m_lastTimeStamp;
qreal m_emitterYVariation;
QString m_follow;
int m_followCount;
- ParticleExtruder* m_emissionExtruder;
- ParticleExtruder* m_defaultEmissionExtruder;
+ QSGParticleExtruder* m_emissionExtruder;
+ QSGParticleExtruder* m_defaultEmissionExtruder;
};
QT_END_NAMESPACE
**
****************************************************************************/
-#include "frictionaffector.h"
+#include "qsgfriction_p.h"
QT_BEGIN_NAMESPACE
-FrictionAffector::FrictionAffector(QSGItem *parent) :
- ParticleAffector(parent), m_factor(0.0)
+QSGFrictionAffector::QSGFrictionAffector(QSGItem *parent) :
+ QSGParticleAffector(parent), m_factor(0.0)
{
}
-bool FrictionAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGFrictionAffector::affectParticle(QSGParticleData *d, qreal dt)
{
if(!m_factor)
return false;
#ifndef FRICTIONAFFECTOR_H
#define FRICTIONAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class FrictionAffector : public ParticleAffector
+class QSGFrictionAffector : public QSGParticleAffector
{
Q_OBJECT
Q_PROPERTY(qreal factor READ factor WRITE setFactor NOTIFY factorChanged)
public:
- explicit FrictionAffector(QSGItem *parent = 0);
+ explicit QSGFrictionAffector(QSGItem *parent = 0);
qreal factor() const
{
return m_factor;
}
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
signals:
void factorChanged(qreal arg);
**
****************************************************************************/
-#include "gravityaffector.h"
+#include "qsggravity_p.h"
#include <cmath>
QT_BEGIN_NAMESPACE
const qreal CONV = 0.017453292520444443;
-GravityAffector::GravityAffector(QSGItem *parent) :
- ParticleAffector(parent), m_acceleration(-10), m_angle(90), m_xAcc(0), m_yAcc(0)
+QSGGravityAffector::QSGGravityAffector(QSGItem *parent) :
+ QSGParticleAffector(parent), m_acceleration(-10), m_angle(90), m_xAcc(0), m_yAcc(0)
{
connect(this, SIGNAL(accelerationChanged(qreal)),
this, SLOT(recalc()));
recalc();
}
-void GravityAffector::recalc()
+void QSGGravityAffector::recalc()
{
qreal theta = m_angle * CONV;
m_xAcc = m_acceleration * cos(theta);
m_yAcc = m_acceleration * sin(theta);
}
-bool GravityAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGGravityAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(dt);
bool changed = false;
#ifndef GRAVITYAFFECTOR_H
#define GRAVITYAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class GravityAffector : public ParticleAffector
+class QSGGravityAffector : public QSGParticleAffector
{
Q_OBJECT
Q_PROPERTY(qreal acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
Q_PROPERTY(qreal angle READ angle WRITE setAngle NOTIFY angleChanged)
public:
- explicit GravityAffector(QSGItem *parent = 0);
+ explicit QSGGravityAffector(QSGItem *parent = 0);
qreal acceleration() const
{
return m_acceleration;
return m_angle;
}
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
signals:
void accelerationChanged(qreal arg);
#include <qsgtexturematerial.h>
#include <qsgtexture.h>
#include <QFile>
-#include "ultraparticle.h"
-#include "particleemitter.h"
-#include "spritestate.h"
-#include "spriteengine.h"
+#include "qsgimageparticle_p.h"
+#include "qsgparticleemitter_p.h"
+#include "qsgsprite_p.h"
+#include "qsgspriteengine_p.h"
#include <QGLFunctions>
#include <qsgengine.h>
public:
UltraMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
{
- QFile vf(vertexFile ? vertexFile : ":resources/ultravertex.shader");
+ QFile vf(vertexFile ? vertexFile : ":defaultshaders/ultravertex.shader");
vf.open(QFile::ReadOnly);
m_vertex_code = vf.readAll();
- QFile ff(fragmentFile ? fragmentFile : ":resources/ultrafragment.shader");
+ QFile ff(fragmentFile ? fragmentFile : ":defaultshaders/ultrafragment.shader");
ff.open(QFile::ReadOnly);
m_fragment_code = ff.readAll();
public:
SimpleMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
{
- QFile vf(vertexFile ? vertexFile : ":resources/simplevertex.shader");
+ QFile vf(vertexFile ? vertexFile : ":defaultshaders/simplevertex.shader");
vf.open(QFile::ReadOnly);
m_vertex_code = vf.readAll();
- QFile ff(fragmentFile ? fragmentFile : ":resources/simplefragment.shader");
+ QFile ff(fragmentFile ? fragmentFile : ":defaultshaders/simplefragment.shader");
ff.open(QFile::ReadOnly);
m_fragment_code = ff.readAll();
return new SimpleMaterialData;
}
-UltraParticle::UltraParticle(QSGItem* parent)
- : ParticleType(parent)
+QSGImageParticle::QSGImageParticle(QSGItem* parent)
+ : QSGParticlePainter(parent)
, m_do_reset(false)
, m_color_variation(0.0)
, m_node(0)
setFlag(ItemHasContents);
}
-QDeclarativeListProperty<SpriteState> UltraParticle::sprites()
+QDeclarativeListProperty<QSGSprite> QSGImageParticle::sprites()
{
- return QDeclarativeListProperty<SpriteState>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
+ return QDeclarativeListProperty<QSGSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
}
-void UltraParticle::setImage(const QUrl &image)
+void QSGImageParticle::setImage(const QUrl &image)
{
if (image == m_image_name)
return;
}
-void UltraParticle::setColortable(const QUrl &table)
+void QSGImageParticle::setColortable(const QUrl &table)
{
if (table == m_colortable_name)
return;
reset();
}
-void UltraParticle::setSizetable(const QUrl &table)
+void QSGImageParticle::setSizetable(const QUrl &table)
{
if (table == m_sizetable_name)
return;
reset();
}
-void UltraParticle::setOpacitytable(const QUrl &table)
+void QSGImageParticle::setOpacitytable(const QUrl &table)
{
if (table == m_opacitytable_name)
return;
reset();
}
-void UltraParticle::setColor(const QColor &color)
+void QSGImageParticle::setColor(const QColor &color)
{
if (color == m_color)
return;
reset();
}
-void UltraParticle::setColorVariation(qreal var)
+void QSGImageParticle::setColorVariation(qreal var)
{
if (var == m_color_variation)
return;
reset();
}
-void UltraParticle::setAlphaVariation(qreal arg)
+void QSGImageParticle::setAlphaVariation(qreal arg)
{
if (m_alphaVariation != arg) {
m_alphaVariation = arg;
reset();
}
-void UltraParticle::setAlpha(qreal arg)
+void QSGImageParticle::setAlpha(qreal arg)
{
if (m_alpha != arg) {
m_alpha = arg;
reset();
}
-void UltraParticle::setRedVariation(qreal arg)
+void QSGImageParticle::setRedVariation(qreal arg)
{
if (m_redVariation != arg) {
m_redVariation = arg;
reset();
}
-void UltraParticle::setGreenVariation(qreal arg)
+void QSGImageParticle::setGreenVariation(qreal arg)
{
if (m_greenVariation != arg) {
m_greenVariation = arg;
reset();
}
-void UltraParticle::setBlueVariation(qreal arg)
+void QSGImageParticle::setBlueVariation(qreal arg)
{
if (m_blueVariation != arg) {
m_blueVariation = arg;
reset();
}
-void UltraParticle::setRotation(qreal arg)
+void QSGImageParticle::setRotation(qreal arg)
{
if (m_rotation != arg) {
m_rotation = arg;
reset();
}
-void UltraParticle::setRotationVariation(qreal arg)
+void QSGImageParticle::setRotationVariation(qreal arg)
{
if (m_rotationVariation != arg) {
m_rotationVariation = arg;
reset();
}
-void UltraParticle::setRotationSpeed(qreal arg)
+void QSGImageParticle::setRotationSpeed(qreal arg)
{
if (m_rotationSpeed != arg) {
m_rotationSpeed = arg;
reset();
}
-void UltraParticle::setRotationSpeedVariation(qreal arg)
+void QSGImageParticle::setRotationSpeedVariation(qreal arg)
{
if (m_rotationSpeedVariation != arg) {
m_rotationSpeedVariation = arg;
reset();
}
-void UltraParticle::setAutoRotation(bool arg)
+void QSGImageParticle::setAutoRotation(bool arg)
{
if (m_autoRotation != arg) {
m_autoRotation = arg;
reset();
}
-void UltraParticle::setXVector(VaryingVector* arg)
+void QSGImageParticle::setXVector(QSGStochasticDirection* arg)
{
if (m_xVector != arg) {
m_xVector = arg;
reset();
}
-void UltraParticle::setYVector(VaryingVector* arg)
+void QSGImageParticle::setYVector(QSGStochasticDirection* arg)
{
if (m_yVector != arg) {
m_yVector = arg;
reset();
}
-void UltraParticle::setBloat(bool arg)
+void QSGImageParticle::setBloat(bool arg)
{
if (m_bloat != arg) {
m_bloat = arg;
if(perfLevel < 9999)
reset();
}
-void UltraParticle::setCount(int c)
+void QSGImageParticle::setCount(int c)
{
- ParticleType::setCount(c);
+ QSGParticlePainter::setCount(c);
m_pleaseReset = true;
}
-void UltraParticle::reset()
+void QSGImageParticle::reset()
{
- ParticleType::reset();
+ QSGParticlePainter::reset();
m_pleaseReset = true;
}
-void UltraParticle::createEngine()
+void QSGImageParticle::createEngine()
{
if(m_spriteEngine)
delete m_spriteEngine;
if(m_sprites.count())
- m_spriteEngine = new SpriteEngine(m_sprites, this);
+ m_spriteEngine = new QSGSpriteEngine(m_sprites, this);
else
m_spriteEngine = 0;
reset();
UltraParticle_Attributes
};
-QSGGeometryNode* UltraParticle::buildSimpleParticleNode()
+QSGGeometryNode* QSGImageParticle::buildSimpleParticleNode()
{
perfLevel = Simple;//TODO: Intermediate levels
QImage image = QImage(m_image_name.toLocalFile());
return m_node;
}
-QSGGeometryNode* UltraParticle::buildParticleNode()
+QSGGeometryNode* QSGImageParticle::buildParticleNode()
{
if (m_count * 4 > 0xffff) {
printf("UltraParticle: Too many particles... \n");//####Why is this here?
QImage opacitytable(m_opacitytable_name.toLocalFile());
m_material = new UltraMaterial();
if(colortable.isNull())
- colortable = QImage(":resources/identitytable.png");
+ colortable = QImage(":defaultshaders/identitytable.png");
if(sizetable.isNull())
- sizetable = QImage(":resources/identitytable.png");
+ sizetable = QImage(":defaultshaders/identitytable.png");
if(opacitytable.isNull())
- opacitytable = QImage(":resources/defaultFadeInOut.png");
+ opacitytable = QImage(":defaultshaders/defaultFadeInOut.png");
Q_ASSERT(!colortable.isNull());
Q_ASSERT(!sizetable.isNull());
Q_ASSERT(!opacitytable.isNull());
return m_node;
}
-QSGNode *UltraParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
+QSGNode *QSGImageParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
{
if(m_pleaseReset){
if(m_node){
return m_node;
}
-void UltraParticle::prepareNextFrame()
+void QSGImageParticle::prepareNextFrame()
{
if (m_node == 0){ //TODO: Staggered loading (as emitted)
m_node = buildParticleNode();
return iv;
}
-IntermediateVertices* UltraParticle::fetchIntermediateVertices(int pos)
+IntermediateVertices* QSGImageParticle::fetchIntermediateVertices(int pos)
{
//Note that this class ruins typesafety for you. Maybe even thread safety.
//TODO: Something better, possibly with templates or inheritance
}
}
-void UltraParticle::reloadColor(const Color4ub &c, ParticleData* d)
+void QSGImageParticle::reloadColor(const Color4ub &c, QSGParticleData* d)
{
UltraVertices *particles = (UltraVertices *) m_node->geometry()->vertexData();
int pos = particleTypeIndex(d);
p.v1.color = p.v2.color = p.v3.color = p.v4.color = c;
}
-void UltraParticle::reload(ParticleData *d)
+void QSGImageParticle::reload(QSGParticleData *d)
{
if (m_node == 0)
return;
vertexCopy(*p->v4, d->pv);
}
-void UltraParticle::load(ParticleData *d)
+void QSGImageParticle::load(QSGParticleData *d)
{
if (m_node == 0)
return;
#ifndef ULTRAPARTICLE_H
#define ULTRAPARTICLE_H
-#include "particle.h"
-#include "varyingvector.h"
+#include "qsgparticlepainter_p.h"
+#include "qsgstochasticdirection_p.h"
#include <QDeclarativeListProperty>
-#include "coloredparticle.h"
-
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class UltraMaterial;
class QSGGeometryNode;
-class SpriteState;
-class SpriteEngine;
+class QSGSprite;
+class QSGSpriteEngine;
-/*struct Color4ub {//in coloredparticle
+struct Color4ub {
uchar r;
uchar g;
uchar b;
uchar a;
-};*/
+};
struct SimpleVertex {
float x;
UltraVertex* v4;
};
-class UltraParticle : public ParticleType
+class QSGImageParticle : public QSGParticlePainter
{
Q_OBJECT
- Q_PROPERTY(QUrl image READ image WRITE setImage NOTIFY imageChanged)
+ Q_PROPERTY(QUrl source READ image WRITE setImage NOTIFY imageChanged)
Q_PROPERTY(QUrl colorTable READ colortable WRITE setColortable NOTIFY colortableChanged)
Q_PROPERTY(QUrl sizeTable READ sizetable WRITE setSizetable NOTIFY sizetableChanged)
Q_PROPERTY(QUrl opacityTable READ opacitytable WRITE setOpacitytable NOTIFY opacitytableChanged)
//###Call i/j? Makes more sense to those with vector calculus experience, and I could even add the cirumflex in QML?
//xVector is the vector from the top-left point to the top-right point, and is multiplied by current size
- Q_PROPERTY(VaryingVector* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged)
+ Q_PROPERTY(QSGStochasticDirection* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged)
//yVector is the same, but top-left to bottom-left. The particle is always a parallelogram.
- Q_PROPERTY(VaryingVector* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged)
- Q_PROPERTY(QDeclarativeListProperty<SpriteState> sprites READ sprites)
+ Q_PROPERTY(QSGStochasticDirection* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged)
+ Q_PROPERTY(QDeclarativeListProperty<QSGSprite> sprites READ sprites)
Q_PROPERTY(bool bloat READ bloat WRITE setBloat NOTIFY bloatChanged)//Just a debugging property to bypass optimizations
public:
- explicit UltraParticle(QSGItem *parent = 0);
- virtual ~UltraParticle(){}
+ explicit QSGImageParticle(QSGItem *parent = 0);
+ virtual ~QSGImageParticle(){}
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
+ virtual void load(QSGParticleData*);
+ virtual void reload(QSGParticleData*);
virtual void setCount(int c);
- QDeclarativeListProperty<SpriteState> sprites();
- SpriteEngine* spriteEngine() {return m_spriteEngine;}
+ QDeclarativeListProperty<QSGSprite> sprites();
+ QSGSpriteEngine* spriteEngine() {return m_spriteEngine;}
enum PerformanceLevel{//TODO: Expose?
Unknown = 0,
bool autoRotation() const { return m_autoRotation; }
- VaryingVector* xVector() const { return m_xVector; }
+ QSGStochasticDirection* xVector() const { return m_xVector; }
- VaryingVector* yVector() const { return m_yVector; }
+ QSGStochasticDirection* yVector() const { return m_yVector; }
bool bloat() const { return m_bloat; }
void autoRotationChanged(bool arg);
- void xVectorChanged(VaryingVector* arg);
+ void xVectorChanged(QSGStochasticDirection* arg);
- void yVectorChanged(VaryingVector* arg);
+ void yVectorChanged(QSGStochasticDirection* arg);
void bloatChanged(bool arg);
public slots:
- void reloadColor(const Color4ub &c, ParticleData* d);
+ void reloadColor(const Color4ub &c, QSGParticleData* d);
void setAlphaVariation(qreal arg);
void setAlpha(qreal arg);
void setAutoRotation(bool arg);
- void setXVector(VaryingVector* arg);
+ void setXVector(QSGStochasticDirection* arg);
- void setYVector(VaryingVector* arg);
+ void setYVector(QSGStochasticDirection* arg);
void setBloat(bool arg);
qreal m_rotationSpeed;
qreal m_rotationSpeedVariation;
bool m_autoRotation;
- VaryingVector* m_xVector;
- VaryingVector* m_yVector;
+ QSGStochasticDirection* m_xVector;
+ QSGStochasticDirection* m_yVector;
- QList<SpriteState*> m_sprites;
- SpriteEngine* m_spriteEngine;
+ QList<QSGSprite*> m_sprites;
+ QSGSpriteEngine* m_spriteEngine;
bool m_bloat;
PerformanceLevel perfLevel;
**
****************************************************************************/
-#include "itemparticle.h"
+#include "qsgitemparticle_p.h"
#include <QtDeclarative/private/qsgvisualitemmodel_p.h>
#include <qsgnode.h>
#include <QDebug>
QT_BEGIN_NAMESPACE
-ItemParticle::ItemParticle(QSGItem *parent) :
- ParticleType(parent), m_fade(true)
+QSGItemParticle::QSGItemParticle(QSGItem *parent) :
+ QSGParticlePainter(parent), m_fade(true)
{
setFlag(QSGItem::ItemHasContents);
}
-void ItemParticle::freeze(QSGItem* item)
+void QSGItemParticle::freeze(QSGItem* item)
{
m_stasis << item;
}
-void ItemParticle::unfreeze(QSGItem* item)
+void QSGItemParticle::unfreeze(QSGItem* item)
{
m_stasis.remove(item);
}
-void ItemParticle::take(QSGItem *item, bool prioritize)
+void QSGItemParticle::take(QSGItem *item, bool prioritize)
{
if(prioritize)
m_pendingItems.push_front(item);
m_pendingItems.push_back(item);
}
-void ItemParticle::give(QSGItem *item)
+void QSGItemParticle::give(QSGItem *item)
{
//TODO: This
}
-void ItemParticle::load(ParticleData* d)
+void QSGItemParticle::load(QSGParticleData* d)
{
if(m_pendingItems.isEmpty())
return;
qWarning() << "Current model particles prefers overwrite:false";
//remove old item from the particle that is dying to make room for this one
m_items[pos]->setOpacity(0.);
- ItemParticleAttached* mpa;
- if((mpa = qobject_cast<ItemParticleAttached*>(qmlAttachedPropertiesObject<ItemParticle>(m_items[pos], false))))
+ QSGItemParticleAttached* mpa;
+ if((mpa = qobject_cast<QSGItemParticleAttached*>(qmlAttachedPropertiesObject<QSGItemParticle>(m_items[pos], false))))
mpa->detach();//reparent as well?
m_items[pos] = 0;
m_data[pos] = 0;
m_pendingItems.pop_front();
m_items[pos]->setX(d->curX() - m_items[pos]->width()/2);
m_items[pos]->setY(d->curY() - m_items[pos]->height()/2);
- ItemParticleAttached* mpa = qobject_cast<ItemParticleAttached*>(qmlAttachedPropertiesObject<ItemParticle>(m_items[pos]));
+ QSGItemParticleAttached* mpa = qobject_cast<QSGItemParticleAttached*>(qmlAttachedPropertiesObject<QSGItemParticle>(m_items[pos]));
if(mpa){
mpa->m_mp = this;
mpa->attach();
m_activeCount++;
}
-void ItemParticle::reload(ParticleData* d)
+void QSGItemParticle::reload(QSGParticleData* d)
{
//No-op unless we start copying the data.
}
-void ItemParticle::setCount(int c)
+void QSGItemParticle::setCount(int c)
{
- ParticleType::setCount(c);//###Do we need our own?
+ QSGParticlePainter::setCount(c);//###Do we need our own?
m_particleCount = c;
reset();
}
-int ItemParticle::count()
+int QSGItemParticle::count()
{
return m_particleCount;
}
-void ItemParticle::reset()
+void QSGItemParticle::reset()
{
- ParticleType::reset();
+ QSGParticlePainter::reset();
//TODO: Cleanup items?
m_items.resize(m_particleCount);
m_data.resize(m_particleCount);
}
-QSGNode* ItemParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
+QSGNode* QSGItemParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
{
//Dummy update just to get painting tick
if(m_pleaseReset){
return QSGItem::updatePaintNode(n,d);
}
-void ItemParticle::prepareNextFrame()
+void QSGItemParticle::prepareNextFrame()
{
qint64 timeStamp = m_system->systemSync(this);
qreal curT = timeStamp/1000.0;
//TODO: Size, better fade?
for(int i=0; i<m_particleCount; i++){
QSGItem* item = m_items[i];
- ParticleData* data = m_data[i];
+ QSGParticleData* data = m_data[i];
if(!item || !data)
continue;
qreal t = ((timeStamp/1000.0) - data->pv.t) / data->pv.lifeSpan;
}
if(t >= 1.0){//Usually happens from load
item->setOpacity(0.);
- ItemParticleAttached* mpa;
- if((mpa = qobject_cast<ItemParticleAttached*>(qmlAttachedPropertiesObject<ItemParticle>(m_items[i]))))
+ QSGItemParticleAttached* mpa;
+ if((mpa = qobject_cast<QSGItemParticleAttached*>(qmlAttachedPropertiesObject<QSGItemParticle>(m_items[i]))))
mpa->detach();//reparent as well?
m_items[i] = 0;
m_data[i] = 0;
}
}
-ItemParticleAttached *ItemParticle::qmlAttachedProperties(QObject *object)
+QSGItemParticleAttached *QSGItemParticle::qmlAttachedProperties(QObject *object)
{
- return new ItemParticleAttached(object);
+ return new QSGItemParticleAttached(object);
}
QT_END_NAMESPACE
#ifndef ITEMPARTICLE_H
#define ITEMPARTICLE_H
-#include "particle.h"
+#include "qsgparticlepainter_p.h"
#include <QPointer>
#include <QSet>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
class QSGVisualDataModel;
-class ItemParticleAttached;
+class QSGItemParticleAttached;
-class ItemParticle : public ParticleType
+class QSGItemParticle : public QSGParticlePainter
{
Q_OBJECT
Q_PROPERTY(bool fade READ fade WRITE setFade NOTIFY fadeChanged)
public:
- explicit ItemParticle(QSGItem *parent = 0);
+ explicit QSGItemParticle(QSGItem *parent = 0);
bool fade() const { return m_fade; }
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
+ virtual void load(QSGParticleData*);
+ virtual void reload(QSGParticleData*);
virtual void setCount(int c);
virtual int count();
- static ItemParticleAttached *qmlAttachedProperties(QObject *object);
+ static QSGItemParticleAttached *qmlAttachedProperties(QObject *object);
signals:
void fadeChanged();
QList<QSGItem*> m_pendingItems;
QVector<QSGItem*> m_items;
- QVector<ParticleData*> m_data;
+ QVector<QSGParticleData*> m_data;
QVector<int> m_idx;
QList<int> m_available;
QSet<QSGItem*> m_stasis;
int m_activeCount;
};
-class ItemParticleAttached : public QObject
+class QSGItemParticleAttached : public QObject
{
Q_OBJECT
- Q_PROPERTY(ItemParticle* particle READ particle CONSTANT);
+ Q_PROPERTY(QSGItemParticle* particle READ particle CONSTANT);
public:
- ItemParticleAttached(QObject* parent)
+ QSGItemParticleAttached(QObject* parent)
: QObject(parent), m_mp(0)
{;}
- ItemParticle* particle() {return m_mp;}
+ QSGItemParticle* particle() {return m_mp;}
void detach(){emit detached();}
void attach(){emit attached();}
private:
- ItemParticle* m_mp;
- friend class ItemParticle;
+ QSGItemParticle* m_mp;
+ friend class QSGItemParticle;
Q_SIGNALS:
void detached();
void attached();
QT_END_NAMESPACE
-QML_DECLARE_TYPEINFO(ItemParticle, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPEINFO(QSGItemParticle, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
#endif // ITEMPARTICLE_H
**
****************************************************************************/
-#include "killaffector.h"
-#include "particleemitter.h"
+#include "qsgkill_p.h"
+#include "qsgparticleemitter_p.h"
QT_BEGIN_NAMESPACE
-KillAffector::KillAffector(QSGItem *parent) :
- ParticleAffector(parent)
+QSGKillAffector::QSGKillAffector(QSGItem *parent) :
+ QSGParticleAffector(parent)
{
}
-bool KillAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGKillAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(dt);
if(d->stillAlive()){
#ifndef KILLAFFECTOR_H
#define KILLAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class KillAffector : public ParticleAffector
+class QSGKillAffector : public QSGParticleAffector
{
Q_OBJECT
public:
- explicit KillAffector(QSGItem *parent = 0);
+ explicit QSGKillAffector(QSGItem *parent = 0);
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
signals:
public slots:
** $QT_END_LICENSE$
**
****************************************************************************/
-#include "lineextruder.h"
+#include "qsglineextruder_p.h"
#include <cmath>
-LineExtruder::LineExtruder(QObject *parent) :
- ParticleExtruder(parent), m_mirrored(false)
+QSGLineExtruder::QSGLineExtruder(QObject *parent) :
+ QSGParticleExtruder(parent), m_mirrored(false)
{
}
-QPointF LineExtruder::extrude(const QRectF &r)
+QPointF QSGLineExtruder::extrude(const QRectF &r)
{
qreal x,y;
if(!r.height()){
#ifndef LINEEXTRUDER_H
#define LINEEXTRUDER_H
-#include "particleextruder.h"
+#include "qsgparticleextruder_p.h"
-class LineExtruder : public ParticleExtruder
+class QSGLineExtruder : public QSGParticleExtruder
{
Q_OBJECT
//Default is topleft to bottom right. Flipped makes it topright to bottom left
Q_PROPERTY(bool mirrored READ mirrored WRITE setmirrored NOTIFY mirroredChanged)
public:
- explicit LineExtruder(QObject *parent = 0);
+ explicit QSGLineExtruder(QObject *parent = 0);
virtual QPointF extrude(const QRectF &);
bool mirrored() const
{
**
****************************************************************************/
-#include "maskextruder.h"
+#include "qsgmaskextruder_p.h"
#include <QImage>
#include <QDebug>
QT_BEGIN_NAMESPACE
-MaskExtruder::MaskExtruder(QObject *parent) :
- ParticleExtruder(parent)
+QSGMaskExtruder::QSGMaskExtruder(QObject *parent) :
+ QSGParticleExtruder(parent)
, m_lastWidth(-1)
, m_lastHeight(-1)
{
}
-QPointF MaskExtruder::extrude(const QRectF &r)
+QPointF QSGMaskExtruder::extrude(const QRectF &r)
{
ensureInitialized(r);
- if(!m_mask.count())
+ if(!m_mask.count() || m_img.isNull())
return r.topLeft();
const QPointF p = m_mask[rand() % m_mask.count()];
//### Should random sub-pixel positioning be added?
return p + r.topLeft();
}
-bool MaskExtruder::contains(const QRectF &bounds, const QPointF &point)
+bool QSGMaskExtruder::contains(const QRectF &bounds, const QPointF &point)
{
ensureInitialized(bounds);//###Current usage patterns WILL lead to different bounds/r calls. Separate list?
+ if(m_img.isNull())
+ return false;
QPoint p = point.toPoint() - bounds.topLeft().toPoint();
return m_img.rect().contains(p) && (bool)m_img.pixelIndex(p);
}
-void MaskExtruder::ensureInitialized(const QRectF &r)
+void QSGMaskExtruder::ensureInitialized(const QRectF &r)
{
if(m_lastWidth == r.width() && m_lastHeight == r.height())
- return;
+ return;//Same as before
m_lastWidth = r.width();
m_lastHeight = r.height();
+ m_img = QImage();
m_mask.clear();
if(m_source.isEmpty())
return;
m_img = QImage(m_source.toLocalFile());
+ if(m_img.isNull()){
+ qWarning() << "MaskShape: Cannot load" << qPrintable(m_source.toLocalFile());
+ return;
+ }
m_img = m_img.createAlphaMask();
m_img = m_img.convertToFormat(QImage::Format_Mono);//Else LSB, but I think that's easier
m_img = m_img.scaled(r.size().toSize());//TODO: Do they need aspect ratio stuff? Or tiling?
#ifndef MASKEXTRUDER_H
#define MASKEXTRUDER_H
-#include "particleextruder.h"
+#include "qsgparticleextruder_p.h"
#include <QUrl>
#include <QImage>
QT_MODULE(Declarative)
-class MaskExtruder : public ParticleExtruder
+class QSGMaskExtruder : public QSGParticleExtruder
{
Q_OBJECT
Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
public:
- explicit MaskExtruder(QObject *parent = 0);
+ explicit QSGMaskExtruder(QObject *parent = 0);
virtual QPointF extrude(const QRectF &);
virtual bool contains(const QRectF &bounds, const QPointF &point);
**
****************************************************************************/
-#include "dataparticle.h"
+#include "qsgmodelparticle_p.h"
#include <QtDeclarative/private/qsgvisualitemmodel_p.h>
#include <qsgnode.h>
#include <QDebug>
QT_BEGIN_NAMESPACE
-DataParticle::DataParticle(QSGItem *parent) :
- ParticleType(parent), m_ownModel(false), m_comp(0), m_model(0), m_fade(true), m_modelCount(0)
+QSGModelParticle::QSGModelParticle(QSGItem *parent) :
+ QSGParticlePainter(parent), m_ownModel(false), m_comp(0), m_model(0), m_fade(true), m_modelCount(0)
{
setFlag(QSGItem::ItemHasContents);
}
-QVariant DataParticle::model() const
+QVariant QSGModelParticle::model() const
{
return m_dataSource;
}
-void DataParticle::setModel(const QVariant &arg)
+void QSGModelParticle::setModel(const QVariant &arg)
{
if(arg == m_dataSource)
return;
updateCount();
}
-void DataParticle::updateCount()
+void QSGModelParticle::updateCount()
{
int newCount = 0;
if(m_model)
m_modelCount = newCount;
}
-QDeclarativeComponent *DataParticle::delegate() const
+QDeclarativeComponent *QSGModelParticle::delegate() const
{
if(m_model)
return m_model->delegate();
return 0;
}
-void DataParticle::setDelegate(QDeclarativeComponent *comp)
+void QSGModelParticle::setDelegate(QDeclarativeComponent *comp)
{
if (QSGVisualDataModel *dataModel = qobject_cast<QSGVisualDataModel*>(m_model))
if (comp == dataModel->delegate())
emit delegateChanged();
}
-int DataParticle::modelCount() const
+int QSGModelParticle::modelCount() const
{
if(m_model)
- const_cast<DataParticle*>(this)->updateCount();//TODO: Investigate why this doesn't get called properly
+ const_cast<QSGModelParticle*>(this)->updateCount();//TODO: Investigate why this doesn't get called properly
return m_modelCount;
}
-void DataParticle::freeze(QSGItem* item)
+void QSGModelParticle::freeze(QSGItem* item)
{
m_stasis << item;
}
-void DataParticle::unfreeze(QSGItem* item)
+void QSGModelParticle::unfreeze(QSGItem* item)
{
m_stasis.remove(item);
}
-void DataParticle::load(ParticleData* d)
+void QSGModelParticle::load(QSGParticleData* d)
{
if(!m_model || !m_model->count())
return;
m_items[pos] = m_model->item(m_available.first());
m_idx[pos] = m_available.first();
m_available.pop_front();
- DataParticleAttached* mpa = qobject_cast<DataParticleAttached*>(qmlAttachedPropertiesObject<DataParticle>(m_items[pos]));
+ QSGModelParticleAttached* mpa = qobject_cast<QSGModelParticleAttached*>(qmlAttachedPropertiesObject<QSGModelParticle>(m_items[pos]));
if(mpa){
mpa->m_mp = this;
mpa->attach();
m_activeCount++;
}
-void DataParticle::reload(ParticleData* d)
+void QSGModelParticle::reload(QSGParticleData* d)
{
//No-op unless we start copying the data.
}
-void DataParticle::setCount(int c)
+void QSGModelParticle::setCount(int c)
{
- ParticleType::setCount(c);//###Do we need our own?
+ QSGParticlePainter::setCount(c);//###Do we need our own?
m_particleCount = c;
reset();
}
-int DataParticle::count()
+int QSGModelParticle::count()
{
return m_particleCount;
}
-void DataParticle::reset()
+void QSGModelParticle::reset()
{
- ParticleType::reset();
+ QSGParticlePainter::reset();
//TODO: Cleanup items?
m_items.resize(m_particleCount);
m_data.resize(m_particleCount);
}
-QSGNode* DataParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
+QSGNode* QSGModelParticle::updatePaintNode(QSGNode* n, UpdatePaintNodeData* d)
{
//Dummy update just to get painting tick
if(m_pleaseReset){
return QSGItem::updatePaintNode(n,d);
}
-void DataParticle::prepareNextFrame()
+void QSGModelParticle::prepareNextFrame()
{
qint64 timeStamp = m_system->systemSync(this);
qreal curT = timeStamp/1000.0;
//TODO: Size, better fade?
for(int i=0; i<m_particleCount; i++){
QSGItem* item = m_items[i];
- ParticleData* data = m_data[i];
+ QSGParticleData* data = m_data[i];
if(!item || !data)
continue;
qreal t = ((timeStamp/1000.0) - data->pv.t) / data->pv.lifeSpan;
}
}
-DataParticleAttached *DataParticle::qmlAttachedProperties(QObject *object)
+QSGModelParticleAttached *QSGModelParticle::qmlAttachedProperties(QObject *object)
{
- return new DataParticleAttached(object);
+ return new QSGModelParticleAttached(object);
}
QT_END_NAMESPACE
#ifndef DATAPARTICLE_H
#define DATAPARTICLE_H
-#include "particle.h"
+#include "qsgparticlepainter_p.h"
#include <QPointer>
#include <QSet>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
class QSGVisualDataModel;
-class DataParticleAttached;
+class QSGModelParticleAttached;
-class DataParticle : public ParticleType
+class QSGModelParticle : public QSGParticlePainter
{
Q_OBJECT
Q_PROPERTY(bool fade READ fade WRITE setFade NOTIFY fadeChanged)
Q_CLASSINFO("DefaultProperty", "delegate")
public:
- explicit DataParticle(QSGItem *parent = 0);
+ explicit QSGModelParticle(QSGItem *parent = 0);
QVariant model() const;
void setModel(const QVariant &);
bool fade() const { return m_fade; }
virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
+ virtual void load(QSGParticleData*);
+ virtual void reload(QSGParticleData*);
virtual void setCount(int c);
virtual int count();
- static DataParticleAttached *qmlAttachedProperties(QObject *object);
+ static QSGModelParticleAttached *qmlAttachedProperties(QObject *object);
signals:
void modelChanged();
void delegateChanged();
QList<QSGItem*> m_pendingItems;
QVector<QSGItem*> m_items;
- QVector<ParticleData*> m_data;
+ QVector<QSGParticleData*> m_data;
QVector<int> m_idx;
QList<int> m_available;
QSet<QSGItem*> m_stasis;
int m_modelCount;
};
-class DataParticleAttached : public QObject
+class QSGModelParticleAttached : public QObject
{
Q_OBJECT
- Q_PROPERTY(DataParticle* particle READ particle CONSTANT);
+ Q_PROPERTY(QSGModelParticle* particle READ particle CONSTANT);
public:
- DataParticleAttached(QObject* parent)
+ QSGModelParticleAttached(QObject* parent)
: QObject(parent), m_mp(0)
{;}
- DataParticle* particle() {return m_mp;}
+ QSGModelParticle* particle() {return m_mp;}
void detach(){emit detached();}
void attach(){emit attached();}
private:
- DataParticle* m_mp;
- friend class DataParticle;
+ QSGModelParticle* m_mp;
+ friend class QSGModelParticle;
Q_SIGNALS:
void detached();
void attached();
QT_END_NAMESPACE
-QML_DECLARE_TYPEINFO(DataParticle, QML_HAS_ATTACHED_PROPERTIES)
+QML_DECLARE_TYPEINFO(QSGModelParticle, QML_HAS_ATTACHED_PROPERTIES)
QT_END_HEADER
#endif // DATAPARTICLE_H
**
****************************************************************************/
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
#include <QDebug>
QT_BEGIN_NAMESPACE
-ParticleAffector::ParticleAffector(QSGItem *parent) :
+QSGParticleAffector::QSGParticleAffector(QSGItem *parent) :
QSGItem(parent), m_needsReset(false), m_system(0), m_active(true)
- , m_updateIntSet(false), m_shape(new ParticleExtruder(this)), m_signal(false)
+ , m_updateIntSet(false), m_shape(new QSGParticleExtruder(this)), m_signal(false)
{
- connect(this, SIGNAL(systemChanged(ParticleSystem*)),
+ connect(this, SIGNAL(systemChanged(QSGParticleSystem*)),
this, SLOT(updateOffsets()));
connect(this, SIGNAL(xChanged()),
this, SLOT(updateOffsets()));
this, SLOT(updateOffsets()));//TODO: in componentComplete and all relevant signals
}
-void ParticleAffector::componentComplete()
+void QSGParticleAffector::componentComplete()
{
if(!m_system)
qWarning() << "Affector created without a particle system specified";//TODO: useful QML warnings, like line number?
QSGItem::componentComplete();
}
-void ParticleAffector::affectSystem(qreal dt)
+void QSGParticleAffector::affectSystem(qreal dt)
{
if(!m_active)
return;
}
//foreach(ParticleData* d, m_system->m_data){
for(int i=0; i<m_system->m_particle_count; i++){
- ParticleData* d = m_system->m_data[i];
+ QSGParticleData* d = m_system->m_data[i];
if(!d || (m_onceOff && m_onceOffed.contains(d->systemIndex)))
continue;
if(m_groups.isEmpty() || m_groups.contains(d->group)){
}
}
-bool ParticleAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGParticleAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(d);
Q_UNUSED(dt);
return false;
}
-void ParticleAffector::reset(int idx)
+void QSGParticleAffector::reset(int idx)
{//TODO: This, among other ones, should be restructured so they don't all need to remember to call the superclass
if(m_onceOff)
m_onceOffed.remove(idx);
}
-void ParticleAffector::updateOffsets()
+void QSGParticleAffector::updateOffsets()
{
if(m_system)
m_offset = m_system->mapFromItem(this, QPointF(0, 0));
#define PARTICLEAFFECTOR_H
#include <QObject>
-#include "particlesystem.h"
-#include "particleextruder.h"
+#include "qsgparticlesystem_p.h"
+#include "qsgparticleextruder_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-
-class ParticleAffector : public QSGItem
+class QSGParticleAffector : public QSGItem
{
Q_OBJECT
- Q_PROPERTY(ParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
+ Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QStringList particles READ particles WRITE setParticles NOTIFY particlesChanged)
Q_PROPERTY(bool active READ active WRITE setActive NOTIFY activeChanged)
Q_PROPERTY(bool onceOff READ onceOff WRITE setOnceOff NOTIFY onceOffChanged)
- Q_PROPERTY(ParticleExtruder* shape READ shape WRITE setShape NOTIFY shapeChanged)
+ Q_PROPERTY(QSGParticleExtruder* shape READ shape WRITE setShape NOTIFY shapeChanged)
Q_PROPERTY(bool signal READ signal WRITE setSignal NOTIFY signalChanged)
public:
- explicit ParticleAffector(QSGItem *parent = 0);
+ explicit QSGParticleAffector(QSGItem *parent = 0);
virtual void affectSystem(qreal dt);
virtual void reset(int systemIdx);//As some store their own data per idx?
- ParticleSystem* system() const
+ QSGParticleSystem* system() const
{
return m_system;
}
return m_onceOff;
}
- ParticleExtruder* shape() const
+ QSGParticleExtruder* shape() const
{
return m_shape;
}
signals:
- void systemChanged(ParticleSystem* arg);
+ void systemChanged(QSGParticleSystem* arg);
void particlesChanged(QStringList arg);
void onceOffChanged(bool arg);
- void shapeChanged(ParticleExtruder* arg);
+ void shapeChanged(QSGParticleExtruder* arg);
void affected(qreal x, qreal y);//###Idx too?
void signalChanged(bool arg);
public slots:
-void setSystem(ParticleSystem* arg)
+void setSystem(QSGParticleSystem* arg)
{
if (m_system != arg) {
m_system = arg;
}
}
-void setShape(ParticleExtruder* arg)
+void setShape(QSGParticleExtruder* arg)
{
if (m_shape != arg) {
m_shape = arg;
}
protected:
- friend class ParticleSystem;
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ friend class QSGParticleSystem;
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
bool m_needsReset;//### What is this really saving?
- ParticleSystem* m_system;
+ QSGParticleSystem* m_system;
QStringList m_particles;
bool activeGroup(int g) {return m_groups.isEmpty() || m_groups.contains(g);}
bool m_active;
bool m_onceOff;
- ParticleExtruder* m_shape;
+ QSGParticleExtruder* m_shape;
bool m_signal;
**
****************************************************************************/
-#include "particleemitter.h"
+#include "qsgparticleemitter_p.h"
QT_BEGIN_NAMESPACE
-ParticleEmitter::ParticleEmitter(QSGItem *parent) :
+QSGParticleEmitter::QSGParticleEmitter(QSGItem *parent) :
QSGItem(parent)
, m_particlesPerSecond(10)
, m_particleDuration(1000)
this, SIGNAL(particleCountChanged()));
}
-ParticleEmitter::~ParticleEmitter()
+QSGParticleEmitter::~QSGParticleEmitter()
{
if(m_defaultExtruder)
delete m_defaultExtruder;
}
-void ParticleEmitter::componentComplete()
+void QSGParticleEmitter::componentComplete()
{
if(!m_system)
qWarning() << "Emitter created without a particle system specified";//TODO: useful QML warnings, like line number?
QSGItem::componentComplete();
}
-void ParticleEmitter::emitWindow(int timeStamp)
+void QSGParticleEmitter::emitWindow(int timeStamp)
{
Q_UNUSED(timeStamp);
}
-void ParticleEmitter::setEmitting(bool arg)
+void QSGParticleEmitter::setEmitting(bool arg)
{
if (m_emitting != arg) {
m_emitting = arg;
}
-ParticleExtruder* ParticleEmitter::effectiveExtruder()
+QSGParticleExtruder* QSGParticleEmitter::effectiveExtruder()
{
if(m_extruder)
return m_extruder;
if(!m_defaultExtruder)
- m_defaultExtruder = new ParticleExtruder;
+ m_defaultExtruder = new QSGParticleExtruder;
return m_defaultExtruder;
}
-void ParticleEmitter::pulse(qreal seconds)
+void QSGParticleEmitter::pulse(qreal seconds)
{
if(!particleCount())
qWarning() << "pulse called on an emitter with a particle count of zero";
m_burstLeft = seconds*1000.0;//TODO: Change name to match
}
-void ParticleEmitter::burst(int num)
+void QSGParticleEmitter::burst(int num)
{
if(!particleCount())
qWarning() << "burst called on an emitter with a particle count of zero";
m_burstQueue << qMakePair(num, QPointF(x(), y()));
}
-void ParticleEmitter::setMaxParticleCount(int arg)
+void QSGParticleEmitter::setMaxParticleCount(int arg)
{
if (m_maxParticleCount != arg) {
if(arg < 0 && m_maxParticleCount >= 0){
}
}
-int ParticleEmitter::particleCount() const
+int QSGParticleEmitter::particleCount() const
{
if(m_maxParticleCount >= 0)
return m_maxParticleCount;
#include <QSGItem>
#include <QDebug>
-#include "particlesystem.h"
-#include "particleextruder.h"
-#include "varyingvector.h"
+#include "qsgparticlesystem_p.h"
+#include "qsgparticleextruder_p.h"
+#include "qsgstochasticdirection_p.h"
#include <QList>
#include <QPair>
QT_MODULE(Declarative)
-class ParticleEmitter : public QSGItem
+class QSGParticleEmitter : public QSGItem
{
Q_OBJECT
//###currently goes in emitters OR sets system. Pick one?
- Q_PROPERTY(ParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
+ Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QString particle READ particle WRITE setParticle NOTIFY particleChanged)
- Q_PROPERTY(ParticleExtruder* shape READ extruder WRITE setExtruder NOTIFY extruderChanged)
+ Q_PROPERTY(QSGParticleExtruder* shape READ extruder WRITE setExtruder NOTIFY extruderChanged)
Q_PROPERTY(bool emitting READ emitting WRITE setEmitting NOTIFY emittingChanged)
- Q_PROPERTY(qreal particlesPerSecond READ particlesPerSecond WRITE setParticlesPerSecond NOTIFY particlesPerSecondChanged)
- Q_PROPERTY(int particleDuration READ particleDuration WRITE setParticleDuration NOTIFY particleDurationChanged)
- Q_PROPERTY(int particleDurationVariation READ particleDurationVariation WRITE setParticleDurationVariation NOTIFY particleDurationVariationChanged)
- Q_PROPERTY(int maxParticles READ maxParticleCount WRITE setMaxParticleCount NOTIFY maxParticleCountChanged)
+ Q_PROPERTY(qreal emitRate READ particlesPerSecond WRITE setParticlesPerSecond NOTIFY particlesPerSecondChanged)
+ Q_PROPERTY(int lifeSpan READ particleDuration WRITE setParticleDuration NOTIFY particleDurationChanged)
+ Q_PROPERTY(int lifeSpanVariation READ particleDurationVariation WRITE setParticleDurationVariation NOTIFY particleDurationVariationChanged)
+ Q_PROPERTY(int emitCap READ maxParticleCount WRITE setMaxParticleCount NOTIFY maxParticleCountChanged)
- Q_PROPERTY(qreal particleSize READ particleSize WRITE setParticleSize NOTIFY particleSizeChanged)
- Q_PROPERTY(qreal particleEndSize READ particleEndSize WRITE setParticleEndSize NOTIFY particleEndSizeChanged)
- Q_PROPERTY(qreal particleSizeVariation READ particleSizeVariation WRITE setParticleSizeVariation NOTIFY particleSizeVariationChanged)
+ Q_PROPERTY(qreal size READ particleSize WRITE setParticleSize NOTIFY particleSizeChanged)
+ Q_PROPERTY(qreal endSize READ particleEndSize WRITE setParticleEndSize NOTIFY particleEndSizeChanged)
+ Q_PROPERTY(qreal sizeVariation READ particleSizeVariation WRITE setParticleSizeVariation NOTIFY particleSizeVariationChanged)
- Q_PROPERTY(VaryingVector *speed READ speed WRITE setSpeed NOTIFY speedChanged)
- Q_PROPERTY(VaryingVector *acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
+ Q_PROPERTY(QSGStochasticDirection *speed READ speed WRITE setSpeed NOTIFY speedChanged)
+ Q_PROPERTY(QSGStochasticDirection *acceleration READ acceleration WRITE setAcceleration NOTIFY accelerationChanged)
public:
- explicit ParticleEmitter(QSGItem *parent = 0);
- virtual ~ParticleEmitter();
+ explicit QSGParticleEmitter(QSGItem *parent = 0);
+ virtual ~QSGParticleEmitter();
virtual void emitWindow(int timeStamp);
bool emitting() const
return m_particleDuration;
}
- ParticleSystem* system() const
+ QSGParticleSystem* system() const
{
return m_system;
}
void particleDurationChanged(int);
void emittingChanged(bool);
- void systemChanged(ParticleSystem* arg);
+ void systemChanged(QSGParticleSystem* arg);
void particleChanged(QString arg);
void particleDurationVariationChanged(int arg);
- void extruderChanged(ParticleExtruder* arg);
+ void extruderChanged(QSGParticleExtruder* arg);
void particleSizeChanged(qreal arg);
void particleSizeVariationChanged(qreal arg);
- void speedChanged(VaryingVector * arg);
+ void speedChanged(QSGStochasticDirection * arg);
- void accelerationChanged(VaryingVector * arg);
+ void accelerationChanged(QSGStochasticDirection * arg);
void maxParticleCountChanged(int arg);
void particleCountChanged();
}
}
- void setSystem(ParticleSystem* arg)
+ void setSystem(QSGParticleSystem* arg)
{
if (m_system != arg) {
m_system = arg;
emit particleDurationVariationChanged(arg);
}
}
- void setExtruder(ParticleExtruder* arg)
+ void setExtruder(QSGParticleExtruder* arg)
{
if (m_extruder != arg) {
m_extruder = arg;
}
}
- void setSpeed(VaryingVector * arg)
+ void setSpeed(QSGStochasticDirection * arg)
{
if (m_speed != arg) {
m_speed = arg;
}
}
- void setAcceleration(VaryingVector * arg)
+ void setAcceleration(QSGStochasticDirection * arg)
{
if (m_acceleration != arg) {
m_acceleration = arg;
int particleCount() const;
virtual void reset(){;}
- ParticleExtruder* extruder() const
+ QSGParticleExtruder* extruder() const
{
return m_extruder;
}
return m_particleSizeVariation;
}
- VaryingVector * speed() const
+ QSGStochasticDirection * speed() const
{
return m_speed;
}
- VaryingVector * acceleration() const
+ QSGStochasticDirection * acceleration() const
{
return m_acceleration;
}
int m_particleDuration;
int m_particleDurationVariation;
bool m_emitting;
- ParticleSystem* m_system;
+ QSGParticleSystem* m_system;
QString m_particle;
- ParticleExtruder* m_extruder;
- ParticleExtruder* m_defaultExtruder;
- ParticleExtruder* effectiveExtruder();
- VaryingVector * m_speed;
- VaryingVector * m_acceleration;
+ QSGParticleExtruder* m_extruder;
+ QSGParticleExtruder* m_defaultExtruder;
+ QSGParticleExtruder* effectiveExtruder();
+ QSGStochasticDirection * m_speed;
+ QSGStochasticDirection * m_acceleration;
qreal m_particleSize;
qreal m_particleEndSize;
qreal m_particleSizeVariation;
QList<QPair<int, QPointF > > m_burstQueue;
int m_maxParticleCount;
private:
- VaryingVector m_nullVector;
+ QSGStochasticDirection m_nullVector;
};
QT_END_NAMESPACE
**
****************************************************************************/
-#include "particleextruder.h"
+#include "qsgparticleextruder_p.h"
QT_BEGIN_NAMESPACE
-ParticleExtruder::ParticleExtruder(QObject *parent) :
+QSGParticleExtruder::QSGParticleExtruder(QObject *parent) :
QObject(parent), m_fill(true)
{
}
-QPointF ParticleExtruder::extrude(const QRectF &rect)
+QPointF QSGParticleExtruder::extrude(const QRectF &rect)
{
if(m_fill)
return QPointF(((qreal)rand() / RAND_MAX) * rect.width() + rect.x(),
}
}
-bool ParticleExtruder::contains(const QRectF &bounds, const QPointF &point)
+bool QSGParticleExtruder::contains(const QRectF &bounds, const QPointF &point)
{
return bounds.contains(point);
}
QT_MODULE(Declarative)
-class ParticleExtruder : public QObject
+class QSGParticleExtruder : public QObject
{
Q_OBJECT
Q_PROPERTY(bool fill READ fill WRITE setFill NOTIFY fillChanged)//###Should this be base class, or a BoxExtruder?
public:
- explicit ParticleExtruder(QObject *parent = 0);
+ explicit QSGParticleExtruder(QObject *parent = 0);
virtual QPointF extrude(const QRectF &);
virtual bool contains(const QRectF &bounds, const QPointF &point);//###Needed for follow emitter, but does it belong? Only marginally conceptually valid, and that's from user's perspective
bool fill() const
**
****************************************************************************/
-#include "particle.h"
+#include "qsgparticlepainter_p.h"
#include <QDebug>
QT_BEGIN_NAMESPACE
-ParticleType::ParticleType(QSGItem *parent) :
+QSGParticlePainter::QSGParticlePainter(QSGItem *parent) :
QSGItem(parent),
m_system(0)
{
this, SLOT(calcSystemOffset()));
}
-void ParticleType::componentComplete()
+void QSGParticlePainter::componentComplete()
{
if(!m_system)
qWarning() << "Particle created without a particle system specified";//TODO: useful QML warnings, like line number?
}
-void ParticleType::setSystem(ParticleSystem *arg)
+void QSGParticlePainter::setSystem(QSGParticleSystem *arg)
{
if (m_system != arg) {
m_system = arg;
}
}
-void ParticleType::load(ParticleData*)
+void QSGParticlePainter::load(QSGParticleData*)
{
}
-void ParticleType::reload(ParticleData*)
+void QSGParticlePainter::reload(QSGParticleData*)
{
}
-void ParticleType::reset()
+void QSGParticlePainter::reset()
{
//Have to every time because what it's emitting may have changed and that affects particleTypeIndex
m_particleStarts.clear();
m_lastStart = 0;
}
-void ParticleType::setCount(int c)
+void QSGParticlePainter::setCount(int c)
{
if(c == m_count)
return;
emit countChanged();
}
-int ParticleType::count()
+int QSGParticlePainter::count()
{
return m_count;
}
-int ParticleType::particleTypeIndex(ParticleData* d)
+int QSGParticlePainter::particleTypeIndex(QSGParticleData* d)
{
if(!m_particleStarts.contains(d->group)){
m_particleStarts.insert(d->group, m_lastStart);
}
-void ParticleType::calcSystemOffset()
+void QSGParticlePainter::calcSystemOffset()
{
if(!m_system)
return;
QPointF lastOffset = m_systemOffset;
- m_systemOffset = this->mapFromItem(m_system, QPointF());
+ m_systemOffset = -1 * this->mapFromItem(m_system, QPointF());
if(lastOffset != m_systemOffset){
- //Reload all particles
+ //Reload all particles//TODO: Necessary?
foreach(const QString &g, m_particles){
int gId = m_system->m_groupIds[g];
for(int i=0; i<m_system->m_groupData[gId]->size; i++)
#include <QObject>
#include <QDebug>
-#include "particlesystem.h"
+#include "qsgparticlesystem_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class ParticleType : public QSGItem
+class QSGParticlePainter : public QSGItem
{
Q_OBJECT
- Q_PROPERTY(ParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
+ Q_PROPERTY(QSGParticleSystem* system READ system WRITE setSystem NOTIFY systemChanged)
Q_PROPERTY(QStringList particles READ particles WRITE setParticles NOTIFY particlesChanged)
public:
- explicit ParticleType(QSGItem *parent = 0);
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
+ explicit QSGParticlePainter(QSGItem *parent = 0);
+ virtual void load(QSGParticleData*);
+ virtual void reload(QSGParticleData*);
virtual void setCount(int c);
virtual int count();
- ParticleSystem* system() const
+ QSGParticleSystem* system() const
{
return m_system;
}
return m_particles;
}
- int particleTypeIndex(ParticleData*);
- virtual void componentComplete();
+ int particleTypeIndex(QSGParticleData*);
signals:
void countChanged();
- void systemChanged(ParticleSystem* arg);
+ void systemChanged(QSGParticleSystem* arg);
void particlesChanged(QStringList arg);
public slots:
-void setSystem(ParticleSystem* arg);
+void setSystem(QSGParticleSystem* arg);
void setParticles(QStringList arg)
{
void calcSystemOffset();
protected:
virtual void reset();
+ virtual void componentComplete();
// virtual QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *){
// qDebug() << "Shouldn't be here..." << this;
// return 0;
// }
- ParticleSystem* m_system;
- friend class ParticleSystem;
+ QSGParticleSystem* m_system;
+ friend class QSGParticleSystem;
int m_count;
bool m_pleaseReset;
QStringList m_particles;
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Declarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsgangleddirection_p.h"
+#include "qsgcustomparticle_p.h"
+#include "qsgellipseextruder_p.h"
+#include "qsgemitter_p.h"
+#include "qsgfollowemitter_p.h"
+#include "qsgfriction_p.h"
+#include "qsggravity_p.h"
+#include "qsgimageparticle_p.h"
+#include "qsgitemparticle_p.h"
+#include "qsgkill_p.h"
+#include "qsglineextruder_p.h"
+#include "qsgmaskextruder_p.h"
+#include "qsgmodelparticle_p.h"
+#include "qsgparticleaffector_p.h"
+#include "qsgparticleemitter_p.h"
+#include "qsgparticleextruder_p.h"
+#include "qsgparticlepainter_p.h"
+#include "qsgparticlesmodule_p.h"
+#include "qsgparticlesystem_p.h"
+#include "qsgpointattractor_p.h"
+#include "qsgpointdirection_p.h"
+#include "qsgspritegoal_p.h"
+#include "qsgstochasticdirection_p.h"
+#include "qsgtargeteddirection_p.h"
+#include "qsgturbulence_p.h"
+#include "qsgwander_p.h"
+
+QT_BEGIN_NAMESPACE
+
+void QSGParticlesModule::defineModule()
+{
+ const char* uri = "QtQuick.Particles";
+ //Debugging only exposition
+ qmlRegisterType<QSGParticlePainter>(uri, 2, 0, "ParticlePainter");
+ qmlRegisterType<QSGParticleEmitter>(uri, 2, 0, "ParticleEmitter");
+ qmlRegisterType<QSGParticleExtruder>(uri, 2, 0, "ParticleExtruder");
+ qmlRegisterType<QSGStochasticDirection>(uri, 2, 0, "NullVector");
+ //Probably should be nocreate types
+
+ qmlRegisterType<QSGParticleSystem>(uri, 2, 0, "ParticleSystem");
+
+ qmlRegisterType<QSGImageParticle>(uri, 2, 0, "ImageParticle");
+ qmlRegisterType<QSGCustomParticle>(uri, 2, 0, "CustomParticle");
+ qmlRegisterType<QSGItemParticle>(uri, 2, 0, "ItemParticle");
+ qmlRegisterType<QSGModelParticle>(uri, 2, 0, "ModelParticle");
+
+ qmlRegisterType<QSGBasicEmitter>(uri, 2, 0, "Emitter");
+ qmlRegisterType<QSGFollowEmitter>(uri, 2, 0, "FollowEmitter");
+
+ qmlRegisterType<QSGEllipseExtruder>(uri, 2, 0, "EllipseShape");
+ qmlRegisterType<QSGLineExtruder>(uri, 2, 0, "LineShape");
+ qmlRegisterType<QSGMaskExtruder>(uri, 2, 0, "MaskShape");
+
+ qmlRegisterType<QSGPointDirection>(uri, 2, 0, "PointDirection");
+ qmlRegisterType<QSGAngledDirection>(uri, 2, 0, "AngledDirection");
+ qmlRegisterType<QSGTargetedDirection>(uri, 2, 0, "TargetedDirection");
+
+ qmlRegisterType<QSGParticleAffector>(uri, 2, 0, "ParticleAffector");//if it has a triggered signal, it's useful
+ qmlRegisterType<QSGWanderAffector>(uri, 2, 0, "Wander");
+ qmlRegisterType<QSGFrictionAffector>(uri, 2, 0, "Friction");
+ qmlRegisterType<QSGPointAttractorAffector>(uri, 2, 0, "PointAttractor");
+ qmlRegisterType<QSGGravityAffector>(uri, 2, 0, "Gravity");
+ qmlRegisterType<QSGKillAffector>(uri, 2, 0, "Kill");
+ qmlRegisterType<QSGSpriteGoalAffector>(uri, 2, 0, "SpriteGoal");
+ qmlRegisterType<QSGTurbulenceAffector>(uri, 2, 0 , "Turbulence");
+}
+
+QT_END_NAMESPACE
+
+//Q_EXPORT_PLUGIN2(Particles, QT_PREPEND_NAMESPACE(ParticlesModule))
** $QT_END_LICENSE$
**
****************************************************************************/
-#include "burstemitter.h"
+
+#ifndef QSGPARTICLESMODULE_H
+#define QSGPARTICLESMODULE_H
+
+#include <qdeclarative.h>
+
+QT_BEGIN_HEADER
+
QT_BEGIN_NAMESPACE
-void BurstEmitter::burst(int count, qreal x, qreal y)
+QT_MODULE(Declarative)
+
+class QSGParticlesModule
{
- qreal oldX = QSGItem::x();
- qreal oldY = QSGItem::y();
- setX(x);
- setY(y);
- TrailsEmitter::burst(count);
- setX(oldX);
- setY(oldY);
-}
+public:
+ static void defineModule();
+};
QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QSGPARTICLESMODULE_H
**
****************************************************************************/
-#include "particlesystem.h"
+#include "qsgparticlesystem_p.h"
#include <qsgnode.h>
-#include "particleemitter.h"
-#include "particleaffector.h"
-#include "particle.h"
+#include "qsgparticleemitter_p.h"
+#include "qsgparticleaffector_p.h"
+#include "qsgparticlepainter_p.h"
#include <cmath>
#include <QDebug>
QT_BEGIN_NAMESPACE
-ParticleData::ParticleData()
+QSGParticleData::QSGParticleData()
: group(0)
, e(0)
, particleIndex(0)
pv.ay = 0;
}
-ParticleSystem::ParticleSystem(QSGItem *parent) :
+QSGParticleSystem::QSGParticleSystem(QSGItem *parent) :
QSGItem(parent), m_particle_count(0), m_running(true) , m_startTime(0), m_overwrite(false)
{
m_groupIds = QHash<QString, int>();
}
-void ParticleSystem::registerParticleType(ParticleType* p)
+void QSGParticleSystem::registerParticleType(QSGParticlePainter* p)
{
- m_particles << QPointer<ParticleType>(p);//###Set or uniqueness checking?
+ m_particles << QPointer<QSGParticlePainter>(p);//###Set or uniqueness checking?
reset();
}
-void ParticleSystem::registerParticleEmitter(ParticleEmitter* e)
+void QSGParticleSystem::registerParticleEmitter(QSGParticleEmitter* e)
{
- m_emitters << QPointer<ParticleEmitter>(e);//###How to get them out?
+ m_emitters << QPointer<QSGParticleEmitter>(e);//###How to get them out?
connect(e, SIGNAL(particleCountChanged()),
this, SLOT(countChanged()));
connect(e, SIGNAL(particleChanged(QString)),
reset();
}
-void ParticleSystem::registerParticleAffector(ParticleAffector* a)
+void QSGParticleSystem::registerParticleAffector(QSGParticleAffector* a)
{
- m_affectors << QPointer<ParticleAffector>(a);
+ m_affectors << QPointer<QSGParticleAffector>(a);
//reset();//TODO: Slim down the huge batch of resets at the start
}
-void ParticleSystem::countChanged()
+void QSGParticleSystem::countChanged()
{
reset();//Need to give Particles new Count
}
-void ParticleSystem::setRunning(bool arg)
+void QSGParticleSystem::setRunning(bool arg)
{
if (m_running != arg) {
m_running = arg;
}
}
-void ParticleSystem::componentComplete()
+void QSGParticleSystem::componentComplete()
{
QSGItem::componentComplete();
reset();
}
-void ParticleSystem::initializeSystem()
+void QSGParticleSystem::initializeSystem()
{
int oldCount = m_particle_count;
m_particle_count = 0;//TODO: Only when changed?
if(!m_emitters.count() || !m_particles.count())
return;
- foreach(ParticleEmitter* e, m_emitters){
+ foreach(QSGParticleEmitter* e, m_emitters){
if(!m_groupIds.contains(e->particle())
|| (!e->particle().isEmpty() && !m_groupIds[e->particle()])){//or it was accidentally inserted by a failed lookup earlier
GroupData* gd = new GroupData;
if(m_particle_count > 16000)
qWarning() << "Particle system contains a vast number of particles (>16000). Expect poor performance";
- foreach(ParticleType* particle, m_particles){
+ foreach(QSGParticlePainter* particle, m_particles){
int particleCount = 0;
if(particle->particles().isEmpty()){//Uses default particle
particleCount += m_groupData[0]->size;
qDebug() << "System Initialized. Size:" << m_particle_count;
}
-void ParticleSystem::reset()
+void QSGParticleSystem::reset()
{
//Clear guarded pointers which have been deleted
int cleared = 0;
cleared += m_particles.removeAll(0);
cleared += m_affectors.removeAll(0);
//qDebug() << "Reset" << m_emitters.count() << m_particles.count() << "Cleared" << cleared;
- foreach(ParticleType* p, m_particles)
+ foreach(QSGParticlePainter* p, m_particles)
p->reset();
- foreach(ParticleEmitter* e, m_emitters)
+ foreach(QSGParticleEmitter* e, m_emitters)
e->reset();
if(!m_running)
return;
initializeSystem();
- foreach(ParticleType* p, m_particles)
+ foreach(QSGParticlePainter* p, m_particles)
p->update();
- foreach(ParticleEmitter* e, m_emitters)
+ foreach(QSGParticleEmitter* e, m_emitters)
e->emitWindow(0);//Start, so that starttime factors appropriately
}
-ParticleData* ParticleSystem::newDatum(int groupId)
+QSGParticleData* QSGParticleSystem::newDatum(int groupId)
{
Q_ASSERT(groupId < m_groupData.count());//XXX shouldn't really be an assert
Q_ASSERT(m_groupData[groupId]->size);
m_groupData[groupId]->nextIdx = 0;
Q_ASSERT(nextIdx < m_data.size());
- ParticleData* ret;
+ QSGParticleData* ret;
if(m_data[nextIdx]){//Recycle, it's faster.
ret = m_data[nextIdx];
if(!m_overwrite && ret->stillAlive()){
return 0;//Artificial longevity (or too fast emission) means this guy hasn't died. To maintain count, don't emit a new one
}//###Reset?
}else{
- ret = new ParticleData;
+ ret = new QSGParticleData;
m_data[nextIdx] = ret;
}
return ret;
}
-void ParticleSystem::emitParticle(ParticleData* pd)
+void QSGParticleSystem::emitParticle(QSGParticleData* pd)
{// called from prepareNextFrame()->emitWindow - enforce?
//Account for relative emitter position
QPointF offset = this->mapFromItem(pd->e, QPointF(0, 0));
pd->pv.y += offset.y();
}
- foreach(ParticleAffector *a, m_affectors)
+ foreach(QSGParticleAffector *a, m_affectors)
if(a && a->m_needsReset)
a->reset(pd->systemIndex);
- foreach(ParticleType* p, m_groupData[pd->group]->types)
+ foreach(QSGParticlePainter* p, m_groupData[pd->group]->types)
if(p)
p->load(pd);
}
-qint64 ParticleSystem::systemSync(ParticleType* p)
+qint64 QSGParticleSystem::systemSync(QSGParticlePainter* p)
{
if (!m_running)
return 0;
qreal time = m_timeInt / 1000.;
dt = time - dt;
m_needsReset.clear();
- foreach(ParticleEmitter* emitter, m_emitters)
+ foreach(QSGParticleEmitter* emitter, m_emitters)
if(emitter)
emitter->emitWindow(m_timeInt);
- foreach(ParticleAffector* a, m_affectors)
+ foreach(QSGParticleAffector* a, m_affectors)
if(a)
a->affectSystem(dt);
- foreach(ParticleData* d, m_needsReset)
- foreach(ParticleType* p, m_groupData[d->group]->types)
+ foreach(QSGParticleData* d, m_needsReset)
+ foreach(QSGParticlePainter* p, m_groupData[d->group]->types)
if(p && d)
p->reload(d);
}
}
//sets the x accleration without affecting the instantaneous x velocity or position
-void ParticleData::setInstantaneousAX(qreal ax)
+void QSGParticleData::setInstantaneousAX(qreal ax)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
qreal sx = (pv.sx + t*pv.ax) - t*ax;
}
//sets the x velocity without affecting the instantaneous x postion
-void ParticleData::setInstantaneousSX(qreal vx)
+void QSGParticleData::setInstantaneousSX(qreal vx)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
qreal sx = vx - t*pv.ax;
}
//sets the instantaneous x postion
-void ParticleData::setInstantaneousX(qreal x)
+void QSGParticleData::setInstantaneousX(qreal x)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
pv.x = x - t*pv.sx - 0.5 * t*t*pv.ax;
}
//sets the y accleration without affecting the instantaneous y velocity or position
-void ParticleData::setInstantaneousAY(qreal ay)
+void QSGParticleData::setInstantaneousAY(qreal ay)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
qreal sy = (pv.sy + t*pv.ay) - t*ay;
}
//sets the y velocity without affecting the instantaneous y position
-void ParticleData::setInstantaneousSY(qreal vy)
+void QSGParticleData::setInstantaneousSY(qreal vy)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
//qDebug() << t << (system->m_timeInt/1000.0) << pv.x << pv.sx << pv.ax << pv.x + pv.sx * t + 0.5 * pv.ax * t * t;
}
//sets the instantaneous Y position
-void ParticleData::setInstantaneousY(qreal y)
+void QSGParticleData::setInstantaneousY(qreal y)
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
pv.y = y - t*pv.sy - 0.5 * t*t*pv.ay;
}
-qreal ParticleData::curX() const
+qreal QSGParticleData::curX() const
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
return pv.x + pv.sx * t + 0.5 * pv.ax * t * t;
}
-qreal ParticleData::curSX() const
+qreal QSGParticleData::curSX() const
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
return pv.sx + t*pv.ax;
}
-qreal ParticleData::curY() const
+qreal QSGParticleData::curY() const
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
return pv.y + pv.sy * t + 0.5 * pv.ay * t * t;
}
-qreal ParticleData::curSY() const
+qreal QSGParticleData::curSY() const
{
qreal t = (system->m_timeInt / 1000.0) - pv.t;
return pv.sy + t*pv.ay;
}
-void ParticleData::debugDump()
+void QSGParticleData::debugDump()
{
qDebug() << "Particle" << group
<< "Pos: " << pv.x << "," << pv.y
<< "Time: " << pv.t << "," <<pv.lifeSpan;
}
-bool ParticleData::stillAlive()
+bool QSGParticleData::stillAlive()
{
if(!system)
return false;
QT_MODULE(Declarative)
-class ParticleAffector;
-class ParticleEmitter;
-class ParticleType;
-class ParticleData;
+class QSGParticleAffector;
+class QSGParticleEmitter;
+class QSGParticlePainter;
+class QSGParticleData;
struct GroupData{
int size;
int start;
int nextIdx;
- QList<ParticleType*> types;
+ QList<QSGParticlePainter*> types;
};
-class ParticleSystem : public QSGItem
+class QSGParticleSystem : public QSGItem
{
Q_OBJECT
Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY runningChanged)
*/
public:
- explicit ParticleSystem(QSGItem *parent = 0);
+ explicit QSGParticleSystem(QSGItem *parent = 0);
bool isRunning() const
{
private slots:
void countChanged();
public://but only really for related class usage. Perhaps we should all be friends?
- void emitParticle(ParticleData* p);
- ParticleData* newDatum(int groupId);
- qint64 systemSync(ParticleType* p);
+ void emitParticle(QSGParticleData* p);
+ QSGParticleData* newDatum(int groupId);
+ qint64 systemSync(QSGParticlePainter* p);
QElapsedTimer m_timestamp;
- QVector<ParticleData*> m_data;
- QSet<ParticleData*> m_needsReset;
+ QVector<QSGParticleData*> m_data;
+ QSet<QSGParticleData*> m_needsReset;
QHash<QString, int> m_groupIds;
QHash<int, GroupData*> m_groupData;//id, size, start
qint64 m_timeInt;
bool m_initialized;
- void registerParticleType(ParticleType* p);
- void registerParticleEmitter(ParticleEmitter* e);
- void registerParticleAffector(ParticleAffector* a);
+ void registerParticleType(QSGParticlePainter* p);
+ void registerParticleEmitter(QSGParticleEmitter* e);
+ void registerParticleAffector(QSGParticleAffector* a);
bool overwrite() const
{
return m_overwrite;
private:
void initializeSystem();
bool m_running;
- QList<QPointer<ParticleEmitter> > m_emitters;
- QList<QPointer<ParticleAffector> > m_affectors;
- QList<QPointer<ParticleType> > m_particles;
- QList<QPointer<ParticleType> > m_syncList;
+ QList<QPointer<QSGParticleEmitter> > m_emitters;
+ QList<QPointer<QSGParticleAffector> > m_affectors;
+ QList<QPointer<QSGParticlePainter> > m_particles;
+ QList<QPointer<QSGParticlePainter> > m_syncList;
qint64 m_startTime;
int m_nextGroupId;
bool m_overwrite;
//TODO: Need opacity over life control. More variable size over life?
};
-class ParticleData{
+class QSGParticleData{
public:
- ParticleData();
+ QSGParticleData();
ParticleVertex pv;
qreal curSY() const;
int group;
- ParticleEmitter* e;
- ParticleSystem* system;
+ QSGParticleEmitter* e;
+ QSGParticleSystem* system;
int particleIndex;
int systemIndex;
**
****************************************************************************/
-#include "attractoraffector.h"
+#include "qsgpointattractor_p.h"
#include <cmath>
#include <QDebug>
QT_BEGIN_NAMESPACE
-AttractorAffector::AttractorAffector(QSGItem *parent) :
- ParticleAffector(parent), m_strength(0.0), m_x(0), m_y(0)
+QSGPointAttractorAffector::QSGPointAttractorAffector(QSGItem *parent) :
+ QSGParticleAffector(parent), m_strength(0.0), m_x(0), m_y(0)
+ , m_physics(Velocity), m_proportionalToDistance(Linear)
{
}
-bool AttractorAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGPointAttractorAffector::affectParticle(QSGParticleData *d, qreal dt)
{
if(m_strength == 0.0)
return false;
- qreal dx = m_x - d->curX();
- qreal dy = m_y - d->curY();
+ qreal dx = m_y - d->curX();
+ qreal dy = m_x - d->curY();
qreal r = sqrt((dx*dx) + (dy*dy));
qreal theta = atan2(dy,dx);
- qreal ds = (m_strength / r) * dt;
+ qreal ds = 0;
+ switch(m_proportionalToDistance){
+ case Quadratic:
+ ds = (m_strength / qMax(1.,r*r)) * dt;
+ break;
+ case Linear://also default
+ default:
+ ds = (m_strength / qMax(1.,r)) * dt;
+ }
dx = ds * cos(theta);
dy = ds * sin(theta);
- d->setInstantaneousSX(d->pv.sx + dx);
- d->setInstantaneousSY(d->pv.sy + dy);
+ switch(m_physics){
+ case Position:
+ d->pv.x = (d->pv.x + dx);
+ d->pv.y = (d->pv.y + dy);
+ break;
+ case Acceleration:
+ d->setInstantaneousAX(d->pv.ax + dx);
+ d->setInstantaneousAY(d->pv.ay + dy);
+ break;
+ case Velocity: //also default
+ default:
+ d->setInstantaneousSX(d->pv.sx + dx);
+ d->setInstantaneousSY(d->pv.sy + dy);
+ }
+
return true;
}
QT_END_NAMESPACE
#ifndef ATTRACTORAFFECTOR_H
#define ATTRACTORAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class AttractorAffector : public ParticleAffector
+class QSGPointAttractorAffector : public QSGParticleAffector
{
Q_OBJECT
//Like Gravitational singularity, but linear to distance instead of quadratic
Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
+ Q_PROPERTY(PhysicsAffects physics READ physics WRITE setPhysics NOTIFY physicsChanged)
+ Q_PROPERTY(Proportion proportionalToDistance READ proportionalToDistance WRITE setProportionalToDistance NOTIFY proportionalToDistanceChanged)
+ Q_ENUMS(PhysicsAffects)
+ Q_ENUMS(Proportion)
+
public:
- explicit AttractorAffector(QSGItem *parent = 0);
+ enum Proportion{
+ Linear,
+ Quadratic
+ };
+
+ enum PhysicsAffects {
+ Position,
+ Velocity,
+ Acceleration
+ };
+
+ explicit QSGPointAttractorAffector(QSGItem *parent = 0);
qreal strength() const
{
return m_y;
}
+ PhysicsAffects physics() const
+ {
+ return m_physics;
+ }
+
+ Proportion proportionalToDistance() const
+ {
+ return m_proportionalToDistance;
+ }
+
signals:
void strengthChanged(qreal arg);
void yChanged(qreal arg);
+ void physicsChanged(PhysicsAffects arg);
+
+ void proportionalToDistanceChanged(Proportion arg);
+
public slots:
void setStrength(qreal arg)
{
emit yChanged(arg);
}
}
+void setPhysics(PhysicsAffects arg)
+{
+ if (m_physics != arg) {
+ m_physics = arg;
+ emit physicsChanged(arg);
+ }
+}
+
+void setProportionalToDistance(Proportion arg)
+{
+ if (m_proportionalToDistance != arg) {
+ m_proportionalToDistance = arg;
+ emit proportionalToDistanceChanged(arg);
+ }
+}
+
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
private:
qreal m_strength;
qreal m_x;
qreal m_y;
+PhysicsAffects m_physics;
+Proportion m_proportionalToDistance;
};
QT_END_NAMESPACE
**
****************************************************************************/
-#include "pointvector.h"
+#include "qsgpointdirection_p.h"
QT_BEGIN_NAMESPACE
-PointVector::PointVector(QObject *parent) :
- VaryingVector(parent)
+QSGPointDirection::QSGPointDirection(QObject *parent) :
+ QSGStochasticDirection(parent)
, m_x(0)
, m_y(0)
, m_xVariation(0)
{
}
-const QPointF &PointVector::sample(const QPointF &)
+const QPointF &QSGPointDirection::sample(const QPointF &)
{
m_ret.setX(m_x - m_xVariation + rand() / float(RAND_MAX) * m_xVariation * 2);
m_ret.setY(m_y - m_yVariation + rand() / float(RAND_MAX) * m_yVariation * 2);
#ifndef POINTVECTOR_H
#define POINTVECTOR_H
-#include "varyingvector.h"
+#include "qsgstochasticdirection_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class PointVector : public VaryingVector
+class QSGPointDirection : public QSGStochasticDirection
{
Q_OBJECT
Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
Q_PROPERTY(qreal xVariation READ xVariation WRITE setXVariation NOTIFY xVariationChanged)
Q_PROPERTY(qreal yVariation READ yVariation WRITE setYVariation NOTIFY yVariationChanged)
public:
- explicit PointVector(QObject *parent = 0);
+ explicit QSGPointDirection(QObject *parent = 0);
virtual const QPointF &sample(const QPointF &from);
qreal x() const
{
**
****************************************************************************/
-#include "spritegoalaffector.h"
-#include "spriteparticle.h"
-#include "spriteengine.h"
-#include "spritestate.h"
+#include "qsgspritegoal_p.h"
+#include "private/qsgspriteengine_p.h"
+#include "private/qsgsprite_p.h"
+#include "qsgimageparticle_p.h"
#include <QDebug>
QT_BEGIN_NAMESPACE
-SpriteGoalAffector::SpriteGoalAffector(QSGItem *parent) :
- ParticleAffector(parent), m_goalIdx(-1), m_jump(false)
+QSGSpriteGoalAffector::QSGSpriteGoalAffector(QSGItem *parent) :
+ QSGParticleAffector(parent), m_goalIdx(-1), m_jump(false)
{
}
-void SpriteGoalAffector::updateStateIndex(SpriteEngine* e)
+void QSGSpriteGoalAffector::updateStateIndex(QSGSpriteEngine* e)
{
m_lastEngine = e;
for(int i=0; i<e->stateCount(); i++){
m_goalIdx = -1;//Can't find it
}
-void SpriteGoalAffector::setGoalState(QString arg)
+void QSGSpriteGoalAffector::setGoalState(QString arg)
{
if (m_goalState != arg) {
m_goalState = arg;
}
}
-bool SpriteGoalAffector::affectParticle(ParticleData *d, qreal dt)
+bool QSGSpriteGoalAffector::affectParticle(QSGParticleData *d, qreal dt)
{
Q_UNUSED(dt);
//TODO: Affect all engines
- SpriteEngine *engine = 0;
- foreach(ParticleType *p, m_system->m_groupData[d->group]->types)
- if(qobject_cast<SpriteParticle*>(p))
- engine = qobject_cast<SpriteParticle*>(p)->spriteEngine();
+ QSGSpriteEngine *engine = 0;
+ foreach(QSGParticlePainter *p, m_system->m_groupData[d->group]->types)
+ if(qobject_cast<QSGImageParticle*>(p))
+ engine = qobject_cast<QSGImageParticle*>(p)->spriteEngine();
if(!engine)
return false;
#ifndef SPRITEGOALAFFECTOR_H
#define SPRITEGOALAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class SpriteEngine;
+class QSGSpriteEngine;
-class SpriteGoalAffector : public ParticleAffector
+class QSGSpriteGoalAffector : public QSGParticleAffector
{
Q_OBJECT
Q_PROPERTY(QString goalState READ goalState WRITE setGoalState NOTIFY goalStateChanged)
Q_PROPERTY(bool jump READ jump WRITE setJump NOTIFY jumpChanged)
public:
- explicit SpriteGoalAffector(QSGItem *parent = 0);
+ explicit QSGSpriteGoalAffector(QSGItem *parent = 0);
QString goalState() const
{
return m_jump;
}
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
signals:
void goalStateChanged(QString arg);
}
private:
- void updateStateIndex(SpriteEngine* e);
+ void updateStateIndex(QSGSpriteEngine* e);
QString m_goalState;
int m_goalIdx;
- SpriteEngine* m_lastEngine;
+ QSGSpriteEngine* m_lastEngine;
bool m_jump;
};
**
****************************************************************************/
-#include "varyingvector.h"
+#include "qsgstochasticdirection_p.h"
QT_BEGIN_NAMESPACE
-VaryingVector::VaryingVector(QObject *parent) :
+QSGStochasticDirection::QSGStochasticDirection(QObject *parent) :
QObject(parent)
{
}
-const QPointF &VaryingVector::sample(const QPointF &from)
+const QPointF &QSGStochasticDirection::sample(const QPointF &from)
{
return m_ret;
}
QT_MODULE(Declarative)
-class VaryingVector : public QObject
+class QSGStochasticDirection : public QObject
{
Q_OBJECT
public:
- explicit VaryingVector(QObject *parent = 0);
+ explicit QSGStochasticDirection(QObject *parent = 0);
virtual const QPointF &sample(const QPointF &from);
signals:
**
****************************************************************************/
-#include "directedvector.h"
-#include "particleemitter.h"
+#include "qsgtargeteddirection_p.h"
+#include "qsgparticleemitter_p.h"
#include <cmath>
#include <QDebug>
QT_BEGIN_NAMESPACE
-DirectedVector::DirectedVector(QObject *parent) :
- VaryingVector(parent)
+QSGTargetedDirection::QSGTargetedDirection(QObject *parent) :
+ QSGStochasticDirection(parent)
, m_targetX(0)
, m_targetY(0)
, m_targetVariation(0)
{
}
-const QPointF &DirectedVector::sample(const QPointF &from)
+const QPointF &QSGTargetedDirection::sample(const QPointF &from)
{
//###This approach loses interpolating the last position of the target (like we could with the emitter) is it worthwhile?
qreal targetX;
qreal targetY;
if(m_targetItem){
- ParticleEmitter* parentEmitter = qobject_cast<ParticleEmitter*>(parent());
+ QSGParticleEmitter* parentEmitter = qobject_cast<QSGParticleEmitter*>(parent());
targetX = m_targetItem->width()/2;
targetY = m_targetItem->height()/2;
if(!parentEmitter){
#ifndef DIRECTEDVECTOR_H
#define DIRECTEDVECTOR_H
-#include "varyingvector.h"
+#include "qsgstochasticdirection_p.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
QT_MODULE(Declarative)
class QSGItem;
-class DirectedVector : public VaryingVector
+class QSGTargetedDirection : public QSGStochasticDirection
{
Q_OBJECT
Q_PROPERTY(qreal targetX READ targetX WRITE setTargetX NOTIFY targetXChanged)
Q_PROPERTY(qreal magnitudeVariation READ magnitudeVariation WRITE setMagnitudeVariation NOTIFY magnitudeVariationChanged)
public:
- explicit DirectedVector(QObject *parent = 0);
+ explicit QSGTargetedDirection(QObject *parent = 0);
virtual const QPointF &sample(const QPointF &from);
qreal targetX() const
**
****************************************************************************/
-#include "turbulenceaffector.h"
-#include "particle.h"
+#include "qsgturbulence_p.h"
+#include "qsgparticlepainter_p.h"//TODO: Why was this needed again?
#include <cmath>
#include <cstdlib>
#include <QDebug>
QT_BEGIN_NAMESPACE
-TurbulenceAffector::TurbulenceAffector(QSGItem *parent) :
- ParticleAffector(parent),
+QSGTurbulenceAffector::QSGTurbulenceAffector(QSGItem *parent) :
+ QSGParticleAffector(parent),
m_strength(10), m_lastT(0), m_frequency(64), m_gridSize(10), m_field(0), m_inited(false)
{
//TODO: Update grid on size change
}
-TurbulenceAffector::~TurbulenceAffector()
+QSGTurbulenceAffector::~QSGTurbulenceAffector()
{
if (m_field) {
for(int i=0; i<m_gridSize; i++)
return sqrt(x*x + y*y);
}
-void TurbulenceAffector::setSize(int arg)
+void QSGTurbulenceAffector::setSize(int arg)
{
if (m_gridSize != arg) {
if(m_field){ //deallocate and then reallocate grid
}
}
-void TurbulenceAffector::ensureInit()
+void QSGTurbulenceAffector::ensureInit()
{
if(m_inited)
return;
m_magSum = magnitude(m_spacing.x(), m_spacing.y())*2;
}
-void TurbulenceAffector::mapUpdate()
+void QSGTurbulenceAffector::mapUpdate()
{
QPoint pos(rand() % m_gridSize, rand() % m_gridSize);
QPointF vector(m_strength - (((qreal)rand() / RAND_MAX) * m_strength*2),
}
-void TurbulenceAffector::affectSystem(qreal dt)
+void QSGTurbulenceAffector::affectSystem(qreal dt)
{
if(!m_system || !m_active)
return;
m_lastT += period;
}
- foreach(ParticleData *d, m_system->m_data){
+ foreach(QSGParticleData *d, m_system->m_data){
if(!d || !activeGroup(d->group))
return;
qreal fx = 0.0;
#ifndef TURBULENCEAFFECTOR_H
#define TURBULENCEAFFECTOR_H
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
#include <QDeclarativeListProperty>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class ParticleType;
+class QSGParticlePainter;
-class TurbulenceAffector : public ParticleAffector
+class QSGTurbulenceAffector : public QSGParticleAffector
{
Q_OBJECT
Q_PROPERTY(int strength READ strength WRITE setStrength NOTIFY strengthChanged)
Q_PROPERTY(int frequency READ frequency WRITE setFrequency NOTIFY frequencyChanged)
Q_PROPERTY(int gridSize READ size WRITE setSize NOTIFY sizeChanged)
public:
- explicit TurbulenceAffector(QSGItem *parent = 0);
- ~TurbulenceAffector();
+ explicit QSGTurbulenceAffector(QSGItem *parent = 0);
+ ~QSGTurbulenceAffector();
virtual void affectSystem(qreal dt);
int strength() const
**
****************************************************************************/
-#include "wanderaffector.h"
-#include "particlesystem.h"//for ParticlesVertices
+#include "qsgwander_p.h"
+#include "qsgparticlesystem_p.h"//for ParticlesVertices
QT_BEGIN_NAMESPACE
-WanderAffector::WanderAffector(QSGItem *parent) :
- ParticleAffector(parent)
+QSGWanderAffector::QSGWanderAffector(QSGItem *parent) :
+ QSGParticleAffector(parent), m_xVariance(0), m_yVariance(0), m_pace(0)
+ , m_physics(Velocity)
{
m_needsReset = true;
}
-WanderAffector::~WanderAffector()
+QSGWanderAffector::~QSGWanderAffector()
{
for(QHash<int, WanderData*>::const_iterator iter=m_wanderData.constBegin();
iter != m_wanderData.constEnd(); iter++)
delete (*iter);
}
-WanderData* WanderAffector::getData(int idx)
+WanderData* QSGWanderAffector::getData(int idx)
{
if(m_wanderData.contains(idx))
return m_wanderData[idx];
return d;
}
-void WanderAffector::reset(int systemIdx)
+void QSGWanderAffector::reset(int systemIdx)
{
if(m_wanderData.contains(systemIdx))
delete m_wanderData[systemIdx];
m_wanderData.remove(systemIdx);
}
-bool WanderAffector::affectParticle(ParticleData* data, qreal dt)
+bool QSGWanderAffector::affectParticle(QSGParticleData* data, qreal dt)
{
+ /*TODO: Add a mode which does basically this - picking a direction, going in it (random speed) and then going back
WanderData* d = getData(data->systemIndex);
if (m_xVariance != 0.) {
if ((d->x_vel > d->x_peak && d->x_var > 0.0) || (d->x_vel < -d->x_peak && d->x_var < 0.0)) {
p->y += dy;
return true;
+ */
+ qreal dx = dt * m_pace * (2 * qreal(qrand())/RAND_MAX - 1);
+ qreal dy = dt * m_pace * (2 * qreal(qrand())/RAND_MAX - 1);
+ qreal newX, newY;
+ switch(m_physics){
+ case Position:
+ newX = data->curX() + dx;
+ if(m_xVariance > qAbs(newX) )
+ data->pv.x += dx;
+ newY = data->curY() + dy;
+ if(m_yVariance > qAbs(newY) )
+ data->pv.y += dy;
+ break;
+ default:
+ case Velocity:
+ newX = data->curSX() + dx;
+ if(m_xVariance > qAbs(newX) )
+ data->setInstantaneousSX(newX);
+ newY = data->curSY() + dy;
+ if(m_yVariance > qAbs(newY) )
+ data->setInstantaneousSY(newY);
+ break;
+ case Acceleration:
+ newX = data->pv.ax + dx;
+ if(m_xVariance > qAbs(newX) )
+ data->setInstantaneousAX(newX);
+ newY = data->pv.ay + dy;
+ if(m_yVariance > qAbs(newY) )
+ data->setInstantaneousAY(newY);
+ break;
+ }
+ return true;
}
QT_END_NAMESPACE
#ifndef WANDERAFFECTOR_H
#define WANDERAFFECTOR_H
#include <QHash>
-#include "particleaffector.h"
+#include "qsgparticleaffector_p.h"
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class SpriteEmitter;
-
struct WanderData{
qreal x_vel;
qreal y_vel;
qreal y_var;
};
-class WanderAffector : public ParticleAffector
+class QSGWanderAffector : public QSGParticleAffector
{
Q_OBJECT
+ Q_PROPERTY(qreal pace READ pace WRITE setPace NOTIFY paceChanged)
Q_PROPERTY(qreal xVariance READ xVariance WRITE setXVariance NOTIFY xVarianceChanged)
Q_PROPERTY(qreal yVariance READ yVariance WRITE setYVariance NOTIFY yVarianceChanged)
- Q_PROPERTY(qreal pace READ pace WRITE setPace NOTIFY paceChanged)
+ Q_PROPERTY(PhysicsAffects physics READ physics WRITE setPhysics NOTIFY physicsChanged)
+ Q_ENUMS(PhysicsAffects)
public:
- explicit WanderAffector(QSGItem *parent = 0);
- ~WanderAffector();
+ enum PhysicsAffects {
+ Position,
+ Velocity,
+ Acceleration
+ };
+
+ explicit QSGWanderAffector(QSGItem *parent = 0);
+ ~QSGWanderAffector();
virtual void reset(int systemIdx);
qreal xVariance() const
{
return m_pace;
}
+
+ PhysicsAffects physics() const
+ {
+ return m_physics;
+ }
+
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
+ virtual bool affectParticle(QSGParticleData *d, qreal dt);
signals:
void xVarianceChanged(qreal arg);
void paceChanged(qreal arg);
+
+ void physicsChanged(PhysicsAffects arg);
+
public slots:
void setXVariance(qreal arg)
{
}
}
+
+void setPhysics(PhysicsAffects arg)
+{
+ if (m_physics != arg) {
+ m_physics = arg;
+ emit physicsChanged(arg);
+ }
+}
+
private:
WanderData* getData(int idx);
QHash<int, WanderData*> m_wanderData;
qreal m_xVariance;
qreal m_yVariance;
qreal m_pace;
+ PhysicsAffects m_physics;
};
QT_END_NAMESPACE
#include "private/qdeclarativenotifier_p.h"
#include "private/qdeclarativedebugtrace_p.h"
#include "private/qdeclarativeapplication_p.h"
+#include "private/qjsdebugservice_p.h"
#include <QtCore/qmetaobject.h>
#include <QScriptClass>
#include <private/qdeclarativeitemsmodule_p.h>
#include <private/qdeclarativeutilmodule_p.h>
#include <private/qsgitemsmodule_p.h>
+#include <private/qsgparticlesmodule_p.h>
#include <qsgtexture.h>
#ifdef Q_OS_WIN // for %APPDATA%
\brief The QtObject element is the most basic element in QML.
The QtObject element is a non-visual element which contains only the
- objectName property.
+ objectName property.
It can be useful to create a QtObject if you need an extremely
lightweight element to enclose a set of custom properties:
This property holds the QObject::objectName for this specific object instance.
This allows a C++ application to locate an item within a QML component
- using the QObject::findChild() method. For example, the following C++
+ using the QObject::findChild() method. For example, the following C++
application locates the child \l Rectangle item and dynamically changes its
\c color value:
Rectangle {
anchors.fill: parent
- color: "red"
+ color: "red"
objectName: "myRect"
}
}
view.show();
QDeclarativeItem *item = view.rootObject()->findChild<QDeclarativeItem*>("myRect");
- if (item)
+ if (item)
item->setProperty("color", QColor(Qt::yellow));
\endcode
*/
\keyword QmlGlobalQtObject
-\brief The \c Qt object provides useful enums and functions from Qt, for use in all QML files.
+\brief The \c Qt object provides useful enums and functions from Qt, for use in all QML files.
The \c Qt object is a global object with utility functions, properties and enums.
QDeclarativeUtilModule::defineModule();
QDeclarativeEnginePrivate::defineModule();
QSGItemsModule::defineModule();
+ QSGParticlesModule::defineModule();
QDeclarativeValueTypeFactory::registerValueTypes();
}
globalClass = new QDeclarativeGlobalScriptClass(&scriptEngine);
QDeclarativeEngineDebugServer::isDebuggingEnabled()) {
isDebugging = true;
QDeclarativeEngineDebugServer::instance()->addEngine(q);
+ QJSDebugService::instance()->addEngine(q);
}
}
QDeclarativeEngine::~QDeclarativeEngine()
{
Q_D(QDeclarativeEngine);
- if (d->isDebugging)
+ if (d->isDebugging) {
QDeclarativeEngineDebugServer::instance()->remEngine(this);
+ }
// if we are the parent of any of the qobject module api instances,
// we need to remove them from our internal list, in order to prevent
/*!
Sets the \a provider to use for images requested via the \e
- image: url scheme, with host \a providerId. The QDeclarativeEngine
+ image: url scheme, with host \a providerId. The QDeclarativeEngine
takes ownership of \a provider.
Image providers enable support for pixmap and threaded image
rv = pf(const_cast<QObject *>(object));
- if (rv)
+ if (rv)
data->attachedProperties()->insert(id, rv);
return rv;
or \c null if an empty string was given.
The returned component's \l Component::status property indicates whether the
-component was successfully created. If the status is \c Component.Error,
+component was successfully created. If the status is \c Component.Error,
see \l Component::errorString() for an error description.
Call \l {Component::createObject()}{Component.createObject()} on the returned
return engine->newVariant(QVariant::fromValue(date.toString(format)));
} else if (formatArg.isNumber()) {
enumFormat = Qt::DateFormat(formatArg.toUInt32());
- } else {
+ } else {
return ctxt->throwError(QLatin1String("Qt.formatDateTime(): Invalid datetime format"));
}
}
}
/*!
-\qmlmethod rect Qt::rect(int x, int y, int width, int height)
+\qmlmethod rect Qt::rect(int x, int y, int width, int height)
Returns a \c rect with the top-left corner at \c x, \c y and the specified \c width and \c height.
*/
QScriptValue QDeclarativeEnginePrivate::btoa(QScriptContext *ctxt, QScriptEngine *)
{
- if (ctxt->argumentCount() != 1)
+ if (ctxt->argumentCount() != 1)
return ctxt->throwError(QLatin1String("Qt.btoa(): Invalid arguments"));
QByteArray data = ctxt->argument(0).toString().toUtf8();
QScriptValue QDeclarativeEnginePrivate::atob(QScriptContext *ctxt, QScriptEngine *)
{
- if (ctxt->argumentCount() != 1)
+ if (ctxt->argumentCount() != 1)
return ctxt->throwError(QLatin1String("Qt.atob(): Invalid arguments"));
QByteArray data = ctxt->argument(0).toString().toUtf8();
}
}
-QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeType *type, int minorVersion,
+QDeclarativePropertyCache *QDeclarativeEnginePrivate::createCache(QDeclarativeType *type, int minorVersion,
QDeclarativeError &error)
{
QList<QDeclarativeType *> types;
const QMetaObject *metaObject = type->metaObject();
while (metaObject) {
- QDeclarativeType *t = QDeclarativeMetaType::qmlType(metaObject, type->module(),
+ QDeclarativeType *t = QDeclarativeMetaType::qmlType(metaObject, type->module(),
type->majorVersion(), minorVersion);
if (t) {
maxMinorVersion = qMax(maxMinorVersion, t->minorVersion());
// Signals override:
// * other signals and methods of the same name.
- // * properties named on<Signal Name>
+ // * properties named on<Signal Name>
// * automatic <property name>Changed notify signals
// Methods override:
QDeclarativePropertyCache::Data *current = d;
while (!overloadError && current) {
current = d->overrideData(current);
- if (current && raw->isAllowedInRevision(current))
+ if (current && raw->isAllowedInRevision(current))
overloadError = true;
}
}
if (overloadError) {
if (hasCopied) raw->release();
-
+
error.setDescription(QLatin1String("Type ") + QString::fromUtf8(type->qmlTypeName()) + QLatin1String(" ") + QString::number(type->majorVersion()) + QLatin1String(".") + QString::number(minorVersion) + QLatin1String(" contains an illegal property \"") + overloadName + QLatin1String("\". This is an error in the type's implementation."));
return 0;
}
class ScarceResourceData;
class QDeclarativeTypeNameScriptClass;
class QDeclarativeValueTypeScriptClass;
-class QScriptEngineDebugger;
class QNetworkReply;
class QNetworkAccessManager;
class QDeclarativeNetworkAccessManagerFactory;
/*!
Returns a QDeclarativePropertyCache for \a obj if one is available.
-If \a obj is null, being deleted or contains a dynamic meta object 0
+If \a obj is null, being deleted or contains a dynamic meta object 0
is returned.
The returned cache is not referenced, so if it is to be stored, call addref().
*/
-QDeclarativePropertyCache *QDeclarativeEnginePrivate::cache(QObject *obj)
+QDeclarativePropertyCache *QDeclarativeEnginePrivate::cache(QObject *obj)
{
- if (!obj || QObjectPrivate::get(obj)->metaObject || QObjectPrivate::get(obj)->wasDeleted)
+ if (!obj || QObjectPrivate::get(obj)->metaObject || QObjectPrivate::get(obj)->wasDeleted)
return 0;
const QMetaObject *mo = obj->metaObject();
}
/*!
-Returns a QDeclarativePropertyCache for \a metaObject.
+Returns a QDeclarativePropertyCache for \a metaObject.
As the cache is persisted for the life of the engine, \a metaObject must be
-a static "compile time" meta-object, or a meta-object that is otherwise known to
+a static "compile time" meta-object, or a meta-object that is otherwise known to
exist for the lifetime of the QDeclarativeEngine.
The returned cache is not referenced, so if it is to be stored, call addref().
#include <qdeclarativeguard_p.h>
#include <private/qdeclarativedebugtrace_p.h>
+#include <private/qdeclarativeobserverservice_p.h>
#include <qscriptvalueiterator.h>
#include <qdebug.h>
q->viewport()->setAttribute(Qt::WA_OpaquePaintEvent);
q->viewport()->setAttribute(Qt::WA_NoSystemBackground);
#endif
+
+ QDeclarativeObserverService::instance()->addView(q);
}
/*!
*/
QDeclarativeView::~QDeclarativeView()
{
+ QDeclarativeObserverService::instance()->removeView(this);
}
/*! \property QDeclarativeView::source
emit statusChanged(status());
}
-
/*!
\internal
*/
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef BURSTEMITTER_H
-#define BURSTEMITTER_H
-
-#include "trailsemitter.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-//Convenience Class - can't do function overloads in QML?
-class BurstEmitter : public TrailsEmitter
-{
- Q_OBJECT
-public:
- explicit BurstEmitter(QSGItem* parent = 0):TrailsEmitter(parent){}
-public slots:
- void burst(int count, qreal x, qreal y);
-};
-
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <private/qsgcontext_p.h>
-#include <private/qsgadaptationlayer_p.h>
-#include <qsgnode.h>
-#include <qsgtexturematerial.h>
-#include <qsgtexture.h>
-#include <QFile>
-#include "coloredparticle.h"
-#include "particleemitter.h"
-#include <QGLFunctions>
-#include <qsgengine.h>
-
-QT_BEGIN_NAMESPACE
-
-class ParticleTrailsMaterial : public QSGMaterial
-{
-public:
- ParticleTrailsMaterial()
- : timestamp(0)
- {
- setFlag(Blending, true);
- }
-
- ~ParticleTrailsMaterial()
- {
- delete texture;
- }
-
- virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
- virtual QSGMaterialShader *createShader() const;
- virtual int compare(const QSGMaterial *other) const
- {
- return this - static_cast<const ParticleTrailsMaterial *>(other);
- }
-
- QSGTexture *texture;
-
- qreal timestamp;
-};
-
-
-class ParticleTrailsMaterialData : public QSGMaterialShader
-{
-public:
- ParticleTrailsMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
- {
- QFile vf(vertexFile ? vertexFile : ":resources/trailsvertex.shader");
- vf.open(QFile::ReadOnly);
- m_vertex_code = vf.readAll();
-
- QFile ff(fragmentFile ? fragmentFile : ":resources/trailsfragment.shader");
- ff.open(QFile::ReadOnly);
- m_fragment_code = ff.readAll();
-
- Q_ASSERT(!m_vertex_code.isNull());
- Q_ASSERT(!m_fragment_code.isNull());
- }
-
- void deactivate() {
- QSGMaterialShader::deactivate();
-
- for (int i=0; i<8; ++i) {
- program()->setAttributeArray(i, GL_FLOAT, chunkOfBytes, 1, 0);
- }
- }
-
- virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
- {
- ParticleTrailsMaterial *m = static_cast<ParticleTrailsMaterial *>(newEffect);
- state.context()->functions()->glActiveTexture(GL_TEXTURE0);
- m->texture->bind();
-
- program()->setUniformValue(m_opacity_id, state.opacity());
- program()->setUniformValue(m_timestamp_id, (float) m->timestamp);
-
- if (state.isMatrixDirty())
- program()->setUniformValue(m_matrix_id, state.combinedMatrix());
- }
-
- virtual void initialize() {
- m_matrix_id = program()->uniformLocation("matrix");
- m_opacity_id = program()->uniformLocation("opacity");
- m_timestamp_id = program()->uniformLocation("timestamp");
- }
-
- virtual const char *vertexShader() const { return m_vertex_code.constData(); }
- virtual const char *fragmentShader() const { return m_fragment_code.constData(); }
-
- virtual char const *const *attributeNames() const {
- static const char *attr[] = {
- "vPos",
- "vTex",
- "vData",
- "vVec",
- "vColor",
- 0
- };
- return attr;
- }
-
- virtual bool isColorTable() const { return false; }
-
- int m_matrix_id;
- int m_opacity_id;
- int m_timestamp_id;
-
- QByteArray m_vertex_code;
- QByteArray m_fragment_code;
-
- static float chunkOfBytes[1024];
-};
-float ParticleTrailsMaterialData::chunkOfBytes[1024];
-
-
-QSGMaterialShader *ParticleTrailsMaterial::createShader() const
-{
- return new ParticleTrailsMaterialData;
-}
-
-
-class ParticleTrailsMaterialCT : public ParticleTrailsMaterial
-{
-public:
- ParticleTrailsMaterialCT()
- {
- }
-
- ~ParticleTrailsMaterialCT()
- {
- delete colortable;
- delete sizetable;
- delete opacitytable;
- }
-
- virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
- virtual QSGMaterialShader *createShader() const;
-
- QSGTexture *colortable;
- QSGTexture *sizetable;
- QSGTexture *opacitytable;
-};
-
-
-class ParticleTrailsMaterialDataCT : public ParticleTrailsMaterialData
-{
-public:
- ParticleTrailsMaterialDataCT()
- : ParticleTrailsMaterialData(":resources/ctvertex.shader", ":resources/ctfragment.shader")
- {
- }
-
- bool isColorTable() const { return true; }
-
- virtual void initialize() {
- ParticleTrailsMaterialData::initialize();
- m_colortable_id = program()->uniformLocation("colortable");
- m_sizetable_id = program()->uniformLocation("sizetable");
- m_opacitytable_id = program()->uniformLocation("opacitytable");
- }
-
- virtual void updateState(const RenderState &state, QSGMaterial *current, QSGMaterial *old)
- {
- // Bind the texture to unit 1 before calling the base class, so that the
- // base class can set active texture back to 0.
- ParticleTrailsMaterialCT *m = static_cast<ParticleTrailsMaterialCT *>(current);
- state.context()->functions()->glActiveTexture(GL_TEXTURE1);
- m->colortable->bind();
- program()->setUniformValue(m_colortable_id, 1);
-
- state.context()->functions()->glActiveTexture(GL_TEXTURE2);
- m->sizetable->bind();
- program()->setUniformValue(m_sizetable_id, 2);
-
- state.context()->functions()->glActiveTexture(GL_TEXTURE3);
- m->opacitytable->bind();
- program()->setUniformValue(m_opacitytable_id, 3);
-
- ParticleTrailsMaterialData::updateState(state, current, old);
- }
-
- int m_colortable_id;
- int m_sizetable_id;
- int m_opacitytable_id;
-};
-
-
-QSGMaterialShader *ParticleTrailsMaterialCT::createShader() const
-{
- return new ParticleTrailsMaterialDataCT;
-}
-
-ColoredParticle::ColoredParticle(QSGItem* parent)
- : ParticleType(parent)
- , m_do_reset(false)
- , m_color(Qt::white)
- , m_color_variation(0.5)
- , m_node(0)
- , m_material(0)
- , m_alphaVariation(0.0)
- , m_alpha(1.0)
- , m_redVariation(0.0)
- , m_greenVariation(0.0)
- , m_blueVariation(0.0)
-{
- setFlag(ItemHasContents);
-}
-
-void ColoredParticle::setImage(const QUrl &image)
-{
- if (image == m_image_name)
- return;
- m_image_name = image;
- emit imageChanged();
- reset();
-}
-
-
-void ColoredParticle::setColortable(const QUrl &table)
-{
- if (table == m_colortable_name)
- return;
- m_colortable_name = table;
- emit colortableChanged();
- reset();
-}
-
-void ColoredParticle::setSizetable(const QUrl &table)
-{
- if (table == m_sizetable_name)
- return;
- m_sizetable_name = table;
- emit sizetableChanged();
- reset();
-}
-
-void ColoredParticle::setOpacitytable(const QUrl &table)
-{
- if (table == m_opacitytable_name)
- return;
- m_opacitytable_name = table;
- emit opacitytableChanged();
- reset();
-}
-
-void ColoredParticle::setColor(const QColor &color)
-{
- if (color == m_color)
- return;
- m_color = color;
- emit colorChanged();
- //m_system->pleaseReset();//XXX
-}
-
-void ColoredParticle::setColorVariation(qreal var)
-{
- if (var == m_color_variation)
- return;
- m_color_variation = var;
- emit colorVariationChanged();
- //m_system->pleaseReset();//XXX
-}
-
-void ColoredParticle::setCount(int c)
-{
- ParticleType::setCount(c);
- m_pleaseReset = true;
-}
-
-void ColoredParticle::reset()
-{
- ParticleType::reset();
- m_pleaseReset = true;
-}
-
-static QSGGeometry::Attribute ColoredParticle_Attributes[] = {
- { 0, 2, GL_FLOAT }, // Position
- { 1, 2, GL_FLOAT }, // TexCoord
- { 2, 4, GL_FLOAT }, // Data
- { 3, 4, GL_FLOAT }, // Vectors
- { 4, 4, GL_UNSIGNED_BYTE } // Colors
-};
-
-static QSGGeometry::AttributeSet ColoredParticle_AttributeSet =
-{
- 5, // Attribute Count
- (2 + 2 + 4 + 4) * sizeof(float) + 4 * sizeof(uchar),
- ColoredParticle_Attributes
-};
-
-QSGGeometryNode* ColoredParticle::buildParticleNode()
-{
- if (m_count * 4 > 0xffff) {
- printf("ColoredParticle: Too many particles... \n");
- return 0;
- }
-
- if(m_count <= 0) {
- printf("ColoredParticle: Too few particles... \n");
- return 0;
- }
-
- QImage image(m_image_name.toLocalFile());
- if (image.isNull()) {
- printf("ParticleTrails: loading image failed... '%s'\n", qPrintable(m_image_name.toLocalFile()));
- return 0;
- }
-
- int vCount = m_count * 4;
- int iCount = m_count * 6;
-
- QSGGeometry *g = new QSGGeometry(ColoredParticle_AttributeSet, vCount, iCount);
- g->setDrawingMode(GL_TRIANGLES);
-
- ColoredParticleVertex *vertices = (ColoredParticleVertex *) g->vertexData();
- for (int p=0; p<m_count; ++p) {
-
- for (int i=0; i<4; ++i) {
- vertices[i].x = 0;
- vertices[i].y = 0;
- vertices[i].t = -1;
- vertices[i].lifeSpan = 0;
- vertices[i].size = 0;
- vertices[i].endSize = 0;
- vertices[i].sx = 0;
- vertices[i].sy = 0;
- vertices[i].ax = 0;
- vertices[i].ay = 0;
- }
-
- vertices[0].tx = 0;
- vertices[0].ty = 0;
-
- vertices[1].tx = 1;
- vertices[1].ty = 0;
-
- vertices[2].tx = 0;
- vertices[2].ty = 1;
-
- vertices[3].tx = 1;
- vertices[3].ty = 1;
-
- vertices += 4;
- }
-
- quint16 *indices = g->indexDataAsUShort();
- for (int i=0; i<m_count; ++i) {
- int o = i * 4;
- indices[0] = o;
- indices[1] = o + 1;
- indices[2] = o + 2;
- indices[3] = o + 1;
- indices[4] = o + 3;
- indices[5] = o + 2;
- indices += 6;
- }
-
- if (m_material) {
- delete m_material;
- m_material = 0;
- }
-
- QImage colortable(m_colortable_name.toLocalFile());
- QImage sizetable(m_sizetable_name.toLocalFile());
- QImage opacitytable(m_opacitytable_name.toLocalFile());
- if(!colortable.isNull() || !sizetable.isNull() || !opacitytable.isNull()){
- //using tabled shaders
- m_material = new ParticleTrailsMaterialCT();
- if(colortable.isNull())
- colortable = QImage(":resources/identitytable.png");
- if(sizetable.isNull())
- sizetable = QImage(":resources/identitytable.png");
- if(opacitytable.isNull())
- opacitytable = QImage(":resources/defaultFadeInOut.png");
- Q_ASSERT(!colortable.isNull());
- Q_ASSERT(!sizetable.isNull());
- Q_ASSERT(!opacitytable.isNull());
- ParticleTrailsMaterialCT* ct_material = static_cast<ParticleTrailsMaterialCT *>(m_material);
- ct_material->colortable = sceneGraphEngine()->createTextureFromImage(colortable);
- ct_material->sizetable = sceneGraphEngine()->createTextureFromImage(sizetable);
- ct_material->opacitytable = sceneGraphEngine()->createTextureFromImage(opacitytable);
- }
-
- if (!m_material)
- m_material = new ParticleTrailsMaterial();
-
-
- m_material->texture = sceneGraphEngine()->createTextureFromImage(image);
- m_material->texture->setFiltering(QSGTexture::Linear);
-
- m_node = new QSGGeometryNode();
- m_node->setGeometry(g);
- m_node->setMaterial(m_material);
-
- m_last_particle = 0;
-
- return m_node;
-}
-
-QSGNode *ColoredParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
-{
- if(m_pleaseReset){
- if(m_node)
- delete m_node;
- if(m_material)
- delete m_material;
-
- m_node = 0;
- m_material = 0;
- m_pleaseReset = false;
- }
-
- if(m_system && m_system->isRunning())
- prepareNextFrame();
- if (m_node){
- update();
- m_node->markDirty(QSGNode::DirtyMaterial);
- }
-
- return m_node;
-}
-
-void ColoredParticle::prepareNextFrame()
-{
- if (m_node == 0){ //TODO: Staggered loading (as emitted)
- m_node = buildParticleNode();
- if(m_node == 0)
- return;
- }
- qint64 timeStamp = m_system->systemSync(this);
-
- qreal time = timeStamp / 1000.;
- m_material->timestamp = time;
-}
-
-void ColoredParticle::reloadColor(const Color4ub &c, ParticleData* d)
-{
- ColoredParticleVertices *particles = (ColoredParticleVertices *) m_node->geometry()->vertexData();
- int pos = particleTypeIndex(d);
- ColoredParticleVertices &p = particles[pos];
- p.v1.color = p.v2.color = p.v3.color = p.v4.color = c;
-}
-
-void ColoredParticle::vertexCopy(ColoredParticleVertex &b,const ParticleVertex& a)
-{
- b.x = a.x - m_systemOffset.x();
- b.y = a.y - m_systemOffset.y();
- b.t = a.t;
- b.lifeSpan = a.lifeSpan;
- b.size = a.size;
- b.endSize = a.endSize;
- b.sx = a.sx;
- b.sy = a.sy;
- b.ax = a.ax;
- b.ay = a.ay;
-}
-
-void ColoredParticle::reload(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- ColoredParticleVertices *particles = (ColoredParticleVertices *) m_node->geometry()->vertexData();
-
- int pos = particleTypeIndex(d);
-
- ColoredParticleVertices &p = particles[pos];
-
- //Perhaps we could be more efficient?
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-void ColoredParticle::load(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- //Color initialization
- // Particle color
- Color4ub color;
- qreal redVariation = m_color_variation + m_redVariation;
- qreal greenVariation = m_color_variation + m_greenVariation;
- qreal blueVariation = m_color_variation + m_blueVariation;
- color.r = m_color.red() * (1 - redVariation) + rand() % 256 * redVariation;
- color.g = m_color.green() * (1 - greenVariation) + rand() % 256 * greenVariation;
- color.b = m_color.blue() * (1 - blueVariation) + rand() % 256 * blueVariation;
- color.a = m_alpha * m_color.alpha() * (1 - m_alphaVariation) + rand() % 256 * m_alphaVariation;
- ColoredParticleVertices *particles = (ColoredParticleVertices *) m_node->geometry()->vertexData();
- ColoredParticleVertices &p = particles[particleTypeIndex(d)];
- p.v1.color = p.v2.color = p.v3.color = p.v4.color = color;
-
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef COLOREDPARTICLE_H
-#define COLOREDPARTICLE_H
-#include "particle.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class ParticleTrailsMaterial;
-class QSGGeometryNode;
-
-struct Color4ub {
- uchar r;
- uchar g;
- uchar b;
- uchar a;
-};
-
-struct ColoredParticleVertex {
- float x;
- float y;
- float tx;
- float ty;
- float t;
- float lifeSpan;
- float size;
- float endSize;
- float sx;
- float sy;
- float ax;
- float ay;
- Color4ub color;
-};
-
-struct ColoredParticleVertices {
- ColoredParticleVertex v1;
- ColoredParticleVertex v2;
- ColoredParticleVertex v3;
- ColoredParticleVertex v4;
-};
-
-class ColoredParticle : public ParticleType
-{
- Q_OBJECT
- Q_PROPERTY(QUrl image READ image WRITE setImage NOTIFY imageChanged)
- Q_PROPERTY(QUrl colorTable READ colortable WRITE setColortable NOTIFY colortableChanged)
- Q_PROPERTY(QUrl sizeTable READ sizetable WRITE setSizetable NOTIFY sizetableChanged)
- Q_PROPERTY(QUrl opacityTable READ opacitytable WRITE setOpacitytable NOTIFY opacitytableChanged)
-
- Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
- //Stacks (added) with individual colorVariations
- Q_PROPERTY(qreal colorVariation READ colorVariation WRITE setColorVariation NOTIFY colorVariationChanged)
- Q_PROPERTY(qreal redVariation READ redVariation WRITE setRedVariation NOTIFY redVariationChanged)
- Q_PROPERTY(qreal greenVariation READ greenVariation WRITE setGreenVariation NOTIFY greenVariationChanged)
- Q_PROPERTY(qreal blueVariation READ blueVariation WRITE setBlueVariation NOTIFY blueVariationChanged)
- //Stacks (multiplies) with the Alpha in the color, mostly here so you can use svg color names (which have full alpha)
- Q_PROPERTY(qreal alpha READ alpha WRITE setAlpha NOTIFY alphaChanged)
- Q_PROPERTY(qreal alphaVariation READ alphaVariation WRITE setAlphaVariation NOTIFY alphaVariationChanged)
-
-public:
- explicit ColoredParticle(QSGItem *parent = 0);
- virtual ~ColoredParticle(){}
-
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
- virtual void setCount(int c);
-
- QUrl image() const { return m_image_name; }
- void setImage(const QUrl &image);
-
- QUrl colortable() const { return m_colortable_name; }
- void setColortable(const QUrl &table);
-
- QUrl sizetable() const { return m_sizetable_name; }
- void setSizetable (const QUrl &table);
-
- QUrl opacitytable() const { return m_opacitytable_name; }
- void setOpacitytable(const QUrl &table);
-
- QColor color() const { return m_color; }
- void setColor(const QColor &color);
-
- qreal colorVariation() const { return m_color_variation; }
- void setColorVariation(qreal var);
-
- qreal renderOpacity() const { return m_render_opacity; }
-
- qreal alphaVariation() const
- {
- return m_alphaVariation;
- }
-
- qreal alpha() const
- {
- return m_alpha;
- }
-
- qreal redVariation() const
- {
- return m_redVariation;
- }
-
- qreal greenVariation() const
- {
- return m_greenVariation;
- }
-
- qreal blueVariation() const
- {
- return m_blueVariation;
- }
-
-signals:
-
- void imageChanged();
- void colortableChanged();
- void sizetableChanged();
- void opacitytableChanged();
-
- void colorChanged();
- void colorVariationChanged();
-
- void particleDurationChanged();
- void alphaVariationChanged(qreal arg);
-
- void alphaChanged(qreal arg);
-
- void redVariationChanged(qreal arg);
-
- void greenVariationChanged(qreal arg);
-
- void blueVariationChanged(qreal arg);
-
-public slots:
- void setAlphaVariation(qreal arg)
- {
- if (m_alphaVariation != arg) {
- m_alphaVariation = arg;
- emit alphaVariationChanged(arg);
- }
- }
-
- void setAlpha(qreal arg)
- {
- if (m_alpha != arg) {
- m_alpha = arg;
- emit alphaChanged(arg);
- }
- }
-
- void setRedVariation(qreal arg)
- {
- if (m_redVariation != arg) {
- m_redVariation = arg;
- emit redVariationChanged(arg);
- }
- }
-
- void setGreenVariation(qreal arg)
- {
- if (m_greenVariation != arg) {
- m_greenVariation = arg;
- emit greenVariationChanged(arg);
- }
- }
-
- void setBlueVariation(qreal arg)
- {
- if (m_blueVariation != arg) {
- m_blueVariation = arg;
- emit blueVariationChanged(arg);
- }
- }
-
- void reloadColor(const Color4ub &c, ParticleData* d);
-protected:
- QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- void reset();
- void prepareNextFrame();
- QSGGeometryNode* buildParticleNode();
-private:
- void vertexCopy(ColoredParticleVertex &b,const ParticleVertex& a);
- bool m_do_reset;
-
- QUrl m_image_name;
- QUrl m_colortable_name;
- QUrl m_sizetable_name;
- QUrl m_opacitytable_name;
-
-
- QColor m_color;
- qreal m_color_variation;
- qreal m_particleDuration;
-
- QSGGeometryNode *m_node;
- ParticleTrailsMaterial *m_material;
-
- // derived values...
- int m_last_particle;
-
- qreal m_render_opacity;
- qreal m_alphaVariation;
- qreal m_alpha;
- qreal m_redVariation;
- qreal m_greenVariation;
- qreal m_blueVariation;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // COLOREDPARTICLE_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <private/qsgcontext_p.h>
-#include <private/qsgadaptationlayer_p.h>
-#include <qsgnode.h>
-#include <qsgtexturematerial.h>
-#include <qsgtexture.h>
-#include <QFile>
-#include "deformableparticle.h"
-#include <QGLFunctions>
-#include <qsgengine.h>
-
-QT_BEGIN_NAMESPACE
-
-const float CONV = 0.017453292519943295;
-class DeformableParticleMaterial : public QSGMaterial
-{
-public:
- DeformableParticleMaterial()
- : timestamp(0)
- {
- setFlag(Blending, true);
- }
-
- ~DeformableParticleMaterial()
- {
- delete texture;
- }
-
- virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
- virtual QSGMaterialShader *createShader() const;
- virtual int compare(const QSGMaterial *other) const
- {
- return this - static_cast<const DeformableParticleMaterial *>(other);
- }
-
- QSGTexture *texture;
-
- qreal timestamp;
-};
-
-
-class DeformableParticleMaterialData : public QSGMaterialShader
-{
-public:
- DeformableParticleMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
- {
- QFile vf(vertexFile ? vertexFile : ":resources/deformablevertex.shader");
- vf.open(QFile::ReadOnly);
- m_vertex_code = vf.readAll();
-
- QFile ff(fragmentFile ? fragmentFile : ":resources/deformablefragment.shader");
- ff.open(QFile::ReadOnly);
- m_fragment_code = ff.readAll();
-
- Q_ASSERT(!m_vertex_code.isNull());
- Q_ASSERT(!m_fragment_code.isNull());
- }
-
- void deactivate() {
- QSGMaterialShader::deactivate();
-
- for (int i=0; i<8; ++i) {
- program()->setAttributeArray(i, GL_FLOAT, chunkOfBytes, 1, 0);
- }
- }
-
- virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
- {
- DeformableParticleMaterial *m = static_cast<DeformableParticleMaterial *>(newEffect);
- state.context()->functions()->glActiveTexture(GL_TEXTURE0);
- m->texture->bind();
-
- program()->setUniformValue(m_opacity_id, state.opacity());
- program()->setUniformValue(m_timestamp_id, (float) m->timestamp);
-
- if (state.isMatrixDirty())
- program()->setUniformValue(m_matrix_id, state.combinedMatrix());
- }
-
- virtual void initialize() {
- m_matrix_id = program()->uniformLocation("matrix");
- m_opacity_id = program()->uniformLocation("opacity");
- m_timestamp_id = program()->uniformLocation("timestamp");
- }
-
- virtual const char *vertexShader() const { return m_vertex_code.constData(); }
- virtual const char *fragmentShader() const { return m_fragment_code.constData(); }
-
- virtual char const *const *attributeNames() const {
- static const char *attr[] = {
- "vPos",
- "vTex",
- "vData",
- "vVec",
- "vDeformVec",
- "vRotation",
- 0
- };
- return attr;
- }
-
- virtual bool isColorTable() const { return false; }
-
- int m_matrix_id;
- int m_opacity_id;
- int m_timestamp_id;
-
- QByteArray m_vertex_code;
- QByteArray m_fragment_code;
-
- static float chunkOfBytes[1024];
-};
-float DeformableParticleMaterialData::chunkOfBytes[1024];
-
-
-QSGMaterialShader *DeformableParticleMaterial::createShader() const
-{
- return new DeformableParticleMaterialData;
-}
-
-struct DeformableParticleVertex {
- float x;
- float y;
- float tx;
- float ty;
- float t;
- float lifeSpan;
- float size;
- float endSize;
- float sx;
- float sy;
- float ax;
- float ay;
- float xx;
- float xy;
- float yx;
- float yy;
- float rotation;
- float rotationSpeed;
- float autoRotate;//Assume that GPUs prefer floats to bools
-};
-
-struct DeformableParticleVertices {
- DeformableParticleVertex v1;
- DeformableParticleVertex v2;
- DeformableParticleVertex v3;
- DeformableParticleVertex v4;
-};
-
-
-DeformableParticle::DeformableParticle(QSGItem* parent)
- : ParticleType(parent)
- , m_do_reset(false)
- , m_rotation(0)
- , m_autoRotation(false)
- , m_xVector(0)
- , m_yVector(0)
- , m_rotationVariation(0)
- , m_rotationSpeed(0)
- , m_rotationSpeedVariation(0)
-{
- setFlag(ItemHasContents);
-}
-
-void DeformableParticle::setImage(const QUrl &image)
-{
- if (image == m_image)
- return;
- m_image = image;
- emit imageChanged();
- reset();
-}
-
-void DeformableParticle::setCount(int c)
-{
- ParticleType::setCount(c);
- m_pleaseReset = true;
-}
-
-void DeformableParticle::reset()
-{
- ParticleType::reset();
- m_pleaseReset = true;
-}
-
-static QSGGeometry::Attribute DeformableParticle_Attributes[] = {
- { 0, 2, GL_FLOAT }, // Position
- { 1, 2, GL_FLOAT }, // TexCoord
- { 2, 4, GL_FLOAT }, // Data
- { 3, 4, GL_FLOAT }, // Vectors
- { 4, 4, GL_FLOAT }, // DeformationVectors
- { 5, 3, GL_FLOAT } // Rotation
-};
-
-static QSGGeometry::AttributeSet DeformableParticle_AttributeSet =
-{
- 6, // Attribute Count
- (2 + 2 + 4 + 4 + 4 + 3) * sizeof(float),
- DeformableParticle_Attributes
-};
-
-QSGGeometryNode* DeformableParticle::buildParticleNode()
-{
- if (m_count * 4 > 0xffff) {
- printf("DeformableParticle: Too many particles... \n");
- return 0;
- }
-
- if(m_count <= 0) {
- printf("DeformableParticle: Too few particles... \n");
- return 0;
- }
-
- QImage image(m_image.toLocalFile());
- if (image.isNull()) {
- printf("DeformableParticle: loading image failed... '%s'\n", qPrintable(m_image.toLocalFile()));
- return 0;
- }
-
- int vCount = m_count * 4;
- int iCount = m_count * 6;
-
- QSGGeometry *g = new QSGGeometry(DeformableParticle_AttributeSet, vCount, iCount);
- g->setDrawingMode(GL_TRIANGLES);
-
- DeformableParticleVertex *vertices = (DeformableParticleVertex *) g->vertexData();
- for (int p=0; p<m_count; ++p) {
-
- for (int i=0; i<4; ++i) {
- vertices[i].x = 0;
- vertices[i].y = 0;
- vertices[i].t = -1;
- vertices[i].lifeSpan = 0;
- vertices[i].size = 0;
- vertices[i].endSize = 0;
- vertices[i].sx = 0;
- vertices[i].sy = 0;
- vertices[i].ax = 0;
- vertices[i].ay = 0;
- vertices[i].xx = 1;
- vertices[i].xy = 0;
- vertices[i].yx = 0;
- vertices[i].yy = 1;
- vertices[i].rotation = 0;
- vertices[i].rotationSpeed = 0;
- vertices[i].autoRotate = 0;
- }
-
- vertices[0].tx = 0;
- vertices[0].ty = 0;
-
- vertices[1].tx = 1;
- vertices[1].ty = 0;
-
- vertices[2].tx = 0;
- vertices[2].ty = 1;
-
- vertices[3].tx = 1;
- vertices[3].ty = 1;
-
- vertices += 4;
- }
-
- quint16 *indices = g->indexDataAsUShort();
- for (int i=0; i<m_count; ++i) {
- int o = i * 4;
- indices[0] = o;
- indices[1] = o + 1;
- indices[2] = o + 2;
- indices[3] = o + 1;
- indices[4] = o + 3;
- indices[5] = o + 2;
- indices += 6;
- }
-
- if (m_material) {
- delete m_material;
- m_material = 0;
- }
-
- if (!m_material)
- m_material = new DeformableParticleMaterial();
-
-
- m_material->texture = sceneGraphEngine()->createTextureFromImage(image);
- m_material->texture->setFiltering(QSGTexture::Linear);
-
- m_node = new QSGGeometryNode();
- m_node->setGeometry(g);
- m_node->setMaterial(m_material);
-
- m_last_particle = 0;
-
- return m_node;
-}
-
-QSGNode *DeformableParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
-{
- if(m_pleaseReset){
- if(m_node)
- delete m_node;
- if(m_material)
- delete m_material;
-
- m_node = 0;
- m_material = 0;
- m_pleaseReset = false;
- }
-
- if(m_system && m_system->isRunning())
- prepareNextFrame();
- if (m_node){
- update();
- m_node->markDirty(QSGNode::DirtyMaterial);
- }
-
- return m_node;
-}
-
-void DeformableParticle::prepareNextFrame()
-{
- if (m_node == 0){ //TODO: Staggered loading (as emitted)
- m_node = buildParticleNode();
- if(m_node == 0)
- return;
- }
- qint64 timeStamp = m_system->systemSync(this);
-
- qreal time = timeStamp / 1000.;
- m_material->timestamp = time;
-
-}
-
-
-void DeformableParticle::vertexCopy(DeformableParticleVertex &b,const ParticleVertex& a)
-{
- b.x = a.x - m_systemOffset.x();
- b.y = a.y - m_systemOffset.y();
- b.t = a.t;
- b.lifeSpan = a.lifeSpan;
- b.size = a.size;
- b.endSize = a.endSize;
- b.sx = a.sx;
- b.sy = a.sy;
- b.ax = a.ax;
- b.ay = a.ay;
-}
-
-void DeformableParticle::reload(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- DeformableParticleVertices *particles = (DeformableParticleVertices *) m_node->geometry()->vertexData();
-
- int pos = particleTypeIndex(d);
-
- DeformableParticleVertices &p = particles[pos];
-
- //Perhaps we could be more efficient?
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
- //TODO: Allow for change of deformation data?
-}
-
-void DeformableParticle::load(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- //Deformation Initialization
- DeformableParticleVertices *particles = (DeformableParticleVertices *) m_node->geometry()->vertexData();
- DeformableParticleVertices &p = particles[particleTypeIndex(d)];
- if(m_xVector){
- const QPointF &ret = m_xVector->sample(QPointF(d->pv.x, d->pv.y));
- p.v1.xx = p.v2.xx = p.v3.xx = p.v4.xx = ret.x();
- p.v1.xy = p.v2.xy = p.v3.xy = p.v4.xy = ret.y();
- }
- if(m_yVector){
- const QPointF &ret = m_yVector->sample(QPointF(d->pv.x, d->pv.y));
- p.v1.yx = p.v2.yx = p.v3.yx = p.v4.yx = ret.x();
- p.v1.yy = p.v2.yy = p.v3.yy = p.v4.yy = ret.y();
- }
- p.v1.rotation = p.v2.rotation = p.v3.rotation = p.v4.rotation =
- (m_rotation + (m_rotationVariation - 2*((qreal)rand()/RAND_MAX)*m_rotationVariation) ) * CONV;
- p.v1.rotationSpeed = p.v2.rotationSpeed = p.v3.rotationSpeed = p.v4.rotationSpeed =
- (m_rotationSpeed + (m_rotationSpeedVariation - 2*((qreal)rand()/RAND_MAX)*m_rotationSpeedVariation) ) * CONV;
- p.v1.autoRotate = p.v2.autoRotate = p.v3.autoRotate = p.v4.autoRotate = m_autoRotation?1.0:0.0;
-
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef DEFORMABLEPARTICLE_H
-#define DEFORMABLEPARTICLE_H
-#include "particle.h"
-#include "varyingvector.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class DeformableParticleMaterial;
-class QSGGeometryNode;
-struct DeformableParticleVertex;
-
-class DeformableParticle : public ParticleType
-{
- Q_OBJECT
- //Note that the particle centering can be less accurate with this one
- Q_PROPERTY(QUrl image READ image WRITE setImage NOTIFY imageChanged)
-
- Q_PROPERTY(qreal rotation READ rotation WRITE setRotation NOTIFY rotationChanged)
- Q_PROPERTY(qreal rotationVariation READ rotationVariation WRITE setRotationVariation NOTIFY rotationVariationChanged)
- Q_PROPERTY(qreal rotationSpeed READ rotationSpeed WRITE setRotationSpeed NOTIFY rotationSpeedChanged)
- Q_PROPERTY(qreal rotationSpeedVariation READ rotationSpeedVariation WRITE setRotationSpeedVariation NOTIFY rotationSpeedVariationChanged)
- //If true, then will face the direction of motion. Stacks with rotation, e.g. setting rotation
- //to 180 will lead to facing away from the direction of motion
- Q_PROPERTY(bool autoRotation READ autoRotation WRITE autoRotation NOTIFY autoRotationChanged)
-
- //###Call i/j? Makes more sense to those with vector calculus experience, and I could even add the cirumflex in QML?
- //xVector is the vector from the top-left point to the top-right point, and is multiplied by current size
- Q_PROPERTY(VaryingVector* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged)
- //yVector is the same, but top-left to bottom-left. The particle is always a parallelogram.
- Q_PROPERTY(VaryingVector* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged)
-
- //Do we want to add the tables?
- //Q_PROPERTY(QUrl colorTable READ colortable WRITE setColortable NOTIFY colortableChanged)
- //Q_PROPERTY(QUrl sizeTable READ sizetable WRITE setSizetable NOTIFY sizetableChanged)
- //Q_PROPERTY(QUrl opacityTable READ opacitytable WRITE setOpacitytable NOTIFY opacitytableChanged)
-
- //Does it need alpha? For convenience only, as images probably don't have it
- //Q_PROPERTY(qreal alpha READ alpha WRITE setAlpha NOTIFY alphaChanged)
- //Q_PROPERTY(qreal alphaVariation READ alphaVariation WRITE setAlphaVariation NOTIFY alphaVariationChanged)
-
-public:
- explicit DeformableParticle(QSGItem *parent = 0);
- virtual ~DeformableParticle(){}
-
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
- virtual void setCount(int c);
-
- QUrl image() const { return m_image; }
- void setImage(const QUrl &image);
-
- qreal rotation() const
- {
- return m_rotation;
- }
-
- bool autoRotation() const
- {
- return m_autoRotation;
- }
-
- VaryingVector* xVector() const
- {
- return m_xVector;
- }
-
- VaryingVector* yVector() const
- {
- return m_yVector;
- }
-
- qreal rotationVariation() const
- {
- return m_rotationVariation;
- }
-
- qreal rotationSpeed() const
- {
- return m_rotationSpeed;
- }
-
- qreal rotationSpeedVariation() const
- {
- return m_rotationSpeedVariation;
- }
-
-signals:
-
- void imageChanged();
- void rotationChanged(qreal arg);
-
- void autoRotationChanged(bool arg);
-
- void xVectorChanged(VaryingVector* arg);
-
- void yVectorChanged(VaryingVector* arg);
-
- void rotationVariationChanged(qreal arg);
-
- void rotationSpeedChanged(qreal arg);
-
- void rotationSpeedVariationChanged(qreal arg);
-
-public slots:
-void setRotation(qreal arg)
-{
- if (m_rotation != arg) {
- m_rotation = arg;
- emit rotationChanged(arg);
- }
-}
-
-void autoRotation(bool arg)
-{
- if (m_autoRotation != arg) {
- m_autoRotation = arg;
- emit autoRotationChanged(arg);
- }
-}
-
-void setXVector(VaryingVector* arg)
-{
- if (m_xVector != arg) {
- m_xVector = arg;
- emit xVectorChanged(arg);
- }
-}
-
-void setYVector(VaryingVector* arg)
-{
- if (m_yVector != arg) {
- m_yVector = arg;
- emit yVectorChanged(arg);
- }
-}
-
-void setRotationVariation(qreal arg)
-{
- if (m_rotationVariation != arg) {
- m_rotationVariation = arg;
- emit rotationVariationChanged(arg);
- }
-}
-
-void setRotationSpeed(qreal arg)
-{
- if (m_rotationSpeed != arg) {
- m_rotationSpeed = arg;
- emit rotationSpeedChanged(arg);
- }
-}
-
-void setRotationSpeedVariation(qreal arg)
-{
- if (m_rotationSpeedVariation != arg) {
- m_rotationSpeedVariation = arg;
- emit rotationSpeedVariationChanged(arg);
- }
-}
-
-protected:
- QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- void reset();
- void prepareNextFrame();
- QSGGeometryNode* buildParticleNode();
-private:
- void vertexCopy(DeformableParticleVertex &b,const ParticleVertex& a);
- bool m_do_reset;
-
- QUrl m_image;
- QSGGeometryNode *m_node;
- DeformableParticleMaterial *m_material;
-
- // derived values...
- int m_last_particle;
-
- qreal m_render_opacity;
- // generated vars
- qreal m_rotation;
- bool m_autoRotation;
- VaryingVector* m_xVector;
- VaryingVector* m_yVector;
- qreal m_rotationVariation;
- qreal m_rotationSpeed;
- qreal m_rotationSpeedVariation;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // DEFORMABLEPARTICLE_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "eternalaffector.h"
-#include <QDebug>
-
-QT_BEGIN_NAMESPACE
-
-EternalAffector::EternalAffector(QSGItem *parent) :
- ParticleAffector(parent)
-{
-}
-
-bool EternalAffector::affectParticle(ParticleData *d, qreal dt)
-{
- qreal target = (m_system->m_timeInt - m_targetLife)/1000.0;
- if(d->pv.t < target)
- d->pv.t = target;
- return true;
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "gravitationalsingularityaffector.h"
-#include <cmath>
-#include <QDebug>
-QT_BEGIN_NAMESPACE
-GravitationalSingularityAffector::GravitationalSingularityAffector(QSGItem *parent) :
- ParticleAffector(parent), m_strength(0.0), m_x(0), m_y(0)
-{
-}
-
-const qreal LIMIT = 200;
-qreal limit(qreal val){
- if(qAbs(val) > LIMIT){
- return val < 0 ? LIMIT * -1 : LIMIT;
- }else{
- return val;
- }
-}
-
-bool GravitationalSingularityAffector::affectParticle(ParticleData *d, qreal dt)
-{
- if(!m_strength)
- return false;
- qreal dx = m_x - d->curX();
- qreal dy = m_y - d->curY();
- qreal r = sqrt((dx*dx) + (dy*dy));
- if(r < 0.1 ){//Simulated event horizion - It's right on top of it, and will never escape again. just stick it here.
- d->pv.ax = 0;
- d->pv.ay = 0;
- d->pv.sx = 0;
- d->pv.sy = 0;
- d->pv.x = m_x;
- d->pv.y = m_y;
- return true;
- }else if(r < 50.0){//Too close, typical dt values are far too coarse for simulation. This may kill perf though
- int parts = floor(100.0/r);
- ParticleData* f = new ParticleData;//Fake, where it's all in real time for convenience
- f->pv.x = d->curX();
- f->pv.y = d->curY();
- f->pv.sx = limit(d->curSX());
- f->pv.sy = limit(d->curSY());
- f->pv.ax = d->pv.ax;
- f->pv.ay = d->pv.ay;
- subaffect(f, dt/parts, true);
- for(int i=1; i<parts; i++)
- subaffect(f, dt/parts, false);
-
- //Copy values from f, and turn into 'from start' values
- qreal t = (m_system->m_timeInt/1000.) - d->pv.t;
- qreal sy = limit(f->pv.sy) - t*f->pv.ay;
- qreal y = f->pv.y - t*sy - 0.5 * t*t*f->pv.ay;
- qreal sx = limit(f->pv.sx) - t*f->pv.ax;
- qreal x = f->pv.x - t*sx - 0.5 * t*t*f->pv.ax;
-
- d->pv.ay = f->pv.ay;
- d->pv.sy = sy;
- d->pv.y = y;
- d->pv.ax = f->pv.ax;
- d->pv.sx = sx;
- d->pv.x = x;
- return true;
- }
- qreal theta = atan2(dy,dx);
- qreal ds = (m_strength / (r*r)) * dt;
- dx = ds * cos(theta);
- dy = ds * sin(theta);
- d->setInstantaneousSX(limit(d->pv.sx + dx));
- d->setInstantaneousSY(limit(d->pv.sy + dy));
- return true;
-}
-
-const qreal EPSILON = 0.1;
-bool fuzzyCompare(qreal a, qreal b)
-{
- //Not using qFuzzyCompare because I want control of epsilon
- return (a >= b - EPSILON && a <= b + EPSILON);
-}
-
-bool fuzzyLess(qreal a, qreal b)
-{
- //Not using qFuzzyCompare because I want control of epsilon
- return a <= b + EPSILON;
-}
-
-bool fuzzyMore(qreal a, qreal b)
-{
- //Not using qFuzzyCompare because I want control of epsilon
- return a >= b - EPSILON;
-}
-
-bool lineIntersect(qreal x1, qreal y1, qreal x2, qreal y2, qreal x3, qreal y3)
-{
- if(x3 < qMin(x1,x2) || x3 > qMax(x1,x2) || y3 < qMin(y1,y2) || y3 > qMax(y1,y2))
- return false;
- qreal m,c;
- m = (y2-y1) / (x2-x1);
- c = y1 - m*x1;
- return (fuzzyCompare(y3, m*x3 + c));
-}
-
-void GravitationalSingularityAffector::subaffect(ParticleData *d, qreal dt, bool first)
-{
- if(!first){
- qreal nextX = d->pv.x + d->pv.sx * dt + d->pv.ax * dt * dt * 0.5;
- qreal nextY = d->pv.y + d->pv.sy * dt + d->pv.ay * dt * dt * 0.5;
- if(lineIntersect(d->pv.x, d->pv.y, nextX, nextY, m_x, m_y)){
- d->pv.ax = 0;
- d->pv.ay = 0;
- d->pv.sx = 0;
- d->pv.sy = 0;
- d->pv.x = m_x;
- d->pv.y = m_y;
- return;
- //Passed center - the near infinite forces cancel out
-// d->pv.x = m_x + m_x - d->pv.x;
-// d->pv.y = m_y + m_y - d->pv.y;
-// d->pv.sx *= -1;
-// d->pv.sy *= -1;
-// return;
- }
- //Simulate advancing a dt
- d->pv.x = nextX;
- d->pv.y = nextY;
- d->pv.sx += d->pv.ax * dt;
- d->pv.sy += d->pv.ay * dt;
- }
- qreal dx = m_x - d->pv.x;
- qreal dy = m_y - d->pv.y;
- qreal r = sqrt((dx*dx) + (dy*dy));
- if(!r)
- return;
- qreal theta = atan2(dy,dx);
- qreal ds = (m_strength / (r*r)) * dt;
- dx = ds * cos(theta);
- dy = ds * sin(theta);
- d->pv.sx = d->pv.sx + dx;
- d->pv.sy = d->pv.sy + dy;
-}
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef GRAVITATIONALSINGULARITYAFFECTOR_H
-#define GRAVITATIONALSINGULARITYAFFECTOR_H
-#include "particleaffector.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-
-class GravitationalSingularityAffector : public ParticleAffector
-{
- Q_OBJECT
- Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
- Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged)
- Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged)
-public:
- explicit GravitationalSingularityAffector(QSGItem *parent = 0);
-
- qreal strength() const
- {
- return m_strength;
- }
-
- qreal x() const
- {
- return m_x;
- }
-
- qreal y() const
- {
- return m_y;
- }
-protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
- void subaffect(ParticleData *d, qreal dt, bool first);
-signals:
-
- void strengthChanged(qreal arg);
-
- void xChanged(qreal arg);
-
- void yChanged(qreal arg);
-
-public slots:
-
-void setStrength(qreal arg)
-{
- if (m_strength != arg) {
- m_strength = arg;
- emit strengthChanged(arg);
- }
-}
-
-void setX(qreal arg)
-{
- if (m_x != arg) {
- m_x = arg;
- emit xChanged(arg);
- }
-}
-
-void setY(qreal arg)
-{
- if (m_y != arg) {
- m_y = arg;
- emit yChanged(arg);
- }
-}
-
-private:
-qreal m_strength;
-qreal m_x;
-qreal m_y;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // GRAVITATIONALSINGULARITYAFFECTOR_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "V1/qdeclarativeparticles_p.h"
-#include "pluginmain.h"
-#include "spritestate.h"
-#include "spriteengine.h"
-#include "particleaffector.h"
-#include "wanderaffector.h"
-//#include "rockingaffector.h"
-//#include "scalingaffector.h"
-#include "resetaffector.h"
-#include "gravityaffector.h"
-#include "driftaffector.h"
-#include "gravitationalsingularityaffector.h"
-#include "frictionaffector.h"
-#include "meanderaffector.h"
-#include "attractoraffector.h"
-#include "speedlimitaffector.h"
-#include "killaffector.h"
-//#include "zoneaffector.h"
-//#include "toggleaffector.h"
-#include "spritegoalaffector.h"
-#include "swarmaffector.h"
-#include "turbulenceaffector.h"
-#include "eternalaffector.h"
-#include "particlesystem.h"
-#include "particleemitter.h"
-//#include "spriteemitter.h"
-#include "trailsemitter.h"
-#include "burstemitter.h"
-#include "particle.h"
-#include "coloredparticle.h"
-#include "spriteparticle.h"
-//#include "modelparticle.h"
-#include "dataparticle.h"
-#include "itemparticle.h"
-#include "superparticle.h"
-#include "ultraparticle.h"
-//#include "pairedparticle.h"
-#include "spriteimage.h"
-#include "followemitter.h"
-#include "particleextruder.h"
-#include "ellipseextruder.h"
-#include "lineextruder.h"
-#include "maskextruder.h"
-#include "varyingvector.h"
-#include "pointvector.h"
-#include "angledvector.h"
-#include "directedvector.h"
-//#include "followaffector.h"
-#include "deformableparticle.h"
-#include "pictureaffector.h"
-
-QT_BEGIN_NAMESPACE
-
-void ParticlesPlugin::registerTypes(const char *uri)
-{
- Q_ASSERT(QLatin1String(uri) == QLatin1String("Qt.labs.particles"));
-
- qmlRegisterType<QDeclarativeParticles>(uri, 1, 0, "Particles");
- qmlRegisterType<QDeclarativeParticleMotion>(uri,1,0,"ParticleMotion");
- qmlRegisterType<QDeclarativeParticleMotionGravity>(uri,1,0,"ParticleMotionGravity");
- qmlRegisterType<QDeclarativeParticleMotionLinear>(uri,1,0,"ParticleMotionLinear");
- qmlRegisterType<QDeclarativeParticleMotionWander>(uri,1,0,"ParticleMotionWander");
- qmlRegisterType<SpriteState>(uri, 2, 0, "Sprite");
- qmlRegisterType<SpriteEngine>(uri, 2, 0, "SpriteEngine");
- qmlRegisterType<SpriteImage>(uri, 2, 0, "SpriteImage");
-
- qmlRegisterType<ParticleSystem>(uri, 2, 0, "ParticleSystem");
-
- qmlRegisterType<ParticleType>(uri, 2, 0, "Particle");
- qmlRegisterType<ColoredParticle>(uri, 2, 0, "ColoredParticle");
- qmlRegisterType<SpriteParticle>(uri, 2, 0, "SpriteParticle");
- //qmlRegisterType<ModelParticle>(uri, 2, 0, "ModelParticle");
- qmlRegisterType<DataParticle>(uri, 2, 0, "DataParticle");
- qmlRegisterType<ItemParticle>(uri, 2, 0, "ItemParticle");
- //qmlRegisterType<PairedParticle>(uri, 2, 0, "PairedParticle");
- qmlRegisterType<DeformableParticle>(uri, 2, 0, "DeformableParticle");
- qmlRegisterType<SuperParticle>(uri, 2, 0, "SuperParticle");
- qmlRegisterType<UltraParticle>(uri, 2, 0, "UltraParticle");
-
- qmlRegisterType<ParticleEmitter>(uri, 2, 0, "ParticleEmitter");
- qmlRegisterType<TrailsEmitter>(uri, 2, 0, "TrailEmitter");
- qmlRegisterType<TrailsEmitter>(uri, 2, 0, "BurstEmitter");
-
- qmlRegisterType<FollowEmitter>(uri, 2, 0, "FollowEmitter");
- qmlRegisterType<ParticleExtruder>(uri, 2, 0, "Box");
- qmlRegisterType<EllipseExtruder>(uri, 2, 0, "Ellipse");
- qmlRegisterType<LineExtruder>(uri, 2, 0, "Line");
- qmlRegisterType<MaskExtruder>(uri, 2, 0, "Mask");
-
- qmlRegisterType<VaryingVector>(uri, 2, 0, "NullVector");
- qmlRegisterType<PointVector>(uri, 2, 0, "PointVector");
- qmlRegisterType<AngledVector>(uri, 2, 0, "AngleVector");
- qmlRegisterType<DirectedVector>(uri, 2, 0, "DirectedVector");
-
- qmlRegisterType<ParticleAffector>(uri, 2, 0, "ParticleAffector");
- qmlRegisterType<WanderAffector>(uri, 2, 0, "Wander");
- //qmlRegisterType<ScalingAffector>(uri, 2, 0, "Scale");
- //qmlRegisterType<RockingAffector>(uri, 2, 0, "Rocking");
- qmlRegisterType<DriftAffector>(uri, 2, 0, "Drift");
- qmlRegisterType<FrictionAffector>(uri, 2, 0, "Friction");
- qmlRegisterType<GravitationalSingularityAffector>(uri, 2, 0, "GravitationalSingularity");
- qmlRegisterType<AttractorAffector>(uri, 2, 0, "Attractor");
- qmlRegisterType<MeanderAffector>(uri, 2, 0, "Meander");
- qmlRegisterType<SpeedLimitAffector>(uri, 2, 0, "SpeedLimit");
- qmlRegisterType<GravityAffector>(uri, 2, 0, "Gravity");
- qmlRegisterType<EternalAffector>(uri, 2, 0, "Stasis");
- qmlRegisterType<ResetAffector>(uri, 2, 0, "Reset");
- //qmlRegisterType<ZoneAffector>(uri, 2, 0, "Zone");
- //qmlRegisterType<ToggleAffector>(uri, 2, 0, "Toggle");
- qmlRegisterType<KillAffector>(uri, 2, 0, "Kill");
- qmlRegisterType<SpriteGoalAffector>(uri, 2, 0, "SpriteGoal");
- qmlRegisterType<SwarmAffector>(uri, 2, 0 , "Swarm");
- qmlRegisterType<TurbulenceAffector>(uri, 2, 0 , "Turbulence");
- qmlRegisterType<PictureAffector>(uri, 2, 0, "Picture");
-}
-
-QT_END_NAMESPACE
-
-Q_EXPORT_PLUGIN2(Particles, QT_PREPEND_NAMESPACE(ParticlesPlugin))
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "meanderaffector.h"
-
-QT_BEGIN_NAMESPACE
-
-MeanderAffector::MeanderAffector(QSGItem *parent) :
- ParticleAffector(parent)
-{
-}
-
-bool MeanderAffector::affectParticle(ParticleData *data, qreal dt)
-{
- if(!m_xDrift && !m_yDrift)
- return false;
- qreal dx = (((qreal)qrand() / (qreal)RAND_MAX) - 0.5) * 2 * m_xDrift * dt;
- qreal dy = (((qreal)qrand() / (qreal)RAND_MAX) - 0.5) * 2 * m_yDrift * dt;
- if(dx)
- data->setInstantaneousAX(data->pv.ax + dx);
- if(dy)
- data->setInstantaneousAY(data->pv.ay + dy);
-
- return true;
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef MEANDERAFFECTOR_H
-#define MEANDERAFFECTOR_H
-#include "particleaffector.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-
-class MeanderAffector : public ParticleAffector
-{
- Q_OBJECT
- //Like drift, but affects da/dt instead of ds/dt
- Q_PROPERTY(qreal xDrift READ xDrift WRITE setXDrift NOTIFY xDriftChanged)
- Q_PROPERTY(qreal yDrift READ yDrift WRITE setYDrift NOTIFY yDriftChanged)
-public:
- explicit MeanderAffector(QSGItem *parent = 0);
-
- qreal xDrift() const
- {
- return m_xDrift;
- }
-
- qreal yDrift() const
- {
- return m_yDrift;
- }
-protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
-signals:
-
- void xDriftChanged(qreal arg);
-
- void yDriftChanged(qreal arg);
-
-public slots:
-
- void setXDrift(qreal arg)
- {
- if (m_xDrift != arg) {
- m_xDrift = arg;
- emit xDriftChanged(arg);
- }
- }
- void setYDrift(qreal arg)
- {
- if (m_yDrift != arg) {
- m_yDrift = arg;
- emit yDriftChanged(arg);
- }
- }
-
-private:
- qreal m_xDrift;
- qreal m_yDrift;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // MEANDERAFFECTOR_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtDeclarative/qdeclarativeextensionplugin.h>
+#include <QtDeclarative/qdeclarative.h>
+
+#include "V1/qdeclarativeparticles_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class QParticlesQmlModule : public QDeclarativeExtensionPlugin
+{
+ Q_OBJECT
+public:
+ virtual void registerTypes(const char *uri)
+ {
+ Q_ASSERT(QLatin1String(uri) == QLatin1String("Qt.labs.particles"));
+ qmlRegisterType<QDeclarativeParticleMotion>(uri,1,0,"ParticleMotion");
+ qmlRegisterType<QDeclarativeParticleMotionGravity>(uri,1,0,"ParticleMotionGravity");
+ qmlRegisterType<QDeclarativeParticleMotionLinear>(uri,1,0,"ParticleMotionLinear");
+ qmlRegisterType<QDeclarativeParticleMotionWander>(uri,1,0,"ParticleMotionWander");
+ qmlRegisterType<QDeclarativeParticles>(uri,1,0,"Particles");
+ }
+};
+
+QT_END_NAMESPACE
+
+#include "particles.moc"
+
+Q_EXPORT_PLUGIN2(qmlparticlesplugin, QT_PREPEND_NAMESPACE(QParticlesQmlModule));
+
include(../qimportbase.pri)
HEADERS += \
- V1/qdeclarativeparticles_p.h \
- spritestate.h \
- pluginmain.h \
- particleaffector.h \
- wanderaffector.h \
- #rockingaffector.h \
- #scalingaffector.h \
- driftaffector.h \
- particleemitter.h \
- particlesystem.h \
- trailsemitter.h \
- #spriteemitter.h \
- particle.h \
- coloredparticle.h \
- spriteparticle.h \
- spritegoalaffector.h \
- #zoneaffector.h \
- frictionaffector.h \
- gravitationalsingularityaffector.h \
- killaffector.h \
- speedlimitaffector.h \
- spriteengine.h \
- gravityaffector.h \
- attractoraffector.h \
- meanderaffector.h \
- #toggleaffector.h \
- spriteimage.h \
- #pairedparticle.h \
- followemitter.h \
- swarmaffector.h \
- turbulenceaffector.h \
- particleextruder.h \
- ellipseextruder.h \
- maskextruder.h \
- varyingvector.h \
- pointvector.h \
- angledvector.h \
- directedvector.h \
- #modelparticle.h \
- eternalaffector.h \
- lineextruder.h \
- resetaffector.h \
- deformableparticle.h \
- pictureaffector.h \
- superparticle.h \
- ultraparticle.h \
- burstemitter.h \
- dataparticle.h \
- itemparticle.h
+ V1/qdeclarativeparticles_p.h
SOURCES += \
- V1/qdeclarativeparticles.cpp \
- spritestate.cpp \
- main.cpp \
- particleaffector.cpp \
- wanderaffector.cpp \
- #rockingaffector.cpp \
- #scalingaffector.cpp \
- driftaffector.cpp \
- particleemitter.cpp \
- particlesystem.cpp \
- trailsemitter.cpp \
- #spriteemitter.cpp \
- particle.cpp \
- coloredparticle.cpp \
- spriteparticle.cpp \
- spritegoalaffector.cpp \
- #zoneaffector.cpp \
- frictionaffector.cpp \
- gravitationalsingularityaffector.cpp \
- killaffector.cpp \
- speedlimitaffector.cpp \
- spriteengine.cpp \
- gravityaffector.cpp \
- attractoraffector.cpp \
- meanderaffector.cpp \
- #toggleaffector.cpp \
- spriteimage.cpp \
- #pairedparticle.cpp \
- followemitter.cpp \
- swarmaffector.cpp \
- turbulenceaffector.cpp \
- particleextruder.cpp \
- ellipseextruder.cpp \
- maskextruder.cpp \
- varyingvector.cpp \
- pointvector.cpp \
- angledvector.cpp \
- directedvector.cpp \
- #modelparticle.cpp \
- eternalaffector.cpp \
- lineextruder.cpp \
- resetaffector.cpp \
- deformableparticle.cpp \
- pictureaffector.cpp \
- superparticle.cpp \
- ultraparticle.cpp \
- burstemitter.cpp \
- dataparticle.cpp \
- itemparticle.cpp
-
-QT += declarative opengl
-#Because we use QDeclarativePixmapCache once...
-QT += core-private gui-private declarative-private script-private
+ particles.cpp \
+ V1/qdeclarativeparticles.cpp
+QT += declarative opengl core gui declarative-private core-private gui-private
OTHER_FILES += \
qmldir
-RESOURCES += \
- spriteparticles.qrc
-
DESTDIR = $$QT.declarative.imports/$$TARGETPATH
target.path = $$[QT_INSTALL_IMPORTS]/$$TARGETPATH
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "pictureaffector.h"
-#include "coloredparticle.h"
-#include <QDebug>
-#include <private/qsgtexture_p.h>
-#include <private/qdeclarativepixmapcache_p.h>
-
-QT_BEGIN_NAMESPACE
-
-PictureAffector::PictureAffector(QSGItem *parent) :
- ParticleAffector(parent), m_pix(0)
-{
- m_needsReset = true;
-}
-
-void PictureAffector::reset(int systemIdx)
-{
- ParticleAffector::reset(systemIdx);
-}
-
-void PictureAffector::startLoadImage()
-{
- if(m_pix)
- m_pix->clear();
- else
- m_pix = new QDeclarativePixmap();
- m_pix->load(qmlEngine(this), m_image, QDeclarativePixmap::Cache);
- if(m_pix->isReady())
- loadImage();
- else
- m_pix->connectFinished(this, SLOT(loadImage()));
-}
-void PictureAffector::loadImage()
-{
- m_loadedImage = m_pix->pixmap().toImage();
- if(m_loadedImage.isNull())
- qWarning() << "PictureAffector could not load picture " << m_image;
-}
-
-bool PictureAffector::affectParticle(ParticleData *d, qreal dt)
-{
- Q_UNUSED(dt);
- if(!width() || !height()){
- qWarning() << "PictureAffector needs a size";
- return false;
- }
-
- if(m_loadedImage.isNull())
- return false;
-
- if(m_loadedImage.size()!=QSize(width(), height()))
- m_loadedImage = m_loadedImage.scaled(width(), height());//TODO: Aspect Ratio Control?
-
- bool affected = false;
- QPoint pos = QPoint(d->curX() - m_offset.x(), d->curY() - m_offset.y());
- if(!QRect(0,0,width(),height()).contains(pos)){
- //XXX: Just a debugging helper, as I don't think it can get here.
- qWarning() << "PictureAffector gives up.";
- return false;
- }
- Color4ub c;
- QRgb col = m_loadedImage.pixel(pos);
- c.a = qAlpha(col);
- c.b = qBlue(col);
- c.g = qGreen(col);
- c.r = qRed(col);
- foreach(ParticleType *p, m_system->m_groupData[d->group]->types){
- if(qobject_cast<ColoredParticle*>(p)){
- ColoredParticle* cp = qobject_cast<ColoredParticle*>(p);
- cp->reloadColor(c, d);
- affected = true;
- }
- }
-
- return affected;//Doesn't affect particle data, but necessary for onceOff
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef PICTUREAFFECTOR_H
-#define PICTUREAFFECTOR_H
-#include "particleaffector.h"
-#include <QDebug>
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class QDeclarativePixmap;
-class PictureAffector : public ParticleAffector
-{
- Q_OBJECT
- //Usually want to use "particles" to target just colored stuff, and save performance
- //Use onceOff (inherited) to determine if this is an emitter modification or a more constant enforcer
- Q_PROPERTY(QUrl image READ image WRITE setImage NOTIFY imageChanged)
- //TODO: Bool smooth, where it interpolates
-public:
- explicit PictureAffector(QSGItem *parent = 0);
-
- QUrl image() const
- {
- return m_image;
- }
-
-protected:
- virtual void reset(int systemIdx);
- virtual bool affectParticle(ParticleData *d, qreal dt);
-signals:
-
- void imageChanged(QUrl arg);
-
-public slots:
- void setImage(QUrl arg)
- {
- if (m_image != arg) {
- m_image = arg;
- startLoadImage();
- emit imageChanged(arg);
- }
- }
-
-private slots:
- void loadImage();
-private:
- void startLoadImage();
- QUrl m_image;
- QDeclarativePixmap* m_pix;
- QImage m_loadedImage;
-};
-
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif // PICTUREAFFECTOR_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "resetaffector.h"
-#include <cmath>
-QT_BEGIN_NAMESPACE
-ResetAffector::ResetAffector(QSGItem *parent) :
- ParticleAffector(parent)
-{
-}
-
-void ResetAffector::reset(int idx)
-{
- ParticleAffector::reset(idx);
- if(m_data[idx])
- delete m_data[idx];
- m_data.insert(idx, 0);//TODO: Either load with data now, or get data next tick whether active or not
-}
-
-bool ResetAffector::affectParticle(ParticleData *d, qreal dt)
-{
- TrajectoryData* trajectory;
- if(m_data[d->systemIndex]){
- trajectory = m_data[d->systemIndex];
- //TODO: Faster to calculate once (not 4 times)
- d->setInstantaneousSX(trajectory->sx);
- d->setInstantaneousSY(trajectory->sy);
- d->setInstantaneousAX(trajectory->ax);
- d->setInstantaneousAY(trajectory->ay);
- }else{
- trajectory = new TrajectoryData;
- }
- trajectory->sx = d->pv.sx;
- trajectory->sy = d->pv.sy;
- trajectory->ax = d->pv.ax;
- trajectory->ay = d->pv.ay;
- m_data.insert(d->systemIndex, trajectory);//overwrites
- return true;
-}
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "speedlimitaffector.h"
-#include <cmath>
-#include <QDebug>
-
-QT_BEGIN_NAMESPACE
-
-SpeedLimitAffector::SpeedLimitAffector(QSGItem *parent) :
- ParticleAffector(parent), m_speedLimit(-1)
-{
-}
-
-bool SpeedLimitAffector::affectParticle(ParticleData *d, qreal dt){
- Q_UNUSED(dt);
- if(m_speedLimit <= 0)
- return false;
-
- qreal x = d->curSX();
- qreal y = d->curSY();
- qreal s = sqrt(x*x + y*y);
- if(s <= m_speedLimit)
- return false;
-
-
- if(s >= m_speedLimit*1.01){
- qreal theta = atan2(y,x);
- d->setInstantaneousSX(m_speedLimit * cos(theta));
- d->setInstantaneousSY(m_speedLimit * sin(theta));
- }
-
- d->setInstantaneousAY(0);
- d->setInstantaneousAX(0);
-
- return true;
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "spriteparticle.h"
-#include "spritestate.h"
-#include "spriteengine.h"
-#include "particleemitter.h"
-#include <private/qsgcontext_p.h>
-#include <private/qsgadaptationlayer_p.h>
-#include <qsgnode.h>
-#include <qsgtexturematerial.h>
-#include <qsgengine.h>
-#include <qsgtexture.h>
-#include <QFile>
-#include <cmath>
-#include <qmath.h>
-#include <QDebug>
-
-QT_BEGIN_NAMESPACE
-
-class SpriteParticlesMaterial : public QSGMaterial
-{
-public:
- SpriteParticlesMaterial();
- virtual ~SpriteParticlesMaterial();
- virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
- virtual QSGMaterialShader *createShader() const;
- virtual int compare(const QSGMaterial *other) const
- {
- return this - static_cast<const SpriteParticlesMaterial *>(other);
- }
-
- QSGTexture *texture;
-
- qreal timestamp;
- int framecount;
- int animcount;
-};
-
-SpriteParticlesMaterial::SpriteParticlesMaterial()
- : timestamp(0)
- , framecount(1)
- , animcount(1)
-{
- setFlag(Blending, true);
-}
-
-SpriteParticlesMaterial::~SpriteParticlesMaterial()
-{
- delete texture;
-}
-
-class SpriteParticlesMaterialData : public QSGMaterialShader
-{
-public:
- SpriteParticlesMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
- {
- QFile vf(vertexFile ? vertexFile : ":resources/spritevertex.shader");
- vf.open(QFile::ReadOnly);
- m_vertex_code = vf.readAll();
-
- QFile ff(fragmentFile ? fragmentFile : ":resources/spritefragment.shader");
- ff.open(QFile::ReadOnly);
- m_fragment_code = ff.readAll();
-
- Q_ASSERT(!m_vertex_code.isNull());
- Q_ASSERT(!m_fragment_code.isNull());
- }
-
- void deactivate() {
- QSGMaterialShader::deactivate();
-
- for (int i=0; i<8; ++i) {
- program()->setAttributeArray(i, GL_FLOAT, chunkOfBytes, 1, 0);
- }
- }
-
- virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
- {
- SpriteParticlesMaterial *m = static_cast<SpriteParticlesMaterial *>(newEffect);
- m->texture->bind();
-
- program()->setUniformValue(m_opacity_id, state.opacity());
- program()->setUniformValue(m_timestamp_id, (float) m->timestamp);
- program()->setUniformValue(m_framecount_id, (float) m->framecount);
- program()->setUniformValue(m_animcount_id, (float) m->animcount);
-
- if (state.isMatrixDirty())
- program()->setUniformValue(m_matrix_id, state.combinedMatrix());
- }
-
- virtual void initialize() {
- m_matrix_id = program()->uniformLocation("matrix");
- m_opacity_id = program()->uniformLocation("opacity");
- m_timestamp_id = program()->uniformLocation("timestamp");
- m_framecount_id = program()->uniformLocation("framecount");
- m_animcount_id = program()->uniformLocation("animcount");
- }
-
- virtual const char *vertexShader() const { return m_vertex_code.constData(); }
- virtual const char *fragmentShader() const { return m_fragment_code.constData(); }
-
- virtual char const *const *attributeNames() const {
- static const char *attr[] = {
- "vPos",
- "vTex",
- "vData",
- "vVec",
- "vAnimData",
- 0
- };
- return attr;
- }
-
- virtual bool isColorTable() const { return false; }
-
- int m_matrix_id;
- int m_opacity_id;
- int m_timestamp_id;
- int m_framecount_id;
- int m_animcount_id;
-
- QByteArray m_vertex_code;
- QByteArray m_fragment_code;
-
- static float chunkOfBytes[1024];
-};
-float SpriteParticlesMaterialData::chunkOfBytes[1024];
-
-QSGMaterialShader *SpriteParticlesMaterial::createShader() const
-{
- return new SpriteParticlesMaterialData;
-}
-
-struct SpriteParticleVertex {
- float x;
- float y;
- float tx;
- float ty;
- float t;
- float lifeSpan;
- float size;
- float endSize;
- float sx;
- float sy;
- float ax;
- float ay;
- float animIdx;
- float frameDuration;
- float frameCount;
- float animT;
-};
-
-struct SpriteParticleVertices {
- SpriteParticleVertex v1;
- SpriteParticleVertex v2;
- SpriteParticleVertex v3;
- SpriteParticleVertex v4;
-};
-
-SpriteParticle::SpriteParticle(QSGItem *parent) :
- ParticleType(parent)
- , m_node(0)
- , m_material(0)
- , m_spriteEngine(0)
-{
- setFlag(ItemHasContents);
- }
-QDeclarativeListProperty<SpriteState> SpriteParticle::sprites()
-{
- return QDeclarativeListProperty<SpriteState>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
-}
-
-void SpriteParticle::createEngine()
-{
- if(m_spriteEngine)
- delete m_spriteEngine;
- if(m_sprites.count())
- m_spriteEngine = new SpriteEngine(m_sprites, this);
- else
- m_spriteEngine = 0;
- reset();//###this is probably out of updatePaintNode and shouldn't be
-}
-
-void SpriteParticle::setCount(int c)
-{
- ParticleType::setCount(c);
- m_pleaseReset = true;
-}
-
-static QSGGeometry::Attribute SpriteParticle_Attributes[] = {
- { 0, 2, GL_FLOAT }, // Position
- { 1, 2, GL_FLOAT }, // TexCoord
- { 2, 4, GL_FLOAT }, // Data
- { 3, 4, GL_FLOAT }, // Vectors
- { 4, 4, GL_FLOAT } // Colors
-};
-
-static QSGGeometry::AttributeSet SpriteParticle_AttributeSet =
-{
- 5, // Attribute Count
- (2 + 2 + 4 + 4 + 4) * sizeof(float),
- SpriteParticle_Attributes
-};
-
-
-
-QSGGeometryNode* SpriteParticle::buildParticleNode()
-{
- if (m_count * 4 > 0xffff) {
- qWarning() << "SpriteParticle: too many particles...";
- return 0;
- }
-
- if (m_count * 4 == 0) {
- qWarning() << "SpriteParticle: No particles...";
- return 0;
- }
-
- if (!m_spriteEngine) {
- qWarning() << "SpriteParticle: No sprite engine...";
- return 0;
- }
-
- if (m_material) {
- delete m_material;
- m_material = 0;
- }
-
- m_material = new SpriteParticlesMaterial();
-
- QImage image = m_spriteEngine->assembledImage();
- if(image.isNull())
- return 0;
- m_material->texture = sceneGraphEngine()->createTextureFromImage(image);
- m_material->texture->setFiltering(QSGTexture::Linear);
- m_material->framecount = m_spriteEngine->maxFrames();
- m_spriteEngine->setCount(m_count);
-
- int vCount = m_count * 4;
- int iCount = m_count * 6;
- QSGGeometry *g = new QSGGeometry(SpriteParticle_AttributeSet, vCount, iCount);
- g->setDrawingMode(GL_TRIANGLES);
-
- SpriteParticleVertex *vertices = (SpriteParticleVertex *) g->vertexData();
- for (int p=0; p<m_count; ++p) {
-
- for (int i=0; i<4; ++i) {
- vertices[i].x = 0;
- vertices[i].y = 0;
- vertices[i].t = -1;
- vertices[i].lifeSpan = -1;
- vertices[i].size = 0;
- vertices[i].endSize = 0;
- vertices[i].sx = 0;
- vertices[i].sy = 0;
- vertices[i].ax = 0;
- vertices[i].ay = 0;
- vertices[i].animIdx = 0;
- vertices[i].frameDuration = 1;
- vertices[i].frameCount = 1;
- vertices[i].animT = -1;
-
- }
-
- vertices[0].tx = 0;
- vertices[0].ty = 0;
-
- vertices[1].tx = 1.0;
- vertices[1].ty = 0;
-
- vertices[2].tx = 0;
- vertices[2].ty = 1.0;
-
- vertices[3].tx = 1.0;
- vertices[3].ty = 1.0;
-
- vertices += 4;
- }
-
- quint16 *indices = g->indexDataAsUShort();
- for (int i=0; i<m_count; ++i) {
- int o = i * 4;
- indices[0] = o;
- indices[1] = o + 1;
- indices[2] = o + 2;
- indices[3] = o + 1;
- indices[4] = o + 3;
- indices[5] = o + 2;
- indices += 6;
- }
-
-
- m_node = new QSGGeometryNode();
- m_node->setGeometry(g);
- m_node->setMaterial(m_material);
- m_last_particle = 0;
- return m_node;
-}
-
-void SpriteParticle::vertexCopy(SpriteParticleVertex &b,const ParticleVertex& a)
-{
- b.x = a.x + m_systemOffset.x();
- b.y = a.y + m_systemOffset.y();
- b.t = a.t;
- b.lifeSpan = a.lifeSpan;
- b.size = a.size;
- b.endSize = a.endSize;
- b.sx = a.sx;
- b.sy = a.sy;
- b.ax = a.ax;
- b.ay = a.ay;
-}
-
-void SpriteParticle::load(ParticleData *d)
-{
- if (m_node == 0) //error creating node
- return;
-
- SpriteParticleVertices *particles = (SpriteParticleVertices *) m_node->geometry()->vertexData();
- int pos = particleTypeIndex(d);
- SpriteParticleVertices &p = particles[pos];
-
- // Initial Sprite State
- m_spriteEngine->startSprite(pos);
- p.v1.animT = p.v2.animT = p.v3.animT = p.v4.animT = p.v1.t;
- p.v1.animIdx = p.v2.animIdx = p.v3.animIdx = p.v4.animIdx = 0;
- p.v1.frameCount = p.v2.frameCount = p.v3.frameCount = p.v4.frameCount = m_spriteEngine->spriteFrames(pos);
- p.v1.frameDuration = p.v2.frameDuration = p.v3.frameDuration = p.v4.frameDuration = m_spriteEngine->spriteDuration(pos);
-
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-
-}
-
-void SpriteParticle::reload(ParticleData *d)
-{
- if (m_node == 0) //error creating node
- return;
-
- SpriteParticleVertices *particles = (SpriteParticleVertices *) m_node->geometry()->vertexData();
- int pos = particleTypeIndex(d);
- SpriteParticleVertices &p = particles[pos];
-
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-
-QSGNode *SpriteParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
-{
- if(m_pleaseReset){
- if(m_node)
- delete m_node;
- if(m_material)
- delete m_material;
-
- m_node = 0;
- m_material = 0;
- m_pleaseReset = false;
- }
- if(m_system&& m_system->isRunning())
- prepareNextFrame();
- if (m_node){
- update();
- m_node->markDirty(QSGNode::DirtyMaterial);
- }
-
- return m_node;
-}
-
-void SpriteParticle::prepareNextFrame()
-{
- if (m_node == 0){ //TODO: Staggered loading (as emitted) (is it just moving this check to load()?)
- m_node = buildParticleNode();
- if(m_node == 0)
- return;
- }
- qint64 timeStamp = m_system->systemSync(this);
-
-
- qreal time = timeStamp / 1000.;
- m_material->timestamp = time;
- m_material->animcount = m_spriteEngine->spriteCount();
-
- //Advance State
- SpriteParticleVertices *particles = (SpriteParticleVertices *) m_node->geometry()->vertexData();
- m_spriteEngine->updateSprites(timeStamp);
- for(int i=0; i<m_count; i++){
- SpriteParticleVertices &p = particles[i];
- int curIdx = m_spriteEngine->spriteState(i);
- if(curIdx != p.v1.animIdx){
- p.v1.animIdx = p.v2.animIdx = p.v3.animIdx = p.v4.animIdx = curIdx;
- p.v1.animT = p.v2.animT = p.v3.animT = p.v4.animT = m_spriteEngine->spriteStart(i)/1000.0;
- p.v1.frameCount = p.v2.frameCount = p.v3.frameCount = p.v4.frameCount = m_spriteEngine->spriteFrames(i);
- p.v1.frameDuration = p.v2.frameDuration = p.v3.frameDuration = p.v4.frameDuration = m_spriteEngine->spriteDuration(i);
- }
- }
-}
-
-void SpriteParticle::reset()
-{
- ParticleType::reset();
- m_pleaseReset = true;
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-<RCC>
- <qresource prefix="/">
- <file>resources/spritefragment.shader</file>
- <file>resources/spritevertex.shader</file>
- <file>resources/ctfragment.shader</file>
- <file>resources/ctvertex.shader</file>
- <file>resources/trailsfragment.shader</file>
- <file>resources/trailsvertex.shader</file>
- <file>resources/spriteimagefragment.shader</file>
- <file>resources/spriteimagevertex.shader</file>
- <file>resources/identitytable.png</file>
- <file>resources/defaultFadeInOut.png</file>
- <file>resources/deformablefragment.shader</file>
- <file>resources/deformablevertex.shader</file>
- <file>resources/ultravertex.shader</file>
- <file>resources/ultrafragment.shader</file>
- <file>resources/supervertex.shader</file>
- <file>resources/superfragment.shader</file>
- <file>resources/simplevertex.shader</file>
- <file>resources/simplefragment.shader</file>
- </qresource>
-</RCC>
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <private/qsgcontext_p.h>
-#include <private/qsgadaptationlayer_p.h>
-#include <qsgnode.h>
-#include <qsgtexturematerial.h>
-#include <qsgtexture.h>
-#include <QFile>
-#include "superparticle.h"
-#include "particleemitter.h"
-#include <QGLFunctions>
-#include <qsgengine.h>
-
-QT_BEGIN_NAMESPACE
-
-const float CONV = 0.017453292519943295;
-class SuperMaterial : public QSGMaterial
-{
-public:
- SuperMaterial()
- : timestamp(0)
- {
- setFlag(Blending, true);
- }
-
- ~SuperMaterial()
- {
- delete texture;
- delete colortable;
- delete sizetable;
- delete opacitytable;
- }
-
- virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
- virtual QSGMaterialShader *createShader() const;
- virtual int compare(const QSGMaterial *other) const
- {
- return this - static_cast<const SuperMaterial *>(other);
- }
-
- QSGTexture *texture;
- QSGTexture *colortable;
- QSGTexture *sizetable;
- QSGTexture *opacitytable;
-
- qreal timestamp;
-};
-
-
-class SuperMaterialData : public QSGMaterialShader
-{
-public:
- SuperMaterialData(const char *vertexFile = 0, const char *fragmentFile = 0)
- {
- QFile vf(vertexFile ? vertexFile : ":resources/supervertex.shader");
- vf.open(QFile::ReadOnly);
- m_vertex_code = vf.readAll();
-
- QFile ff(fragmentFile ? fragmentFile : ":resources/superfragment.shader");
- ff.open(QFile::ReadOnly);
- m_fragment_code = ff.readAll();
-
- Q_ASSERT(!m_vertex_code.isNull());
- Q_ASSERT(!m_fragment_code.isNull());
- }
-
- void deactivate() {
- QSGMaterialShader::deactivate();
-
- for (int i=0; i<8; ++i) {
- program()->setAttributeArray(i, GL_FLOAT, chunkOfBytes, 1, 0);
- }
- }
-
- virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
- {
- SuperMaterial *m = static_cast<SuperMaterial *>(newEffect);
- state.context()->functions()->glActiveTexture(GL_TEXTURE0);
- m->texture->bind();
-
- state.context()->functions()->glActiveTexture(GL_TEXTURE1);
- m->colortable->bind();
- program()->setUniformValue(m_colortable_id, 1);
-
- state.context()->functions()->glActiveTexture(GL_TEXTURE2);
- m->sizetable->bind();
- program()->setUniformValue(m_sizetable_id, 2);
-
- state.context()->functions()->glActiveTexture(GL_TEXTURE3);
- m->opacitytable->bind();
- program()->setUniformValue(m_opacitytable_id, 3);
-
- program()->setUniformValue(m_opacity_id, state.opacity());
- program()->setUniformValue(m_timestamp_id, (float) m->timestamp);
-
- if (state.isMatrixDirty())
- program()->setUniformValue(m_matrix_id, state.combinedMatrix());
- }
-
- virtual void initialize() {
- m_colortable_id = program()->uniformLocation("colortable");
- m_sizetable_id = program()->uniformLocation("sizetable");
- m_opacitytable_id = program()->uniformLocation("opacitytable");
- m_matrix_id = program()->uniformLocation("matrix");
- m_opacity_id = program()->uniformLocation("opacity");
- m_timestamp_id = program()->uniformLocation("timestamp");
- }
-
- virtual const char *vertexShader() const { return m_vertex_code.constData(); }
- virtual const char *fragmentShader() const { return m_fragment_code.constData(); }
-
- virtual char const *const *attributeNames() const {
- static const char *attr[] = {
- "vPos",
- "vTex",
- "vData",
- "vVec",
- "vColor",
- "vDeformVec",
- "vRotation",
- 0
- };
- return attr;
- }
-
- virtual bool isColorTable() const { return false; }
-
- int m_matrix_id;
- int m_opacity_id;
- int m_timestamp_id;
- int m_colortable_id;
- int m_sizetable_id;
- int m_opacitytable_id;
-
- QByteArray m_vertex_code;
- QByteArray m_fragment_code;
-
- static float chunkOfBytes[1024];
-};
-float SuperMaterialData::chunkOfBytes[1024];
-
-
-QSGMaterialShader *SuperMaterial::createShader() const
-{
- return new SuperMaterialData;
-}
-
-SuperParticle::SuperParticle(QSGItem* parent)
- : ParticleType(parent)
- , m_do_reset(false)
- , m_color(Qt::white)
- , m_color_variation(0.5)
- , m_node(0)
- , m_material(0)
- , m_alphaVariation(0.0)
- , m_alpha(1.0)
- , m_redVariation(0.0)
- , m_greenVariation(0.0)
- , m_blueVariation(0.0)
-{
- setFlag(ItemHasContents);
-}
-
-void SuperParticle::setImage(const QUrl &image)
-{
- if (image == m_image_name)
- return;
- m_image_name = image;
- emit imageChanged();
- reset();
-}
-
-
-void SuperParticle::setColortable(const QUrl &table)
-{
- if (table == m_colortable_name)
- return;
- m_colortable_name = table;
- emit colortableChanged();
- reset();
-}
-
-void SuperParticle::setSizetable(const QUrl &table)
-{
- if (table == m_sizetable_name)
- return;
- m_sizetable_name = table;
- emit sizetableChanged();
- reset();
-}
-
-void SuperParticle::setOpacitytable(const QUrl &table)
-{
- if (table == m_opacitytable_name)
- return;
- m_opacitytable_name = table;
- emit opacitytableChanged();
- reset();
-}
-
-void SuperParticle::setColor(const QColor &color)
-{
- if (color == m_color)
- return;
- m_color = color;
- emit colorChanged();
- //m_system->pleaseReset();//XXX
-}
-
-void SuperParticle::setColorVariation(qreal var)
-{
- if (var == m_color_variation)
- return;
- m_color_variation = var;
- emit colorVariationChanged();
- //m_system->pleaseReset();//XXX
-}
-
-void SuperParticle::setCount(int c)
-{
- ParticleType::setCount(c);
- m_pleaseReset = true;
-}
-
-void SuperParticle::reset()
-{
- ParticleType::reset();
- m_pleaseReset = true;
-}
-
-static QSGGeometry::Attribute SuperParticle_Attributes[] = {
- { 0, 2, GL_FLOAT }, // Position
- { 1, 2, GL_FLOAT }, // TexCoord
- { 2, 4, GL_FLOAT }, // Data
- { 3, 4, GL_FLOAT }, // Vectors
- { 4, 4, GL_UNSIGNED_BYTE }, // Colors
- { 5, 4, GL_FLOAT }, // DeformationVectors
- { 6, 3, GL_FLOAT } // Rotation
-};
-
-static QSGGeometry::AttributeSet SuperParticle_AttributeSet =
-{
- 7, // Attribute Count
- (2 + 2 + 4 + 4 + 4 + 3) * sizeof(float) + 4 * sizeof(uchar),
- SuperParticle_Attributes
-};
-
-QSGGeometryNode* SuperParticle::buildParticleNode()
-{
- if (m_count * 4 > 0xffff) {
- printf("SuperParticle: Too many particles... \n");
- return 0;
- }
-
- if(m_count <= 0) {
- printf("SuperParticle: Too few particles... \n");
- return 0;
- }
-
- QImage image(m_image_name.toLocalFile());
- if (image.isNull()) {
- printf("SuperParticle: loading image failed... '%s'\n", qPrintable(m_image_name.toLocalFile()));
- return 0;
- }
-
- int vCount = m_count * 4;
- int iCount = m_count * 6;
-
- QSGGeometry *g = new QSGGeometry(SuperParticle_AttributeSet, vCount, iCount);
- g->setDrawingMode(GL_TRIANGLES);
-
- SuperVertex *vertices = (SuperVertex *) g->vertexData();
- for (int p=0; p<m_count; ++p) {
-
- for (int i=0; i<4; ++i) {
- vertices[i].x = 0;
- vertices[i].y = 0;
- vertices[i].t = -1;
- vertices[i].lifeSpan = 0;
- vertices[i].size = 0;
- vertices[i].endSize = 0;
- vertices[i].sx = 0;
- vertices[i].sy = 0;
- vertices[i].ax = 0;
- vertices[i].ay = 0;
- vertices[i].xx = 1;
- vertices[i].xy = 0;
- vertices[i].yx = 0;
- vertices[i].yy = 1;
- vertices[i].rotation = 0;
- vertices[i].rotationSpeed = 0;
- vertices[i].autoRotate = 0;
- }
-
- vertices[0].tx = 0;
- vertices[0].ty = 0;
-
- vertices[1].tx = 1;
- vertices[1].ty = 0;
-
- vertices[2].tx = 0;
- vertices[2].ty = 1;
-
- vertices[3].tx = 1;
- vertices[3].ty = 1;
-
- vertices += 4;
- }
-
- quint16 *indices = g->indexDataAsUShort();
- for (int i=0; i<m_count; ++i) {
- int o = i * 4;
- indices[0] = o;
- indices[1] = o + 1;
- indices[2] = o + 2;
- indices[3] = o + 1;
- indices[4] = o + 3;
- indices[5] = o + 2;
- indices += 6;
- }
-
- if (m_material) {
- delete m_material;
- m_material = 0;
- }
-
- QImage colortable(m_colortable_name.toLocalFile());
- QImage sizetable(m_sizetable_name.toLocalFile());
- QImage opacitytable(m_opacitytable_name.toLocalFile());
- m_material = new SuperMaterial();
- if(colortable.isNull())
- colortable = QImage(":resources/identitytable.png");
- if(sizetable.isNull())
- sizetable = QImage(":resources/identitytable.png");
- if(opacitytable.isNull())
- opacitytable = QImage(":resources/defaultFadeInOut.png");
- Q_ASSERT(!colortable.isNull());
- Q_ASSERT(!sizetable.isNull());
- Q_ASSERT(!opacitytable.isNull());
- m_material->colortable = sceneGraphEngine()->createTextureFromImage(colortable);
- m_material->sizetable = sceneGraphEngine()->createTextureFromImage(sizetable);
- m_material->opacitytable = sceneGraphEngine()->createTextureFromImage(opacitytable);
-
- m_material->texture = sceneGraphEngine()->createTextureFromImage(image);
- m_material->texture->setFiltering(QSGTexture::Linear);
-
- m_node = new QSGGeometryNode();
- m_node->setGeometry(g);
- m_node->setMaterial(m_material);
-
- m_last_particle = 0;
-
- return m_node;
-}
-
-QSGNode *SuperParticle::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
-{
- if(m_pleaseReset){
- if(m_node)
- delete m_node;
- if(m_material)
- delete m_material;
-
- m_node = 0;
- m_material = 0;
- m_pleaseReset = false;
- }
-
- if(m_system && m_system->isRunning())
- prepareNextFrame();
- if (m_node){
- update();
- m_node->markDirty(QSGNode::DirtyMaterial);
- }
-
- return m_node;
-}
-
-void SuperParticle::prepareNextFrame()
-{
- if (m_node == 0){ //TODO: Staggered loading (as emitted)
- m_node = buildParticleNode();
- if(m_node == 0)
- return;
- }
- qint64 timeStamp = m_system->systemSync(this);
-
- qreal time = timeStamp / 1000.;
- m_material->timestamp = time;
-}
-
-void SuperParticle::reloadColor(const Color4ub &c, ParticleData* d)
-{
- SuperVertices *particles = (SuperVertices *) m_node->geometry()->vertexData();
- int pos = particleTypeIndex(d);
- SuperVertices &p = particles[pos];
- p.v1.color = p.v2.color = p.v3.color = p.v4.color = c;
-}
-
-void SuperParticle::vertexCopy(SuperVertex &b,const ParticleVertex& a)
-{
- b.x = a.x - m_systemOffset.x();
- b.y = a.y - m_systemOffset.y();
- b.t = a.t;
- b.lifeSpan = a.lifeSpan;
- b.size = a.size;
- b.endSize = a.endSize;
- b.sx = a.sx;
- b.sy = a.sy;
- b.ax = a.ax;
- b.ay = a.ay;
-}
-
-void SuperParticle::reload(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- SuperVertices *particles = (SuperVertices *) m_node->geometry()->vertexData();
-
- int pos = particleTypeIndex(d);
-
- SuperVertices &p = particles[pos];
-
- //Perhaps we could be more efficient?
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-void SuperParticle::load(ParticleData *d)
-{
- if (m_node == 0)
- return;
-
- //Color initialization
- // Particle color
- Color4ub color;
- qreal redVariation = m_color_variation + m_redVariation;
- qreal greenVariation = m_color_variation + m_greenVariation;
- qreal blueVariation = m_color_variation + m_blueVariation;
- color.r = m_color.red() * (1 - redVariation) + rand() % 256 * redVariation;
- color.g = m_color.green() * (1 - greenVariation) + rand() % 256 * greenVariation;
- color.b = m_color.blue() * (1 - blueVariation) + rand() % 256 * blueVariation;
- color.a = m_alpha * m_color.alpha() * (1 - m_alphaVariation) + rand() % 256 * m_alphaVariation;
- SuperVertices *particles = (SuperVertices *) m_node->geometry()->vertexData();
- SuperVertices &p = particles[particleTypeIndex(d)];
- p.v1.color = p.v2.color = p.v3.color = p.v4.color = color;
- if(m_xVector){
- const QPointF &ret = m_xVector->sample(QPointF(d->pv.x, d->pv.y));
- p.v1.xx = p.v2.xx = p.v3.xx = p.v4.xx = ret.x();
- p.v1.xy = p.v2.xy = p.v3.xy = p.v4.xy = ret.y();
- }
- if(m_yVector){
- const QPointF &ret = m_yVector->sample(QPointF(d->pv.x, d->pv.y));
- p.v1.yx = p.v2.yx = p.v3.yx = p.v4.yx = ret.x();
- p.v1.yy = p.v2.yy = p.v3.yy = p.v4.yy = ret.y();
- }
- p.v1.rotation = p.v2.rotation = p.v3.rotation = p.v4.rotation =
- (m_rotation + (m_rotationVariation - 2*((qreal)rand()/RAND_MAX)*m_rotationVariation) ) * CONV;
- p.v1.rotationSpeed = p.v2.rotationSpeed = p.v3.rotationSpeed = p.v4.rotationSpeed =
- (m_rotationSpeed + (m_rotationSpeedVariation - 2*((qreal)rand()/RAND_MAX)*m_rotationSpeedVariation) ) * CONV;
- p.v1.autoRotate = p.v2.autoRotate = p.v3.autoRotate = p.v4.autoRotate = m_autoRotation?1.0:0.0;
-
- vertexCopy(p.v1, d->pv);
- vertexCopy(p.v2, d->pv);
- vertexCopy(p.v3, d->pv);
- vertexCopy(p.v4, d->pv);
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef SUPERPARTICLE_H
-#define SUPERPARTICLE_H
-#include "particle.h"
-#include "varyingvector.h"
-
-#include "coloredparticle.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class SuperMaterial;
-class QSGGeometryNode;
-
-/*struct Color4ub {//in coloredparticle
- uchar r;
- uchar g;
- uchar b;
- uchar a;
-};*/
-
-struct SuperVertex {
- float x;
- float y;
- float tx;
- float ty;
- float t;
- float lifeSpan;
- float size;
- float endSize;
- float sx;
- float sy;
- float ax;
- float ay;
- Color4ub color;
- float xx;
- float xy;
- float yx;
- float yy;
- float rotation;
- float rotationSpeed;
- float autoRotate;//Assume that GPUs prefer floats to bools
-};
-
-struct SuperVertices {
- SuperVertex v1;
- SuperVertex v2;
- SuperVertex v3;
- SuperVertex v4;
-};
-
-class SuperParticle : public ParticleType
-{
- Q_OBJECT
- Q_PROPERTY(QUrl image READ image WRITE setImage NOTIFY imageChanged)
- Q_PROPERTY(QUrl colorTable READ colortable WRITE setColortable NOTIFY colortableChanged)
- Q_PROPERTY(QUrl sizeTable READ sizetable WRITE setSizetable NOTIFY sizetableChanged)
- Q_PROPERTY(QUrl opacityTable READ opacitytable WRITE setOpacitytable NOTIFY opacitytableChanged)
-
- Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
- //Stacks (added) with individual colorVariations
- Q_PROPERTY(qreal colorVariation READ colorVariation WRITE setColorVariation NOTIFY colorVariationChanged)
- Q_PROPERTY(qreal redVariation READ redVariation WRITE setRedVariation NOTIFY redVariationChanged)
- Q_PROPERTY(qreal greenVariation READ greenVariation WRITE setGreenVariation NOTIFY greenVariationChanged)
- Q_PROPERTY(qreal blueVariation READ blueVariation WRITE setBlueVariation NOTIFY blueVariationChanged)
- //Stacks (multiplies) with the Alpha in the color, mostly here so you can use svg color names (which have full alpha)
- Q_PROPERTY(qreal alpha READ alpha WRITE setAlpha NOTIFY alphaChanged)
- Q_PROPERTY(qreal alphaVariation READ alphaVariation WRITE setAlphaVariation NOTIFY alphaVariationChanged)
-
- Q_PROPERTY(qreal rotation READ rotation WRITE setRotation NOTIFY rotationChanged)
- Q_PROPERTY(qreal rotationVariation READ rotationVariation WRITE setRotationVariation NOTIFY rotationVariationChanged)
- Q_PROPERTY(qreal rotationSpeed READ rotationSpeed WRITE setRotationSpeed NOTIFY rotationSpeedChanged)
- Q_PROPERTY(qreal rotationSpeedVariation READ rotationSpeedVariation WRITE setRotationSpeedVariation NOTIFY rotationSpeedVariationChanged)
- //If true, then will face the direction of motion. Stacks with rotation, e.g. setting rotation
- //to 180 will lead to facing away from the direction of motion
- Q_PROPERTY(bool autoRotation READ autoRotation WRITE autoRotation NOTIFY autoRotationChanged)
-
- //###Call i/j? Makes more sense to those with vector calculus experience, and I could even add the cirumflex in QML?
- //xVector is the vector from the top-left point to the top-right point, and is multiplied by current size
- Q_PROPERTY(VaryingVector* xVector READ xVector WRITE setXVector NOTIFY xVectorChanged)
- //yVector is the same, but top-left to bottom-left. The particle is always a parallelogram.
- Q_PROPERTY(VaryingVector* yVector READ yVector WRITE setYVector NOTIFY yVectorChanged)
-public:
- explicit SuperParticle(QSGItem *parent = 0);
- virtual ~SuperParticle(){}
-
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
- virtual void setCount(int c);
-
- QUrl image() const { return m_image_name; }
- void setImage(const QUrl &image);
-
- QUrl colortable() const { return m_colortable_name; }
- void setColortable(const QUrl &table);
-
- QUrl sizetable() const { return m_sizetable_name; }
- void setSizetable (const QUrl &table);
-
- QUrl opacitytable() const { return m_opacitytable_name; }
- void setOpacitytable(const QUrl &table);
-
- QColor color() const { return m_color; }
- void setColor(const QColor &color);
-
- qreal colorVariation() const { return m_color_variation; }
- void setColorVariation(qreal var);
-
- qreal renderOpacity() const { return m_render_opacity; }
-
- qreal alphaVariation() const
- {
- return m_alphaVariation;
- }
-
- qreal alpha() const
- {
- return m_alpha;
- }
-
- qreal redVariation() const
- {
- return m_redVariation;
- }
-
- qreal greenVariation() const
- {
- return m_greenVariation;
- }
-
- qreal blueVariation() const
- {
- return m_blueVariation;
- }
-
- qreal rotation() const
- {
- return m_rotation;
- }
-
- qreal rotationVariation() const
- {
- return m_rotationVariation;
- }
-
- qreal rotationSpeed() const
- {
- return m_rotationSpeed;
- }
-
- qreal rotationSpeedVariation() const
- {
- return m_rotationSpeedVariation;
- }
-
- bool autoRotation() const
- {
- return m_autoRotation;
- }
-
- VaryingVector* xVector() const
- {
- return m_xVector;
- }
-
- VaryingVector* yVector() const
- {
- return m_yVector;
- }
-
-signals:
-
- void imageChanged();
- void colortableChanged();
- void sizetableChanged();
- void opacitytableChanged();
-
- void colorChanged();
- void colorVariationChanged();
-
- void particleDurationChanged();
- void alphaVariationChanged(qreal arg);
-
- void alphaChanged(qreal arg);
-
- void redVariationChanged(qreal arg);
-
- void greenVariationChanged(qreal arg);
-
- void blueVariationChanged(qreal arg);
-
- void rotationChanged(qreal arg);
-
- void rotationVariationChanged(qreal arg);
-
- void rotationSpeedChanged(qreal arg);
-
- void rotationSpeedVariationChanged(qreal arg);
-
- void autoRotationChanged(bool arg);
-
- void xVectorChanged(VaryingVector* arg);
-
- void yVectorChanged(VaryingVector* arg);
-
-public slots:
- void setAlphaVariation(qreal arg)
- {
- if (m_alphaVariation != arg) {
- m_alphaVariation = arg;
- emit alphaVariationChanged(arg);
- }
- }
-
- void setAlpha(qreal arg)
- {
- if (m_alpha != arg) {
- m_alpha = arg;
- emit alphaChanged(arg);
- }
- }
-
- void setRedVariation(qreal arg)
- {
- if (m_redVariation != arg) {
- m_redVariation = arg;
- emit redVariationChanged(arg);
- }
- }
-
- void setGreenVariation(qreal arg)
- {
- if (m_greenVariation != arg) {
- m_greenVariation = arg;
- emit greenVariationChanged(arg);
- }
- }
-
- void setBlueVariation(qreal arg)
- {
- if (m_blueVariation != arg) {
- m_blueVariation = arg;
- emit blueVariationChanged(arg);
- }
- }
-
- void reloadColor(const Color4ub &c, ParticleData* d);
- void setRotation(qreal arg)
- {
- if (m_rotation != arg) {
- m_rotation = arg;
- emit rotationChanged(arg);
- }
- }
-
- void setRotationVariation(qreal arg)
- {
- if (m_rotationVariation != arg) {
- m_rotationVariation = arg;
- emit rotationVariationChanged(arg);
- }
- }
-
- void setRotationSpeed(qreal arg)
- {
- if (m_rotationSpeed != arg) {
- m_rotationSpeed = arg;
- emit rotationSpeedChanged(arg);
- }
- }
-
- void setRotationSpeedVariation(qreal arg)
- {
- if (m_rotationSpeedVariation != arg) {
- m_rotationSpeedVariation = arg;
- emit rotationSpeedVariationChanged(arg);
- }
- }
-
- void autoRotation(bool arg)
- {
- if (m_autoRotation != arg) {
- m_autoRotation = arg;
- emit autoRotationChanged(arg);
- }
- }
-
- void setXVector(VaryingVector* arg)
- {
- if (m_xVector != arg) {
- m_xVector = arg;
- emit xVectorChanged(arg);
- }
- }
-
- void setYVector(VaryingVector* arg)
- {
- if (m_yVector != arg) {
- m_yVector = arg;
- emit yVectorChanged(arg);
- }
- }
-
-protected:
- QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- void reset();
- void prepareNextFrame();
- QSGGeometryNode* buildParticleNode();
-private:
- void vertexCopy(SuperVertex &b,const ParticleVertex& a);
- bool m_do_reset;
-
- QUrl m_image_name;
- QUrl m_colortable_name;
- QUrl m_sizetable_name;
- QUrl m_opacitytable_name;
-
-
- QColor m_color;
- qreal m_color_variation;
- qreal m_particleDuration;
-
- QSGGeometryNode *m_node;
- SuperMaterial *m_material;
-
- // derived values...
- int m_last_particle;
-
- qreal m_render_opacity;
- qreal m_alphaVariation;
- qreal m_alpha;
- qreal m_redVariation;
- qreal m_greenVariation;
- qreal m_blueVariation;
- qreal m_rotation;
- qreal m_rotationVariation;
- qreal m_rotationSpeed;
- qreal m_rotationSpeedVariation;
- bool m_autoRotation;
- VaryingVector* m_xVector;
- VaryingVector* m_yVector;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // SUPERPARTICLE_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "swarmaffector.h"
-#include "particle.h"
-#include <cmath>
-#include <QDebug>
-QT_BEGIN_NAMESPACE
-
-SwarmAffector::SwarmAffector(QSGItem *parent) :
- ParticleAffector(parent), m_strength(1), m_inited(false)
-{
- connect(this, SIGNAL(leadersChanged(QStringList)),
- this, SLOT(updateGroupList()));
-}
-
-void SwarmAffector::ensureInit()
-{
- if(m_inited)
- return;
- m_inited = true;
- updateGroupList();
- m_lastPos.resize(m_system->count());
-}
-
-const qreal epsilon = 0.0000001;
-bool SwarmAffector::affectParticle(ParticleData *d, qreal dt)
-{
- ensureInit();
- QPointF curPos(d->curX(), d->curY());
- if(m_leaders.isEmpty() || m_leadGroups.contains(d->group)){
- m_lastPos[d->systemIndex] = curPos;
- if(m_leadGroups.contains(d->group))
- return false;
- }
-
- qreal fx = 0.0;
- qreal fy = 0.0;
- for(int i=0; i < m_lastPos.count(); i++){
- if(m_lastPos[i].isNull())
- continue;
- QPointF diff = m_lastPos[i] - curPos;
- qreal r = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
- if(r == 0.0)
- continue;
- qreal f = m_strength * (1/r);
- if(f < epsilon)
- continue;
- qreal theta = atan2(diff.y(), diff.x());
- fx += cos(theta) * f;
- fy += sin(theta) * f;
- }
- if(!fx && !fy)
- return false;
- d->setInstantaneousSX(d->curSX()+fx * dt);
- d->setInstantaneousSY(d->curSY()+fy * dt);
- return true;
-}
-
-void SwarmAffector::reset(int systemIdx)
-{
- if(!m_system)
- return;
- if(!m_lastPos[systemIdx].isNull())
- m_lastPos[systemIdx] = QPointF();
-}
-
-void SwarmAffector::updateGroupList()
-{
- if(!m_system || !m_system->m_initialized)
- return;
- m_leadGroups.clear();
- foreach(const QString &s, m_leaders)
- m_leadGroups << m_system->m_groupIds[s];
-}
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef SWARMAFFECTOR_H
-#define SWARMAFFECTOR_H
-#include "particleaffector.h"
-#include <QDeclarativeListProperty>
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-
-class ParticleType;
-
-class SwarmAffector : public ParticleAffector
-{
- Q_OBJECT
- Q_PROPERTY(qreal strength READ strength WRITE setStrength NOTIFY strengthChanged)
- Q_PROPERTY(QStringList leaders READ leaders WRITE setLeaders NOTIFY leadersChanged)
-public:
- explicit SwarmAffector(QSGItem *parent = 0);
- virtual bool affectParticle(ParticleData *d, qreal dt);
- virtual void reset(int systemIdx);
-
- qreal strength() const
- {
- return m_strength;
- }
-
- QStringList leaders() const
- {
- return m_leaders;
- }
-
-signals:
-
- void strengthChanged(qreal arg);
-
- void leadersChanged(QStringList arg);
-
-public slots:
-
-void setStrength(qreal arg)
-{
- if (m_strength != arg) {
- m_strength = arg;
- emit strengthChanged(arg);
- }
-}
-
-void setLeaders(QStringList arg)
-{
- if (m_leaders != arg) {
- m_leaders = arg;
- emit leadersChanged(arg);
- }
-}
-
-private:
- void ensureInit();
- void mapUpdate(int idx, qreal strength);
- QVector<QPointF> m_lastPos;
- qreal m_strength;
- bool m_inited;
- QStringList m_leaders;
- QSet<int> m_leadGroups;
-private slots:
- void updateGroupList();
-};
-
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif // SWARMAFFECTOR_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "toggleaffector.h"
-
-QT_BEGIN_NAMESPACE
-
-ToggleAffector::ToggleAffector(QObject *parent) :
- ParticleAffector(parent)
-{
-}
-
-bool ToggleAffector::affect(ParticleData *d, qreal dt)
-{
- if(m_affecting)
- return m_affector->affect(d, dt);
- else
- return false;
-}
-
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef TOGGLEAFFECTOR_H
-#define TOGGLEAFFECTOR_H
-#include "particleaffector.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class ToggleAffector : public ParticleAffector
-{
- Q_OBJECT
- Q_PROPERTY(bool affecting READ affecting WRITE setAffecting NOTIFY affectingChanged)
- Q_PROPERTY(ParticleAffector* affector READ affector WRITE affector NOTIFY affectorChanged)
- Q_CLASSINFO("DefaultProperty", "affector")
-
-public:
- explicit ToggleAffector(QObject *parent = 0);
- virtual bool affect(ParticleData *d, qreal dt);
- bool affecting() const
- {
- return m_affecting;
- }
-
- ParticleAffector* affector() const
- {
- return m_affector;
- }
-
-signals:
-
- void affectingChanged(bool arg);
-
- void affectorChanged(ParticleAffector* arg);
-
-public slots:
-void setAffecting(bool arg)
-{
- if (m_affecting != arg) {
- m_affecting = arg;
- emit affectingChanged(arg);
- }
-}
-
-void affector(ParticleAffector* arg)
-{
- if (m_affector != arg) {
- m_affector = arg;
- emit affectorChanged(arg);
- }
-}
-
-private:
-bool m_affecting;
-ParticleAffector* m_affector;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // TOGGLEAFFECTOR_H
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "zoneaffector.h"
-#include <QDebug>
-
-QT_BEGIN_NAMESPACE
-
-ZoneAffector::ZoneAffector(QObject *parent) :
- ParticleAffector(parent), m_x(0), m_y(0), m_width(0), m_height(0), m_affector(0)
-{
-}
-
-bool ZoneAffector::affect(ParticleData *d, qreal dt)
-{
- if(!m_affector)
- return false;
- qreal x = d->curX();
- qreal y = d->curY();
- if(x >= m_x && x <= m_x+m_width && y >= m_y && y <= m_y+m_height)
- return m_affector->affect(d, dt);
- return false;
-}
-
-void ZoneAffector::reset(int systemIdx)
-{
- if(m_affector)
- m_affector->reset(systemIdx);
-}
-QT_END_NAMESPACE
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the Declarative module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** No Commercial Usage
-** This file contains pre-release code and may not be distributed.
-** You may use this file in accordance with the terms and conditions
-** contained in the Technology Preview License Agreement accompanying
-** this package.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef ZONEAFFECTOR_H
-#define ZONEAFFECTOR_H
-#include "particleaffector.h"
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Declarative)
-
-class ZoneAffector : public ParticleAffector
-{
- Q_OBJECT
- //TODO: Can we get anchors in here? consider becoming an un-parented QSGItem?
- Q_PROPERTY(qreal x READ x WRITE setX NOTIFY xChanged);
- Q_PROPERTY(qreal y READ y WRITE setY NOTIFY yChanged);
- Q_PROPERTY(qreal width READ width WRITE setWidth NOTIFY widthChanged);
- Q_PROPERTY(qreal height READ height WRITE setHeight NOTIFY heightChanged);
- Q_PROPERTY(ParticleAffector* affector READ affector WRITE affector NOTIFY affectorChanged)
- Q_CLASSINFO("DefaultProperty", "affector")
-public:
- explicit ZoneAffector(QObject *parent = 0);
-
- virtual bool affect(ParticleData *d, qreal dt);
- virtual void reset(int systemIdx);
-
- ParticleAffector* affector() const
- {
- return m_affector;
- }
-
- qreal x() const
- {
- return m_x;
- }
-
- qreal y() const
- {
- return m_y;
- }
-
- qreal width() const
- {
- return m_width;
- }
-
- qreal height() const
- {
- return m_height;
- }
-
-signals:
-
-
- void affectorChanged(ParticleAffector* arg);
-
- void xChanged(qreal arg);
-
- void yChanged(qreal arg);
-
- void widthChanged(qreal arg);
-
- void heightChanged(qreal arg);
-
-public slots:
-
-
-void affector(ParticleAffector* arg)
-{
- if (m_affector != arg) {
- m_affector = arg;
- emit affectorChanged(arg);
- }
-}
-
-void setX(qreal arg)
-{
- if (m_x != arg) {
- m_x = arg;
- emit xChanged(arg);
- }
-}
-
-void setY(qreal arg)
-{
- if (m_y != arg) {
- m_y = arg;
- emit yChanged(arg);
- }
-}
-
-void setWidth(qreal arg)
-{
- if (m_width != arg) {
- m_width = arg;
- emit widthChanged(arg);
- }
-}
-
-void setHeight(qreal arg)
-{
- if (m_height != arg) {
- m_height = arg;
- emit heightChanged(arg);
- }
-}
-
-private:
-qreal m_x;
-qreal m_y;
-qreal m_width;
-qreal m_height;
-ParticleAffector* m_affector;
-};
-
-QT_END_NAMESPACE
-QT_END_HEADER
-#endif // ZONEAFFECTOR_H
--- /dev/null
+load(qt_module)
+
+TARGET = declarativeobserver
+QT += declarative-private
+
+include($$QT_SOURCE_TREE/src/plugins/qpluginbase.pri)
+
+DESTDIR = $$QT.declarative.plugins/qmltooling
+QTDIR_build:REQUIRES += "contains(QT_CONFIG, declarative)"
+
+SOURCES += \
+ qdeclarativeobserverplugin.cpp \
+ qdeclarativeviewobserver.cpp \
+ editor/abstractliveedittool.cpp \
+ editor/liveselectiontool.cpp \
+ editor/livelayeritem.cpp \
+ editor/livesingleselectionmanipulator.cpp \
+ editor/liverubberbandselectionmanipulator.cpp \
+ editor/liveselectionrectangle.cpp \
+ editor/liveselectionindicator.cpp \
+ editor/boundingrecthighlighter.cpp \
+ editor/subcomponenteditortool.cpp \
+ editor/subcomponentmasklayeritem.cpp \
+ editor/zoomtool.cpp \
+ editor/colorpickertool.cpp \
+ editor/qmltoolbar.cpp \
+ editor/toolbarcolorbox.cpp
+
+HEADERS += \
+ qdeclarativeobserverplugin.h \
+ qdeclarativeobserverprotocol.h \
+ qdeclarativeviewobserver_p.h \
+ qdeclarativeviewobserver_p_p.h \
+ qmlobserverconstants_p.h \
+ editor/abstractliveedittool_p.h \
+ editor/liveselectiontool_p.h \
+ editor/livelayeritem_p.h \
+ editor/livesingleselectionmanipulator_p.h \
+ editor/liverubberbandselectionmanipulator_p.h \
+ editor/liveselectionrectangle_p.h \
+ editor/liveselectionindicator_p.h \
+ editor/boundingrecthighlighter_p.h \
+ editor/subcomponenteditortool_p.h \
+ editor/subcomponentmasklayeritem_p.h \
+ editor/zoomtool_p.h \
+ editor/colorpickertool_p.h \
+ editor/qmltoolbar_p.h \
+ editor/toolbarcolorbox_p.h
+
+RESOURCES += editor/editor.qrc
+
+target.path += $$[QT_INSTALL_PLUGINS]/qmltooling
+INSTALLS += target
+
+symbian:TARGET.UID3=0x20031E90
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "abstractliveedittool_p.h"
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QDeclarativeEngine>
+
+#include <QtDebug>
+#include <QGraphicsItem>
+#include <QDeclarativeItem>
+
+QT_BEGIN_NAMESPACE
+
+AbstractLiveEditTool::AbstractLiveEditTool(QDeclarativeViewObserver *editorView)
+ : QObject(editorView), m_observer(editorView)
+{
+}
+
+
+AbstractLiveEditTool::~AbstractLiveEditTool()
+{
+}
+
+QDeclarativeViewObserver *AbstractLiveEditTool::observer() const
+{
+ return m_observer;
+}
+
+QDeclarativeView *AbstractLiveEditTool::view() const
+{
+ return m_observer->declarativeView();
+}
+
+QGraphicsScene* AbstractLiveEditTool::scene() const
+{
+ return view()->scene();
+}
+
+void AbstractLiveEditTool::updateSelectedItems()
+{
+ selectedItemsChanged(items());
+}
+
+QList<QGraphicsItem*> AbstractLiveEditTool::items() const
+{
+ return observer()->selectedItems();
+}
+
+void AbstractLiveEditTool::enterContext(QGraphicsItem *itemToEnter)
+{
+ observer()->data->enterContext(itemToEnter);
+}
+
+bool AbstractLiveEditTool::topItemIsMovable(const QList<QGraphicsItem*> & itemList)
+{
+ QGraphicsItem *firstSelectableItem = topMovableGraphicsItem(itemList);
+ if (firstSelectableItem == 0)
+ return false;
+ if (toQDeclarativeItem(firstSelectableItem) != 0)
+ return true;
+
+ return false;
+
+}
+
+bool AbstractLiveEditTool::topSelectedItemIsMovable(const QList<QGraphicsItem*> &itemList)
+{
+ QList<QGraphicsItem*> selectedItems = observer()->selectedItems();
+
+ foreach (QGraphicsItem *item, itemList) {
+ QDeclarativeItem *declarativeItem = toQDeclarativeItem(item);
+ if (declarativeItem
+ && selectedItems.contains(declarativeItem)
+ /*&& (declarativeItem->qmlItemNode().hasShowContent() || selectNonContentItems)*/)
+ return true;
+ }
+
+ return false;
+
+}
+
+bool AbstractLiveEditTool::topItemIsResizeHandle(const QList<QGraphicsItem*> &/*itemList*/)
+{
+ return false;
+}
+
+QDeclarativeItem *AbstractLiveEditTool::toQDeclarativeItem(QGraphicsItem *item)
+{
+ return qobject_cast<QDeclarativeItem*>(item->toGraphicsObject());
+}
+
+QGraphicsItem *AbstractLiveEditTool::topMovableGraphicsItem(const QList<QGraphicsItem*> &itemList)
+{
+ foreach (QGraphicsItem *item, itemList) {
+ if (item->flags().testFlag(QGraphicsItem::ItemIsMovable))
+ return item;
+ }
+ return 0;
+}
+
+QDeclarativeItem *AbstractLiveEditTool::topMovableDeclarativeItem(const QList<QGraphicsItem*>
+ &itemList)
+{
+ foreach (QGraphicsItem *item, itemList) {
+ QDeclarativeItem *declarativeItem = toQDeclarativeItem(item);
+ if (declarativeItem /*&& (declarativeItem->qmlItemNode().hasShowContent())*/)
+ return declarativeItem;
+ }
+
+ return 0;
+}
+
+QList<QGraphicsObject*> AbstractLiveEditTool::toGraphicsObjectList(const QList<QGraphicsItem*>
+ &itemList)
+{
+ QList<QGraphicsObject*> gfxObjects;
+ foreach (QGraphicsItem *item, itemList) {
+ QGraphicsObject *obj = item->toGraphicsObject();
+ if (obj)
+ gfxObjects << obj;
+ }
+
+ return gfxObjects;
+}
+
+QString AbstractLiveEditTool::titleForItem(QGraphicsItem *item)
+{
+ QString className(QLatin1String("QGraphicsItem"));
+ QString objectStringId;
+
+ QString constructedName;
+
+ QGraphicsObject *gfxObject = item->toGraphicsObject();
+ if (gfxObject) {
+ className = QLatin1String(gfxObject->metaObject()->className());
+
+ className.remove(QRegExp(QLatin1String("_QMLTYPE_\\d+")));
+ className.remove(QRegExp(QLatin1String("_QML_\\d+")));
+ if (className.startsWith(QLatin1String("QDeclarative")))
+ className = className.remove(QLatin1String("QDeclarative"));
+
+ QDeclarativeItem *declarativeItem = qobject_cast<QDeclarativeItem*>(gfxObject);
+ if (declarativeItem) {
+ objectStringId = m_observer->idStringForObject(declarativeItem);
+ }
+
+ if (!objectStringId.isEmpty()) {
+ constructedName = objectStringId + QLatin1String(" (") + className + QLatin1Char(')');
+ } else {
+ if (!gfxObject->objectName().isEmpty()) {
+ constructedName = gfxObject->objectName() + QLatin1String(" (") + className + QLatin1Char(')');
+ } else {
+ constructedName = className;
+ }
+ }
+ }
+
+ return constructedName;
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef ABSTRACTLIVEEDITTOOL_H
+#define ABSTRACTLIVEEDITTOOL_H
+
+#include <QtCore/QList>
+#include <QtCore/QObject>
+
+QT_BEGIN_NAMESPACE
+class QMouseEvent;
+class QGraphicsItem;
+class QDeclarativeItem;
+class QKeyEvent;
+class QGraphicsScene;
+class QGraphicsObject;
+class QWheelEvent;
+class QDeclarativeView;
+QT_END_NAMESPACE
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+
+class AbstractLiveEditTool : public QObject
+{
+ Q_OBJECT
+public:
+ AbstractLiveEditTool(QDeclarativeViewObserver *observer);
+
+ virtual ~AbstractLiveEditTool();
+
+ virtual void mousePressEvent(QMouseEvent *event) = 0;
+ virtual void mouseMoveEvent(QMouseEvent *event) = 0;
+ virtual void mouseReleaseEvent(QMouseEvent *event) = 0;
+ virtual void mouseDoubleClickEvent(QMouseEvent *event) = 0;
+
+ virtual void hoverMoveEvent(QMouseEvent *event) = 0;
+ virtual void wheelEvent(QWheelEvent *event) = 0;
+
+ virtual void keyPressEvent(QKeyEvent *event) = 0;
+ virtual void keyReleaseEvent(QKeyEvent *keyEvent) = 0;
+ virtual void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList) = 0;
+
+ virtual void clear() = 0;
+
+ void updateSelectedItems();
+ QList<QGraphicsItem*> items() const;
+
+ void enterContext(QGraphicsItem *itemToEnter);
+
+ bool topItemIsMovable(const QList<QGraphicsItem*> &itemList);
+ bool topItemIsResizeHandle(const QList<QGraphicsItem*> &itemList);
+ bool topSelectedItemIsMovable(const QList<QGraphicsItem*> &itemList);
+
+ QString titleForItem(QGraphicsItem *item);
+
+ static QList<QGraphicsObject*> toGraphicsObjectList(const QList<QGraphicsItem*> &itemList);
+ static QGraphicsItem* topMovableGraphicsItem(const QList<QGraphicsItem*> &itemList);
+ static QDeclarativeItem* topMovableDeclarativeItem(const QList<QGraphicsItem*> &itemList);
+ static QDeclarativeItem *toQDeclarativeItem(QGraphicsItem *item);
+
+protected:
+ virtual void selectedItemsChanged(const QList<QGraphicsItem*> &objectList) = 0;
+
+ QDeclarativeViewObserver *observer() const;
+ QDeclarativeView *view() const;
+ QGraphicsScene *scene() const;
+
+private:
+ QDeclarativeViewObserver *m_observer;
+ QList<QGraphicsItem*> m_itemList;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // ABSTRACTLIVEEDITTOOL_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "boundingrecthighlighter_p.h"
+
+#include "../qdeclarativeviewobserver_p.h"
+#include "../qmlobserverconstants_p.h"
+
+#include <QtGui/QGraphicsPolygonItem>
+
+#include <QtCore/QTimer>
+#include <QtCore/QObject>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+const qreal AnimDelta = 0.025f;
+const int AnimInterval = 30;
+const int AnimFrames = 10;
+
+BoundingBox::BoundingBox(QGraphicsObject *itemToHighlight, QGraphicsItem *parentItem,
+ QObject *parent)
+ : QObject(parent),
+ highlightedObject(itemToHighlight),
+ highlightPolygon(0),
+ highlightPolygonEdge(0)
+{
+ highlightPolygon = new BoundingBoxPolygonItem(parentItem);
+ highlightPolygonEdge = new BoundingBoxPolygonItem(parentItem);
+
+ highlightPolygon->setPen(QPen(QColor(0, 22, 159)));
+ highlightPolygonEdge->setPen(QPen(QColor(158, 199, 255)));
+
+ highlightPolygon->setFlag(QGraphicsItem::ItemIsSelectable, false);
+ highlightPolygonEdge->setFlag(QGraphicsItem::ItemIsSelectable, false);
+}
+
+BoundingBox::~BoundingBox()
+{
+ highlightedObject.clear();
+}
+
+BoundingBoxPolygonItem::BoundingBoxPolygonItem(QGraphicsItem *item) : QGraphicsPolygonItem(item)
+{
+ QPen pen;
+ pen.setColor(QColor(108, 141, 221));
+ pen.setWidth(1);
+ setPen(pen);
+}
+
+int BoundingBoxPolygonItem::type() const
+{
+ return Constants::EditorItemType;
+}
+
+BoundingRectHighlighter::BoundingRectHighlighter(QDeclarativeViewObserver *view) :
+ LiveLayerItem(view->declarativeView()->scene()),
+ m_view(view),
+ m_animFrame(0)
+{
+ m_animTimer = new QTimer(this);
+ m_animTimer->setInterval(AnimInterval);
+ connect(m_animTimer, SIGNAL(timeout()), SLOT(animTimeout()));
+}
+
+BoundingRectHighlighter::~BoundingRectHighlighter()
+{
+
+}
+
+void BoundingRectHighlighter::animTimeout()
+{
+ ++m_animFrame;
+ if (m_animFrame == AnimFrames) {
+ m_animTimer->stop();
+ }
+
+ qreal alpha = m_animFrame / float(AnimFrames);
+
+ foreach (BoundingBox *box, m_boxes) {
+ box->highlightPolygonEdge->setOpacity(alpha);
+ }
+}
+
+void BoundingRectHighlighter::clear()
+{
+ if (m_boxes.length()) {
+ m_animTimer->stop();
+
+ foreach (BoundingBox *box, m_boxes) {
+ freeBoundingBox(box);
+ }
+ }
+}
+
+BoundingBox *BoundingRectHighlighter::boxFor(QGraphicsObject *item) const
+{
+ foreach (BoundingBox *box, m_boxes) {
+ if (box->highlightedObject.data() == item) {
+ return box;
+ }
+ }
+ return 0;
+}
+
+void BoundingRectHighlighter::highlight(QList<QGraphicsObject*> items)
+{
+ if (items.isEmpty())
+ return;
+
+ bool animate = false;
+
+ QList<BoundingBox *> newBoxes;
+ foreach (QGraphicsObject *itemToHighlight, items) {
+ BoundingBox *box = boxFor(itemToHighlight);
+ if (!box) {
+ box = createBoundingBox(itemToHighlight);
+ animate = true;
+ }
+
+ newBoxes << box;
+ }
+ qSort(newBoxes);
+
+ if (newBoxes != m_boxes) {
+ clear();
+ m_boxes << newBoxes;
+ }
+
+ highlightAll(animate);
+}
+
+void BoundingRectHighlighter::highlight(QGraphicsObject* itemToHighlight)
+{
+ if (!itemToHighlight)
+ return;
+
+ bool animate = false;
+
+ BoundingBox *box = boxFor(itemToHighlight);
+ if (!box) {
+ box = createBoundingBox(itemToHighlight);
+ m_boxes << box;
+ animate = true;
+ qSort(m_boxes);
+ }
+
+ highlightAll(animate);
+}
+
+BoundingBox *BoundingRectHighlighter::createBoundingBox(QGraphicsObject *itemToHighlight)
+{
+ if (!m_freeBoxes.isEmpty()) {
+ BoundingBox *box = m_freeBoxes.last();
+ if (box->highlightedObject.isNull()) {
+ box->highlightedObject = itemToHighlight;
+ box->highlightPolygon->show();
+ box->highlightPolygonEdge->show();
+ m_freeBoxes.removeLast();
+ return box;
+ }
+ }
+
+ BoundingBox *box = new BoundingBox(itemToHighlight, this, this);
+
+ connect(itemToHighlight, SIGNAL(xChanged()), this, SLOT(refresh()));
+ connect(itemToHighlight, SIGNAL(yChanged()), this, SLOT(refresh()));
+ connect(itemToHighlight, SIGNAL(widthChanged()), this, SLOT(refresh()));
+ connect(itemToHighlight, SIGNAL(heightChanged()), this, SLOT(refresh()));
+ connect(itemToHighlight, SIGNAL(rotationChanged()), this, SLOT(refresh()));
+ connect(itemToHighlight, SIGNAL(destroyed(QObject*)), this, SLOT(itemDestroyed(QObject*)));
+
+ return box;
+}
+
+void BoundingRectHighlighter::removeBoundingBox(BoundingBox *box)
+{
+ delete box;
+ box = 0;
+}
+
+void BoundingRectHighlighter::freeBoundingBox(BoundingBox *box)
+{
+ if (!box->highlightedObject.isNull()) {
+ disconnect(box->highlightedObject.data(), SIGNAL(xChanged()), this, SLOT(refresh()));
+ disconnect(box->highlightedObject.data(), SIGNAL(yChanged()), this, SLOT(refresh()));
+ disconnect(box->highlightedObject.data(), SIGNAL(widthChanged()), this, SLOT(refresh()));
+ disconnect(box->highlightedObject.data(), SIGNAL(heightChanged()), this, SLOT(refresh()));
+ disconnect(box->highlightedObject.data(), SIGNAL(rotationChanged()), this, SLOT(refresh()));
+ }
+
+ box->highlightedObject.clear();
+ box->highlightPolygon->hide();
+ box->highlightPolygonEdge->hide();
+ m_boxes.removeOne(box);
+ m_freeBoxes << box;
+}
+
+void BoundingRectHighlighter::itemDestroyed(QObject *obj)
+{
+ foreach (BoundingBox *box, m_boxes) {
+ if (box->highlightedObject.data() == obj) {
+ freeBoundingBox(box);
+ break;
+ }
+ }
+}
+
+void BoundingRectHighlighter::highlightAll(bool animate)
+{
+ foreach (BoundingBox *box, m_boxes) {
+ if (box && box->highlightedObject.isNull()) {
+ // clear all highlights
+ clear();
+ return;
+ }
+ QGraphicsObject *item = box->highlightedObject.data();
+ QRectF itemAndChildRect = item->boundingRect() | item->childrenBoundingRect();
+
+ QPolygonF boundingRectInSceneSpace(item->mapToScene(itemAndChildRect));
+ QPolygonF boundingRectInLayerItemSpace = mapFromScene(boundingRectInSceneSpace);
+ QRectF bboxRect
+ = m_view->adjustToScreenBoundaries(boundingRectInLayerItemSpace.boundingRect());
+ QRectF edgeRect = bboxRect;
+ edgeRect.adjust(-1, -1, 1, 1);
+
+ box->highlightPolygon->setPolygon(QPolygonF(bboxRect));
+ box->highlightPolygonEdge->setPolygon(QPolygonF(edgeRect));
+
+ if (animate)
+ box->highlightPolygonEdge->setOpacity(0);
+ }
+
+ if (animate) {
+ m_animFrame = 0;
+ m_animTimer->start();
+ }
+}
+
+void BoundingRectHighlighter::refresh()
+{
+ if (!m_boxes.isEmpty())
+ highlightAll(true);
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef BOUNDINGRECTHIGHLIGHTER_H
+#define BOUNDINGRECTHIGHLIGHTER_H
+
+#include "livelayeritem_p.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QWeakPointer>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsItem)
+QT_FORWARD_DECLARE_CLASS(QPainter)
+QT_FORWARD_DECLARE_CLASS(QWidget)
+QT_FORWARD_DECLARE_CLASS(QStyleOptionGraphicsItem)
+QT_FORWARD_DECLARE_CLASS(QTimer)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+class BoundingBox;
+
+class BoundingRectHighlighter : public LiveLayerItem
+{
+ Q_OBJECT
+public:
+ explicit BoundingRectHighlighter(QDeclarativeViewObserver *view);
+ ~BoundingRectHighlighter();
+ void clear();
+ void highlight(QList<QGraphicsObject*> items);
+ void highlight(QGraphicsObject* item);
+
+private slots:
+ void refresh();
+ void animTimeout();
+ void itemDestroyed(QObject *);
+
+private:
+ BoundingBox *boxFor(QGraphicsObject *item) const;
+ void highlightAll(bool animate);
+ BoundingBox *createBoundingBox(QGraphicsObject *itemToHighlight);
+ void removeBoundingBox(BoundingBox *box);
+ void freeBoundingBox(BoundingBox *box);
+
+private:
+ Q_DISABLE_COPY(BoundingRectHighlighter)
+
+ QDeclarativeViewObserver *m_view;
+ QList<BoundingBox* > m_boxes;
+ QList<BoundingBox* > m_freeBoxes;
+ QTimer *m_animTimer;
+ qreal m_animScale;
+ int m_animFrame;
+
+};
+
+class BoundingBox : public QObject
+{
+ Q_OBJECT
+public:
+ explicit BoundingBox(QGraphicsObject *itemToHighlight, QGraphicsItem *parentItem,
+ QObject *parent = 0);
+ ~BoundingBox();
+ QWeakPointer<QGraphicsObject> highlightedObject;
+ QGraphicsPolygonItem *highlightPolygon;
+ QGraphicsPolygonItem *highlightPolygonEdge;
+
+private:
+ Q_DISABLE_COPY(BoundingBox)
+
+};
+
+class BoundingBoxPolygonItem : public QGraphicsPolygonItem
+{
+public:
+ explicit BoundingBoxPolygonItem(QGraphicsItem *item);
+ int type() const;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // BOUNDINGRECTHIGHLIGHTER_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "colorpickertool_p.h"
+
+#include "../qdeclarativeviewobserver_p.h"
+
+#include <QtGui/QMouseEvent>
+#include <QtGui/QKeyEvent>
+#include <QtCore/QRectF>
+#include <QtGui/QRgb>
+#include <QtGui/QImage>
+#include <QtGui/QApplication>
+#include <QtGui/QPalette>
+
+QT_BEGIN_NAMESPACE
+
+ColorPickerTool::ColorPickerTool(QDeclarativeViewObserver *view) :
+ AbstractLiveEditTool(view)
+{
+ m_selectedColor.setRgb(0,0,0);
+}
+
+ColorPickerTool::~ColorPickerTool()
+{
+
+}
+
+void ColorPickerTool::mousePressEvent(QMouseEvent * /*event*/)
+{
+}
+
+void ColorPickerTool::mouseMoveEvent(QMouseEvent *event)
+{
+ pickColor(event->pos());
+}
+
+void ColorPickerTool::mouseReleaseEvent(QMouseEvent *event)
+{
+ pickColor(event->pos());
+}
+
+void ColorPickerTool::mouseDoubleClickEvent(QMouseEvent * /*event*/)
+{
+}
+
+
+void ColorPickerTool::hoverMoveEvent(QMouseEvent * /*event*/)
+{
+}
+
+void ColorPickerTool::keyPressEvent(QKeyEvent * /*event*/)
+{
+}
+
+void ColorPickerTool::keyReleaseEvent(QKeyEvent * /*keyEvent*/)
+{
+}
+void ColorPickerTool::wheelEvent(QWheelEvent * /*event*/)
+{
+}
+
+void ColorPickerTool::itemsAboutToRemoved(const QList<QGraphicsItem*> &/*itemList*/)
+{
+}
+
+void ColorPickerTool::clear()
+{
+ view()->setCursor(Qt::CrossCursor);
+}
+
+void ColorPickerTool::selectedItemsChanged(const QList<QGraphicsItem*> &/*itemList*/)
+{
+}
+
+void ColorPickerTool::pickColor(const QPoint &pos)
+{
+ QRgb fillColor = view()->backgroundBrush().color().rgb();
+ if (view()->backgroundBrush().style() == Qt::NoBrush)
+ fillColor = view()->palette().color(QPalette::Base).rgb();
+
+ QRectF target(0,0, 1, 1);
+ QRect source(pos.x(), pos.y(), 1, 1);
+ QImage img(1, 1, QImage::Format_ARGB32);
+ img.fill(fillColor);
+ QPainter painter(&img);
+ view()->render(&painter, target, source);
+ m_selectedColor = QColor::fromRgb(img.pixel(0, 0));
+
+ emit selectedColorChanged(m_selectedColor);
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef COLORPICKERTOOL_H
+#define COLORPICKERTOOL_H
+
+#include "abstractliveedittool_p.h"
+
+#include <QtGui/QColor>
+
+QT_FORWARD_DECLARE_CLASS(QPoint)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class ColorPickerTool : public AbstractLiveEditTool
+{
+ Q_OBJECT
+public:
+ explicit ColorPickerTool(QDeclarativeViewObserver *view);
+
+ virtual ~ColorPickerTool();
+
+ void mousePressEvent(QMouseEvent *event);
+ void mouseMoveEvent(QMouseEvent *event);
+ void mouseReleaseEvent(QMouseEvent *event);
+ void mouseDoubleClickEvent(QMouseEvent *event);
+
+ void hoverMoveEvent(QMouseEvent *event);
+
+ void keyPressEvent(QKeyEvent *event);
+ void keyReleaseEvent(QKeyEvent *keyEvent);
+
+ void wheelEvent(QWheelEvent *event);
+
+ void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList);
+
+ void clear();
+
+signals:
+ void selectedColorChanged(const QColor &color);
+
+protected:
+
+ void selectedItemsChanged(const QList<QGraphicsItem*> &itemList);
+
+private:
+ void pickColor(const QPoint &pos);
+
+private:
+ QColor m_selectedColor;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // COLORPICKERTOOL_H
--- /dev/null
+<RCC>
+ <qresource prefix="/qml">
+ <file>images/resize_handle.png</file>
+ <file>images/select.png</file>
+ <file>images/select-marquee.png</file>
+ <file>images/color-picker.png</file>
+ <file>images/play.png</file>
+ <file>images/pause.png</file>
+ <file>images/from-qml.png</file>
+ <file>images/to-qml.png</file>
+ <file>images/color-picker-hicontrast.png</file>
+ <file>images/zoom.png</file>
+ <file>images/color-picker-24.png</file>
+ <file>images/from-qml-24.png</file>
+ <file>images/pause-24.png</file>
+ <file>images/play-24.png</file>
+ <file>images/to-qml-24.png</file>
+ <file>images/zoom-24.png</file>
+ <file>images/select-24.png</file>
+ <file>images/select-marquee-24.png</file>
+ <file>images/observermode.png</file>
+ <file>images/observermode-24.png</file>
+ </qresource>
+</RCC>
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "livelayeritem_p.h"
+
+#include "../qmlobserverconstants_p.h"
+
+#include <QGraphicsScene>
+
+QT_BEGIN_NAMESPACE
+
+LiveLayerItem::LiveLayerItem(QGraphicsScene* scene)
+ : QGraphicsObject()
+{
+ scene->addItem(this);
+ setZValue(1);
+ setFlag(QGraphicsItem::ItemIsMovable, false);
+}
+
+LiveLayerItem::~LiveLayerItem()
+{
+}
+
+void LiveLayerItem::paint(QPainter * /*painter*/, const QStyleOptionGraphicsItem * /*option*/,
+ QWidget * /*widget*/)
+{
+}
+
+int LiveLayerItem::type() const
+{
+ return Constants::EditorItemType;
+}
+
+QRectF LiveLayerItem::boundingRect() const
+{
+ return childrenBoundingRect();
+}
+
+QList<QGraphicsItem*> LiveLayerItem::findAllChildItems() const
+{
+ return findAllChildItems(this);
+}
+
+QList<QGraphicsItem*> LiveLayerItem::findAllChildItems(const QGraphicsItem *item) const
+{
+ QList<QGraphicsItem*> itemList(item->childItems());
+
+ foreach (QGraphicsItem *childItem, item->childItems())
+ itemList += findAllChildItems(childItem);
+
+ return itemList;
+}
+
+QT_END_NAMESPACE
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef PLUGINMAIN_H
-#define PLUGINMAIN_H
+#ifndef LIVELAYERITEM_H
+#define LIVELAYERITEM_H
-#include <QtDeclarative>
-#include <QtDeclarative/QDeclarativeExtensionPlugin>
+#include <QtGui/QGraphicsObject>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class ParticlesPlugin : public QDeclarativeExtensionPlugin
+class LiveLayerItem : public QGraphicsObject
{
- Q_OBJECT
public:
- virtual void registerTypes(const char *uri);
+ LiveLayerItem(QGraphicsScene *scene);
+ ~LiveLayerItem();
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+ QWidget *widget = 0);
+ QRectF boundingRect() const;
+ int type() const;
+
+ QList<QGraphicsItem*> findAllChildItems() const;
+
+protected:
+ QList<QGraphicsItem*> findAllChildItems(const QGraphicsItem *item) const;
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // PLUGINMAIN_H
+#endif // LIVELAYERITEM_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "liverubberbandselectionmanipulator_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QtGui/QGraphicsItem>
+
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+LiveRubberBandSelectionManipulator::LiveRubberBandSelectionManipulator(QGraphicsObject *layerItem,
+ QDeclarativeViewObserver *editorView)
+ : m_selectionRectangleElement(layerItem),
+ m_editorView(editorView),
+ m_beginFormEditorItem(0),
+ m_isActive(false)
+{
+ m_selectionRectangleElement.hide();
+}
+
+void LiveRubberBandSelectionManipulator::clear()
+{
+ m_selectionRectangleElement.clear();
+ m_isActive = false;
+ m_beginPoint = QPointF();
+ m_itemList.clear();
+ m_oldSelectionList.clear();
+}
+
+QGraphicsItem *LiveRubberBandSelectionManipulator::topFormEditorItem(const QList<QGraphicsItem*>
+ &itemList)
+{
+ if (itemList.isEmpty())
+ return 0;
+
+ return itemList.first();
+}
+
+void LiveRubberBandSelectionManipulator::begin(const QPointF &beginPoint)
+{
+ m_beginPoint = beginPoint;
+ m_selectionRectangleElement.setRect(m_beginPoint, m_beginPoint);
+ m_selectionRectangleElement.show();
+ m_isActive = true;
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(m_editorView);
+ m_beginFormEditorItem = topFormEditorItem(observerPrivate->selectableItems(beginPoint));
+ m_oldSelectionList = m_editorView->selectedItems();
+}
+
+void LiveRubberBandSelectionManipulator::update(const QPointF &updatePoint)
+{
+ m_selectionRectangleElement.setRect(m_beginPoint, updatePoint);
+}
+
+void LiveRubberBandSelectionManipulator::end()
+{
+ m_oldSelectionList.clear();
+ m_selectionRectangleElement.hide();
+ m_isActive = false;
+}
+
+void LiveRubberBandSelectionManipulator::select(SelectionType selectionType)
+{
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(m_editorView);
+ QList<QGraphicsItem*> itemList
+ = observerPrivate->selectableItems(m_selectionRectangleElement.rect(),
+ Qt::IntersectsItemShape);
+ QList<QGraphicsItem*> newSelectionList;
+
+ foreach (QGraphicsItem* item, itemList) {
+ if (item
+ && item->parentItem()
+ && !newSelectionList.contains(item)
+ //&& m_beginFormEditorItem->childItems().contains(item) // TODO activate this test
+ )
+ {
+ newSelectionList.append(item);
+ }
+ }
+
+ if (newSelectionList.isEmpty() && m_beginFormEditorItem)
+ newSelectionList.append(m_beginFormEditorItem);
+
+ QList<QGraphicsItem*> resultList;
+
+ switch (selectionType) {
+ case AddToSelection: {
+ resultList.append(m_oldSelectionList);
+ resultList.append(newSelectionList);
+ }
+ break;
+ case ReplaceSelection: {
+ resultList.append(newSelectionList);
+ }
+ break;
+ case RemoveFromSelection: {
+ QSet<QGraphicsItem*> oldSelectionSet(m_oldSelectionList.toSet());
+ QSet<QGraphicsItem*> newSelectionSet(newSelectionList.toSet());
+ resultList.append(oldSelectionSet.subtract(newSelectionSet).toList());
+ }
+ }
+
+ m_editorView->setSelectedItems(resultList);
+}
+
+
+void LiveRubberBandSelectionManipulator::setItems(const QList<QGraphicsItem*> &itemList)
+{
+ m_itemList = itemList;
+}
+
+QPointF LiveRubberBandSelectionManipulator::beginPoint() const
+{
+ return m_beginPoint;
+}
+
+bool LiveRubberBandSelectionManipulator::isActive() const
+{
+ return m_isActive;
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef RUBBERBANDSELECTIONMANIPULATOR_H
+#define RUBBERBANDSELECTIONMANIPULATOR_H
+
+#include "liveselectionrectangle_p.h"
+
+#include <QtCore/QPointF>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsItem)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+
+class LiveRubberBandSelectionManipulator
+{
+public:
+ enum SelectionType {
+ ReplaceSelection,
+ AddToSelection,
+ RemoveFromSelection
+ };
+
+ LiveRubberBandSelectionManipulator(QGraphicsObject *layerItem,
+ QDeclarativeViewObserver *editorView);
+
+ void setItems(const QList<QGraphicsItem*> &itemList);
+
+ void begin(const QPointF& beginPoint);
+ void update(const QPointF& updatePoint);
+ void end();
+
+ void clear();
+
+ void select(SelectionType selectionType);
+
+ QPointF beginPoint() const;
+
+ bool isActive() const;
+
+protected:
+ QGraphicsItem *topFormEditorItem(const QList<QGraphicsItem*> &itemList);
+
+private:
+ QList<QGraphicsItem*> m_itemList;
+ QList<QGraphicsItem*> m_oldSelectionList;
+ LiveSelectionRectangle m_selectionRectangleElement;
+ QPointF m_beginPoint;
+ QDeclarativeViewObserver *m_editorView;
+ QGraphicsItem *m_beginFormEditorItem;
+ bool m_isActive;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // RUBBERBANDSELECTIONMANIPULATOR_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "liveselectionindicator_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+#include "../qmlobserverconstants_p.h"
+
+#include <QtCore/QDebug>
+
+#include <QtGui/QGraphicsPolygonItem>
+#include <QtGui/QGraphicsObject>
+#include <QtGui/QGraphicsScene>
+#include <QtGui/QPen>
+
+#include <cmath>
+
+QT_BEGIN_NAMESPACE
+
+LiveSelectionIndicator::LiveSelectionIndicator(QDeclarativeViewObserver *editorView,
+ QGraphicsObject *layerItem)
+ : m_layerItem(layerItem), m_view(editorView)
+{
+}
+
+LiveSelectionIndicator::~LiveSelectionIndicator()
+{
+ clear();
+}
+
+void LiveSelectionIndicator::show()
+{
+ foreach (QGraphicsPolygonItem *item, m_indicatorShapeHash.values())
+ item->show();
+}
+
+void LiveSelectionIndicator::hide()
+{
+ foreach (QGraphicsPolygonItem *item, m_indicatorShapeHash.values())
+ item->hide();
+}
+
+void LiveSelectionIndicator::clear()
+{
+ if (!m_layerItem.isNull()) {
+ QHashIterator<QGraphicsItem*, QGraphicsPolygonItem *> iter(m_indicatorShapeHash);
+ while (iter.hasNext()) {
+ iter.next();
+ m_layerItem.data()->scene()->removeItem(iter.value());
+ delete iter.value();
+ }
+ }
+
+ m_indicatorShapeHash.clear();
+
+}
+
+QPolygonF LiveSelectionIndicator::addBoundingRectToPolygon(QGraphicsItem *item, QPolygonF &polygon)
+{
+ // ### remove this if statement when QTBUG-12172 gets fixed
+ if (item->boundingRect() != QRectF(0,0,0,0)) {
+ QPolygonF bounding = item->mapToScene(item->boundingRect());
+ if (bounding.isClosed()) //avoid crashes if there is an infinite scale.
+ polygon = polygon.united(bounding);
+ }
+
+ foreach (QGraphicsItem *child, item->childItems()) {
+ if (!QDeclarativeViewObserverPrivate::get(m_view)->isEditorItem(child))
+ addBoundingRectToPolygon(child, polygon);
+ }
+ return polygon;
+}
+
+void LiveSelectionIndicator::setItems(const QList<QWeakPointer<QGraphicsObject> > &itemList)
+{
+ clear();
+
+ // set selections to also all children if they are not editor items
+
+ foreach (const QWeakPointer<QGraphicsObject> &object, itemList) {
+ if (object.isNull())
+ continue;
+
+ QGraphicsItem *item = object.data();
+
+ QGraphicsPolygonItem *newSelectionIndicatorGraphicsItem
+ = new QGraphicsPolygonItem(m_layerItem.data());
+ if (!m_indicatorShapeHash.contains(item)) {
+ m_indicatorShapeHash.insert(item, newSelectionIndicatorGraphicsItem);
+
+ QPolygonF boundingShapeInSceneSpace;
+ addBoundingRectToPolygon(item, boundingShapeInSceneSpace);
+
+ QRectF boundingRect
+ = m_view->adjustToScreenBoundaries(boundingShapeInSceneSpace.boundingRect());
+ QPolygonF boundingRectInLayerItemSpace = m_layerItem.data()->mapFromScene(boundingRect);
+
+ QPen pen;
+ pen.setColor(QColor(108, 141, 221));
+ newSelectionIndicatorGraphicsItem->setData(Constants::EditorItemDataKey,
+ QVariant(true));
+ newSelectionIndicatorGraphicsItem->setFlag(QGraphicsItem::ItemIsSelectable, false);
+ newSelectionIndicatorGraphicsItem->setPolygon(boundingRectInLayerItemSpace);
+ newSelectionIndicatorGraphicsItem->setPen(pen);
+ }
+ }
+}
+
+QT_END_NAMESPACE
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef LIVESELECTIONINDICATOR_H
+#define LIVESELECTIONINDICATOR_H
+
+#include <QtCore/QWeakPointer>
+#include <QtCore/QHash>
+
+QT_BEGIN_NAMESPACE
+class QGraphicsObject;
+class QGraphicsPolygonItem;
+class QGraphicsItem;
+class QPolygonF;
+QT_END_NAMESPACE
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+
+class LiveSelectionIndicator
+{
+public:
+ LiveSelectionIndicator(QDeclarativeViewObserver* editorView, QGraphicsObject *layerItem);
+ ~LiveSelectionIndicator();
+
+ void show();
+ void hide();
+
+ void clear();
+
+ void setItems(const QList<QWeakPointer<QGraphicsObject> > &itemList);
+
+private:
+ QPolygonF addBoundingRectToPolygon(QGraphicsItem *item, QPolygonF &polygon);
+
+private:
+ QHash<QGraphicsItem*, QGraphicsPolygonItem *> m_indicatorShapeHash;
+ QWeakPointer<QGraphicsObject> m_layerItem;
+ QDeclarativeViewObserver *m_view;
+
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // LIVESELECTIONINDICATOR_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "liveselectionrectangle_p.h"
+
+#include "../qmlobserverconstants_p.h"
+
+#include <QtGui/QPen>
+#include <QtGui/QGraphicsRectItem>
+#include <QtGui/QGraphicsObject>
+#include <QtGui/QGraphicsScene>
+
+#include <QtCore/QtDebug>
+
+#include <cmath>
+
+QT_BEGIN_NAMESPACE
+
+class SelectionRectShape : public QGraphicsRectItem
+{
+public:
+ SelectionRectShape(QGraphicsItem *parent = 0) : QGraphicsRectItem(parent) {}
+ int type() const { return Constants::EditorItemType; }
+};
+
+LiveSelectionRectangle::LiveSelectionRectangle(QGraphicsObject *layerItem)
+ : m_controlShape(new SelectionRectShape(layerItem)),
+ m_layerItem(layerItem)
+{
+ m_controlShape->setPen(QPen(Qt::black));
+ m_controlShape->setBrush(QColor(128, 128, 128, 50));
+}
+
+LiveSelectionRectangle::~LiveSelectionRectangle()
+{
+ if (m_layerItem)
+ m_layerItem.data()->scene()->removeItem(m_controlShape);
+}
+
+void LiveSelectionRectangle::clear()
+{
+ hide();
+}
+void LiveSelectionRectangle::show()
+{
+ m_controlShape->show();
+}
+
+void LiveSelectionRectangle::hide()
+{
+ m_controlShape->hide();
+}
+
+QRectF LiveSelectionRectangle::rect() const
+{
+ return m_controlShape->mapFromScene(m_controlShape->rect()).boundingRect();
+}
+
+void LiveSelectionRectangle::setRect(const QPointF &firstPoint,
+ const QPointF &secondPoint)
+{
+ double firstX = std::floor(firstPoint.x()) + 0.5;
+ double firstY = std::floor(firstPoint.y()) + 0.5;
+ double secondX = std::floor(secondPoint.x()) + 0.5;
+ double secondY = std::floor(secondPoint.y()) + 0.5;
+ QPointF topLeftPoint(firstX < secondX ? firstX : secondX,
+ firstY < secondY ? firstY : secondY);
+ QPointF bottomRightPoint(firstX > secondX ? firstX : secondX,
+ firstY > secondY ? firstY : secondY);
+
+ QRectF rect(topLeftPoint, bottomRightPoint);
+ m_controlShape->setRect(rect);
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef LIVESELECTIONRECTANGLE_H
+#define LIVESELECTIONRECTANGLE_H
+
+#include <QtCore/QWeakPointer>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsObject)
+QT_FORWARD_DECLARE_CLASS(QGraphicsRectItem)
+QT_FORWARD_DECLARE_CLASS(QPointF)
+QT_FORWARD_DECLARE_CLASS(QRectF)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class LiveSelectionRectangle
+{
+public:
+ LiveSelectionRectangle(QGraphicsObject *layerItem);
+ ~LiveSelectionRectangle();
+
+ void show();
+ void hide();
+
+ void clear();
+
+ void setRect(const QPointF &firstPoint,
+ const QPointF &secondPoint);
+
+ QRectF rect() const;
+
+private:
+ QGraphicsRectItem *m_controlShape;
+ QWeakPointer<QGraphicsObject> m_layerItem;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // LIVESELECTIONRECTANGLE_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "liveselectiontool_p.h"
+#include "livelayeritem_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QtGui/QApplication>
+#include <QtGui/QWheelEvent>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QClipboard>
+#include <QtGui/QMenu>
+#include <QtGui/QAction>
+#include <QtGui/QGraphicsObject>
+
+#include <QtDeclarative/QDeclarativeItem>
+#include <QtDeclarative/QDeclarativeEngine>
+
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+LiveSelectionTool::LiveSelectionTool(QDeclarativeViewObserver *editorView) :
+ AbstractLiveEditTool(editorView),
+ m_rubberbandSelectionMode(false),
+ m_rubberbandSelectionManipulator(
+ QDeclarativeViewObserverPrivate::get(editorView)->manipulatorLayer, editorView),
+ m_singleSelectionManipulator(editorView),
+ m_selectionIndicator(editorView,
+ QDeclarativeViewObserverPrivate::get(editorView)->manipulatorLayer),
+ //m_resizeIndicator(editorView->manipulatorLayer()),
+ m_selectOnlyContentItems(true)
+{
+
+}
+
+LiveSelectionTool::~LiveSelectionTool()
+{
+}
+
+void LiveSelectionTool::setRubberbandSelectionMode(bool value)
+{
+ m_rubberbandSelectionMode = value;
+}
+
+LiveSingleSelectionManipulator::SelectionType LiveSelectionTool::getSelectionType(Qt::KeyboardModifiers
+ modifiers)
+{
+ LiveSingleSelectionManipulator::SelectionType selectionType
+ = LiveSingleSelectionManipulator::ReplaceSelection;
+ if (modifiers.testFlag(Qt::ControlModifier)) {
+ selectionType = LiveSingleSelectionManipulator::RemoveFromSelection;
+ } else if (modifiers.testFlag(Qt::ShiftModifier)) {
+ selectionType = LiveSingleSelectionManipulator::AddToSelection;
+ }
+ return selectionType;
+}
+
+bool LiveSelectionTool::alreadySelected(const QList<QGraphicsItem*> &itemList) const
+{
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(observer());
+ const QList<QGraphicsItem*> selectedItems = observerPrivate->selectedItems();
+
+ if (selectedItems.isEmpty())
+ return false;
+
+ foreach (QGraphicsItem *item, itemList)
+ if (selectedItems.contains(item))
+ return true;
+
+ return false;
+}
+
+void LiveSelectionTool::mousePressEvent(QMouseEvent *event)
+{
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(observer());
+ QList<QGraphicsItem*> itemList = observerPrivate->selectableItems(event->pos());
+ LiveSingleSelectionManipulator::SelectionType selectionType = getSelectionType(event->modifiers());
+
+ if (event->buttons() & Qt::LeftButton) {
+ m_mousePressTimer.start();
+
+ if (m_rubberbandSelectionMode) {
+ m_rubberbandSelectionManipulator.begin(event->pos());
+ } else {
+ m_singleSelectionManipulator.begin(event->pos());
+ m_singleSelectionManipulator.select(selectionType, m_selectOnlyContentItems);
+ }
+ } else if (event->buttons() & Qt::RightButton) {
+ createContextMenu(itemList, event->globalPos());
+ }
+}
+
+void LiveSelectionTool::createContextMenu(QList<QGraphicsItem*> itemList, QPoint globalPos)
+{
+ if (!QDeclarativeViewObserverPrivate::get(observer())->mouseInsideContextItem())
+ return;
+
+ QMenu contextMenu;
+ connect(&contextMenu, SIGNAL(hovered(QAction*)),
+ this, SLOT(contextMenuElementHovered(QAction*)));
+
+ m_contextMenuItemList = itemList;
+
+ contextMenu.addAction(tr("Items"));
+ contextMenu.addSeparator();
+ int shortcutKey = Qt::Key_1;
+ bool addKeySequence = true;
+ int i = 0;
+
+ foreach (QGraphicsItem * const item, itemList) {
+ QString itemTitle = titleForItem(item);
+ QAction *elementAction = contextMenu.addAction(itemTitle, this,
+ SLOT(contextMenuElementSelected()));
+
+ if (observer()->selectedItems().contains(item)) {
+ QFont boldFont = elementAction->font();
+ boldFont.setBold(true);
+ elementAction->setFont(boldFont);
+ }
+
+ elementAction->setData(i);
+ if (addKeySequence)
+ elementAction->setShortcut(QKeySequence(shortcutKey));
+
+ shortcutKey++;
+ if (shortcutKey > Qt::Key_9)
+ addKeySequence = false;
+
+ ++i;
+ }
+ // add root item separately
+ // QString itemTitle = QString(tr("%1")).arg(titleForItem(view()->currentRootItem()));
+ // contextMenu.addAction(itemTitle, this, SLOT(contextMenuElementSelected()));
+ // m_contextMenuItemList.append(view()->currentRootItem());
+
+ contextMenu.exec(globalPos);
+ m_contextMenuItemList.clear();
+}
+
+void LiveSelectionTool::contextMenuElementSelected()
+{
+ QAction *senderAction = static_cast<QAction*>(sender());
+ int itemListIndex = senderAction->data().toInt();
+ if (itemListIndex >= 0 && itemListIndex < m_contextMenuItemList.length()) {
+
+ QPointF updatePt(0, 0);
+ QGraphicsItem *item = m_contextMenuItemList.at(itemListIndex);
+ m_singleSelectionManipulator.begin(updatePt);
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::InvertSelection,
+ QList<QGraphicsItem*>() << item,
+ false);
+ m_singleSelectionManipulator.end(updatePt);
+ enterContext(item);
+ }
+}
+
+void LiveSelectionTool::contextMenuElementHovered(QAction *action)
+{
+ int itemListIndex = action->data().toInt();
+ if (itemListIndex >= 0 && itemListIndex < m_contextMenuItemList.length()) {
+ QGraphicsObject *item = m_contextMenuItemList.at(itemListIndex)->toGraphicsObject();
+ QDeclarativeViewObserverPrivate::get(observer())->highlight(item);
+ }
+}
+
+void LiveSelectionTool::mouseMoveEvent(QMouseEvent *event)
+{
+ if (m_singleSelectionManipulator.isActive()) {
+ QPointF mouseMovementVector = m_singleSelectionManipulator.beginPoint() - event->pos();
+
+ if ((mouseMovementVector.toPoint().manhattanLength() > Constants::DragStartDistance)
+ && (m_mousePressTimer.elapsed() > Constants::DragStartTime))
+ {
+ m_singleSelectionManipulator.end(event->pos());
+ //view()->changeToMoveTool(m_singleSelectionManipulator.beginPoint());
+ return;
+ }
+ } else if (m_rubberbandSelectionManipulator.isActive()) {
+ QPointF mouseMovementVector = m_rubberbandSelectionManipulator.beginPoint() - event->pos();
+
+ if ((mouseMovementVector.toPoint().manhattanLength() > Constants::DragStartDistance)
+ && (m_mousePressTimer.elapsed() > Constants::DragStartTime)) {
+ m_rubberbandSelectionManipulator.update(event->pos());
+
+ if (event->modifiers().testFlag(Qt::ControlModifier))
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::RemoveFromSelection);
+ else if (event->modifiers().testFlag(Qt::ShiftModifier))
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::AddToSelection);
+ else
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::ReplaceSelection);
+ }
+ }
+}
+
+void LiveSelectionTool::hoverMoveEvent(QMouseEvent * event)
+{
+// ### commented out until move tool is re-enabled
+// QList<QGraphicsItem*> itemList = view()->items(event->pos());
+// if (!itemList.isEmpty() && !m_rubberbandSelectionMode) {
+//
+// foreach (QGraphicsItem *item, itemList) {
+// if (item->type() == Constants::ResizeHandleItemType) {
+// ResizeHandleItem* resizeHandle = ResizeHandleItem::fromGraphicsItem(item);
+// if (resizeHandle)
+// view()->changeTool(Constants::ResizeToolMode);
+// return;
+// }
+// }
+// if (topSelectedItemIsMovable(itemList))
+// view()->changeTool(Constants::MoveToolMode);
+// }
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(observer());
+
+ QList<QGraphicsItem*> selectableItemList = observerPrivate->selectableItems(event->pos());
+ if (!selectableItemList.isEmpty()) {
+ QGraphicsObject *item = selectableItemList.first()->toGraphicsObject();
+ if (item)
+ QDeclarativeViewObserverPrivate::get(observer())->highlight(item);
+
+ return;
+ }
+
+ QDeclarativeViewObserverPrivate::get(observer())->clearHighlight();
+}
+
+void LiveSelectionTool::mouseReleaseEvent(QMouseEvent *event)
+{
+ if (m_singleSelectionManipulator.isActive()) {
+ m_singleSelectionManipulator.end(event->pos());
+ }
+ else if (m_rubberbandSelectionManipulator.isActive()) {
+
+ QPointF mouseMovementVector = m_rubberbandSelectionManipulator.beginPoint() - event->pos();
+ if (mouseMovementVector.toPoint().manhattanLength() < Constants::DragStartDistance) {
+ m_singleSelectionManipulator.begin(event->pos());
+
+ if (event->modifiers().testFlag(Qt::ControlModifier))
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::RemoveFromSelection,
+ m_selectOnlyContentItems);
+ else if (event->modifiers().testFlag(Qt::ShiftModifier))
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::AddToSelection,
+ m_selectOnlyContentItems);
+ else
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::InvertSelection,
+ m_selectOnlyContentItems);
+
+ m_singleSelectionManipulator.end(event->pos());
+ } else {
+ m_rubberbandSelectionManipulator.update(event->pos());
+
+ if (event->modifiers().testFlag(Qt::ControlModifier))
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::RemoveFromSelection);
+ else if (event->modifiers().testFlag(Qt::ShiftModifier))
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::AddToSelection);
+ else
+ m_rubberbandSelectionManipulator.select(
+ LiveRubberBandSelectionManipulator::ReplaceSelection);
+
+ m_rubberbandSelectionManipulator.end();
+ }
+ }
+}
+
+void LiveSelectionTool::mouseDoubleClickEvent(QMouseEvent * /*event*/)
+{
+}
+
+void LiveSelectionTool::keyPressEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Left:
+ case Qt::Key_Right:
+ case Qt::Key_Up:
+ case Qt::Key_Down:
+ // disabled for now, cannot move stuff yet.
+ //view()->changeTool(Constants::MoveToolMode);
+ //view()->currentTool()->keyPressEvent(event);
+ break;
+ }
+}
+
+void LiveSelectionTool::keyReleaseEvent(QKeyEvent * /*keyEvent*/)
+{
+
+}
+
+void LiveSelectionTool::wheelEvent(QWheelEvent *event)
+{
+ if (event->orientation() == Qt::Horizontal || m_rubberbandSelectionMode)
+ return;
+
+ QDeclarativeViewObserverPrivate *observerPrivate
+ = QDeclarativeViewObserverPrivate::get(observer());
+ QList<QGraphicsItem*> itemList = observerPrivate->selectableItems(event->pos());
+
+ if (itemList.isEmpty())
+ return;
+
+ int selectedIdx = 0;
+ if (!observer()->selectedItems().isEmpty()) {
+ selectedIdx = itemList.indexOf(observer()->selectedItems().first());
+ if (selectedIdx >= 0) {
+ if (event->delta() > 0) {
+ selectedIdx++;
+ if (selectedIdx == itemList.length())
+ selectedIdx = 0;
+ } else if (event->delta() < 0) {
+ selectedIdx--;
+ if (selectedIdx == -1)
+ selectedIdx = itemList.length() - 1;
+ }
+ } else {
+ selectedIdx = 0;
+ }
+ }
+
+ QPointF updatePt(0, 0);
+ m_singleSelectionManipulator.begin(updatePt);
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::ReplaceSelection,
+ QList<QGraphicsItem*>() << itemList.at(selectedIdx),
+ false);
+ m_singleSelectionManipulator.end(updatePt);
+
+}
+
+void LiveSelectionTool::setSelectOnlyContentItems(bool selectOnlyContentItems)
+{
+ m_selectOnlyContentItems = selectOnlyContentItems;
+}
+
+void LiveSelectionTool::itemsAboutToRemoved(const QList<QGraphicsItem*> &/*itemList*/)
+{
+}
+
+void LiveSelectionTool::clear()
+{
+ view()->setCursor(Qt::ArrowCursor);
+ m_rubberbandSelectionManipulator.clear(),
+ m_singleSelectionManipulator.clear();
+ m_selectionIndicator.clear();
+ //m_resizeIndicator.clear();
+}
+
+void LiveSelectionTool::selectedItemsChanged(const QList<QGraphicsItem*> &itemList)
+{
+ foreach (const QWeakPointer<QGraphicsObject> &obj, m_selectedItemList) {
+ if (!obj.isNull()) {
+ disconnect(obj.data(), SIGNAL(xChanged()), this, SLOT(repaintBoundingRects()));
+ disconnect(obj.data(), SIGNAL(yChanged()), this, SLOT(repaintBoundingRects()));
+ disconnect(obj.data(), SIGNAL(widthChanged()), this, SLOT(repaintBoundingRects()));
+ disconnect(obj.data(), SIGNAL(heightChanged()), this, SLOT(repaintBoundingRects()));
+ disconnect(obj.data(), SIGNAL(rotationChanged()), this, SLOT(repaintBoundingRects()));
+ }
+ }
+
+ QList<QGraphicsObject*> objects = toGraphicsObjectList(itemList);
+ m_selectedItemList.clear();
+
+ foreach (QGraphicsObject *obj, objects) {
+ m_selectedItemList.append(obj);
+ connect(obj, SIGNAL(xChanged()), this, SLOT(repaintBoundingRects()));
+ connect(obj, SIGNAL(yChanged()), this, SLOT(repaintBoundingRects()));
+ connect(obj, SIGNAL(widthChanged()), this, SLOT(repaintBoundingRects()));
+ connect(obj, SIGNAL(heightChanged()), this, SLOT(repaintBoundingRects()));
+ connect(obj, SIGNAL(rotationChanged()), this, SLOT(repaintBoundingRects()));
+ }
+
+ m_selectionIndicator.setItems(m_selectedItemList);
+ //m_resizeIndicator.setItems(toGraphicsObjectList(itemList));
+}
+
+void LiveSelectionTool::repaintBoundingRects()
+{
+ m_selectionIndicator.setItems(m_selectedItemList);
+}
+
+void LiveSelectionTool::selectUnderPoint(QMouseEvent *event)
+{
+ m_singleSelectionManipulator.begin(event->pos());
+
+ if (event->modifiers().testFlag(Qt::ControlModifier))
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::RemoveFromSelection,
+ m_selectOnlyContentItems);
+ else if (event->modifiers().testFlag(Qt::ShiftModifier))
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::AddToSelection,
+ m_selectOnlyContentItems);
+ else
+ m_singleSelectionManipulator.select(LiveSingleSelectionManipulator::InvertSelection,
+ m_selectOnlyContentItems);
+
+ m_singleSelectionManipulator.end(event->pos());
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef LIVESELECTIONTOOL_H
+#define LIVESELECTIONTOOL_H
+
+#include "abstractliveedittool_p.h"
+#include "liverubberbandselectionmanipulator_p.h"
+#include "livesingleselectionmanipulator_p.h"
+#include "liveselectionindicator_p.h"
+
+#include <QtCore/QList>
+#include <QtCore/QTime>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsItem)
+QT_FORWARD_DECLARE_CLASS(QMouseEvent)
+QT_FORWARD_DECLARE_CLASS(QKeyEvent)
+QT_FORWARD_DECLARE_CLASS(QAction)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class LiveSelectionTool : public AbstractLiveEditTool
+{
+ Q_OBJECT
+
+public:
+ LiveSelectionTool(QDeclarativeViewObserver* editorView);
+ ~LiveSelectionTool();
+
+ void mousePressEvent(QMouseEvent *event);
+ void mouseMoveEvent(QMouseEvent *event);
+ void mouseReleaseEvent(QMouseEvent *event);
+ void mouseDoubleClickEvent(QMouseEvent *event);
+ void hoverMoveEvent(QMouseEvent *event);
+ void keyPressEvent(QKeyEvent *event);
+ void keyReleaseEvent(QKeyEvent *keyEvent);
+ void wheelEvent(QWheelEvent *event);
+
+ void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList);
+// QVariant itemChange(const QList<QGraphicsItem*> &itemList,
+// QGraphicsItem::GraphicsItemChange change,
+// const QVariant &value );
+
+// void update();
+
+ void clear();
+
+ void selectedItemsChanged(const QList<QGraphicsItem*> &itemList);
+
+ void selectUnderPoint(QMouseEvent *event);
+
+ void setSelectOnlyContentItems(bool selectOnlyContentItems);
+
+ void setRubberbandSelectionMode(bool value);
+
+private slots:
+ void contextMenuElementSelected();
+ void contextMenuElementHovered(QAction *action);
+ void repaintBoundingRects();
+
+private:
+ void createContextMenu(QList<QGraphicsItem*> itemList, QPoint globalPos);
+ LiveSingleSelectionManipulator::SelectionType getSelectionType(Qt::KeyboardModifiers modifiers);
+ bool alreadySelected(const QList<QGraphicsItem*> &itemList) const;
+
+private:
+ bool m_rubberbandSelectionMode;
+ LiveRubberBandSelectionManipulator m_rubberbandSelectionManipulator;
+ LiveSingleSelectionManipulator m_singleSelectionManipulator;
+ LiveSelectionIndicator m_selectionIndicator;
+ //ResizeIndicator m_resizeIndicator;
+ QTime m_mousePressTimer;
+ bool m_selectOnlyContentItems;
+
+ QList<QWeakPointer<QGraphicsObject> > m_selectedItemList;
+
+ QList<QGraphicsItem*> m_contextMenuItemList;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // LIVESELECTIONTOOL_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "livesingleselectionmanipulator_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QtDebug>
+
+QT_BEGIN_NAMESPACE
+
+LiveSingleSelectionManipulator::LiveSingleSelectionManipulator(QDeclarativeViewObserver *editorView)
+ : m_editorView(editorView),
+ m_isActive(false)
+{
+}
+
+
+void LiveSingleSelectionManipulator::begin(const QPointF &beginPoint)
+{
+ m_beginPoint = beginPoint;
+ m_isActive = true;
+ m_oldSelectionList = QDeclarativeViewObserverPrivate::get(m_editorView)->selectedItems();
+}
+
+void LiveSingleSelectionManipulator::update(const QPointF &/*updatePoint*/)
+{
+ m_oldSelectionList.clear();
+}
+
+void LiveSingleSelectionManipulator::clear()
+{
+ m_beginPoint = QPointF();
+ m_oldSelectionList.clear();
+}
+
+
+void LiveSingleSelectionManipulator::end(const QPointF &/*updatePoint*/)
+{
+ m_oldSelectionList.clear();
+ m_isActive = false;
+}
+
+void LiveSingleSelectionManipulator::select(SelectionType selectionType,
+ const QList<QGraphicsItem*> &items,
+ bool /*selectOnlyContentItems*/)
+{
+ QGraphicsItem *selectedItem = 0;
+
+ foreach (QGraphicsItem* item, items)
+ {
+ //FormEditorItem *formEditorItem = FormEditorItem::fromQGraphicsItem(item);
+ if (item
+ /*&& !formEditorItem->qmlItemNode().isRootNode()
+ && (formEditorItem->qmlItemNode().hasShowContent() || !selectOnlyContentItems)*/)
+ {
+ selectedItem = item;
+ break;
+ }
+ }
+
+ QList<QGraphicsItem*> resultList;
+
+ switch (selectionType) {
+ case AddToSelection: {
+ resultList.append(m_oldSelectionList);
+ if (selectedItem && !m_oldSelectionList.contains(selectedItem))
+ resultList.append(selectedItem);
+ }
+ break;
+ case ReplaceSelection: {
+ if (selectedItem)
+ resultList.append(selectedItem);
+ }
+ break;
+ case RemoveFromSelection: {
+ resultList.append(m_oldSelectionList);
+ if (selectedItem)
+ resultList.removeAll(selectedItem);
+ }
+ break;
+ case InvertSelection: {
+ if (selectedItem
+ && !m_oldSelectionList.contains(selectedItem))
+ {
+ resultList.append(selectedItem);
+ }
+ }
+ }
+
+ m_editorView->setSelectedItems(resultList);
+}
+
+void LiveSingleSelectionManipulator::select(SelectionType selectionType, bool selectOnlyContentItems)
+{
+ QDeclarativeViewObserverPrivate *observerPrivate =
+ QDeclarativeViewObserverPrivate::get(m_editorView);
+ QList<QGraphicsItem*> itemList = observerPrivate->selectableItems(m_beginPoint);
+ select(selectionType, itemList, selectOnlyContentItems);
+}
+
+
+bool LiveSingleSelectionManipulator::isActive() const
+{
+ return m_isActive;
+}
+
+QPointF LiveSingleSelectionManipulator::beginPoint() const
+{
+ return m_beginPoint;
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef LIVESINGLESELECTIONMANIPULATOR_H
+#define LIVESINGLESELECTIONMANIPULATOR_H
+
+#include <QtCore/QPointF>
+#include <QtCore/QList>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsItem)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+
+class LiveSingleSelectionManipulator
+{
+public:
+ LiveSingleSelectionManipulator(QDeclarativeViewObserver *editorView);
+
+ enum SelectionType {
+ ReplaceSelection,
+ AddToSelection,
+ RemoveFromSelection,
+ InvertSelection
+ };
+
+ void begin(const QPointF& beginPoint);
+ void update(const QPointF& updatePoint);
+ void end(const QPointF& updatePoint);
+
+ void select(SelectionType selectionType, const QList<QGraphicsItem*> &items,
+ bool selectOnlyContentItems);
+ void select(SelectionType selectionType, bool selectOnlyContentItems);
+
+ void clear();
+
+ QPointF beginPoint() const;
+
+ bool isActive() const;
+
+private:
+ QList<QGraphicsItem*> m_oldSelectionList;
+ QPointF m_beginPoint;
+ QDeclarativeViewObserver *m_editorView;
+ bool m_isActive;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // LIVESINGLESELECTIONMANIPULATOR_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmltoolbar_p.h"
+#include "toolbarcolorbox_p.h"
+
+#include <QtGui/QLabel>
+#include <QtGui/QIcon>
+#include <QtGui/QAction>
+#include <QtGui/QMenu>
+
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+QmlToolBar::QmlToolBar(QWidget *parent)
+ : QToolBar(parent)
+ , m_emitSignals(true)
+ , m_paused(false)
+ , m_animationSpeed(1.0f)
+ , ui(new Ui)
+{
+ ui->playIcon = QIcon(QLatin1String(":/qml/images/play-24.png"));
+ ui->pauseIcon = QIcon(QLatin1String(":/qml/images/pause-24.png"));
+
+ ui->designmode = new QAction(QIcon(QLatin1String(":/qml/images/observermode-24.png")),
+ tr("Observer Mode"), this);
+ ui->play = new QAction(ui->pauseIcon, tr("Play/Pause Animations"), this);
+ ui->select = new QAction(QIcon(QLatin1String(":/qml/images/select-24.png")), tr("Select"), this);
+ ui->selectMarquee = new QAction(QIcon(QLatin1String(":/qml/images/select-marquee-24.png")),
+ tr("Select (Marquee)"), this);
+ ui->zoom = new QAction(QIcon(QLatin1String(":/qml/images/zoom-24.png")), tr("Zoom"), this);
+ ui->colorPicker = new QAction(QIcon(QLatin1String(":/qml/images/color-picker-24.png")),
+ tr("Color Picker"), this);
+ ui->toQml = new QAction(QIcon(QLatin1String(":/qml/images/to-qml-24.png")),
+ tr("Apply Changes to QML Viewer"), this);
+ ui->fromQml = new QAction(QIcon(QLatin1String(":/qml/images/from-qml-24.png")),
+ tr("Apply Changes to Document"), this);
+ ui->designmode->setCheckable(true);
+ ui->designmode->setChecked(false);
+
+ ui->play->setCheckable(false);
+ ui->select->setCheckable(true);
+ ui->selectMarquee->setCheckable(true);
+ ui->zoom->setCheckable(true);
+ ui->colorPicker->setCheckable(true);
+
+ setWindowTitle(tr("Tools"));
+
+ addAction(ui->designmode);
+ addAction(ui->play);
+ addSeparator();
+
+ addAction(ui->select);
+ // disabled because multi selection does not do anything useful without design mode
+ //addAction(ui->selectMarquee);
+ addSeparator();
+ addAction(ui->zoom);
+ addAction(ui->colorPicker);
+ //addAction(ui->fromQml);
+
+ ui->colorBox = new ToolBarColorBox(this);
+ ui->colorBox->setMinimumSize(24, 24);
+ ui->colorBox->setMaximumSize(28, 28);
+ ui->colorBox->setColor(Qt::black);
+ addWidget(ui->colorBox);
+
+ setWindowFlags(Qt::Tool);
+
+ QMenu *playSpeedMenu = new QMenu(this);
+ ui->playSpeedMenuActions = new QActionGroup(this);
+ ui->playSpeedMenuActions->setExclusive(true);
+
+ QAction *speedAction = playSpeedMenu->addAction(tr("1x"), this, SLOT(changeAnimationSpeed()));
+ speedAction->setCheckable(true);
+ speedAction->setChecked(true);
+ speedAction->setData(1.0f);
+ ui->playSpeedMenuActions->addAction(speedAction);
+
+ speedAction = playSpeedMenu->addAction(tr("0.5x"), this, SLOT(changeAnimationSpeed()));
+ speedAction->setCheckable(true);
+ speedAction->setData(2.0f);
+ ui->playSpeedMenuActions->addAction(speedAction);
+
+ speedAction = playSpeedMenu->addAction(tr("0.25x"), this, SLOT(changeAnimationSpeed()));
+ speedAction->setCheckable(true);
+ speedAction->setData(4.0f);
+ ui->playSpeedMenuActions->addAction(speedAction);
+
+ speedAction = playSpeedMenu->addAction(tr("0.125x"), this, SLOT(changeAnimationSpeed()));
+ speedAction->setCheckable(true);
+ speedAction->setData(8.0f);
+ ui->playSpeedMenuActions->addAction(speedAction);
+
+ speedAction = playSpeedMenu->addAction(tr("0.1x"), this, SLOT(changeAnimationSpeed()));
+ speedAction->setCheckable(true);
+ speedAction->setData(10.0f);
+ ui->playSpeedMenuActions->addAction(speedAction);
+
+ ui->play->setMenu(playSpeedMenu);
+
+ connect(ui->designmode, SIGNAL(toggled(bool)), SLOT(setDesignModeBehaviorOnClick(bool)));
+
+ connect(ui->colorPicker, SIGNAL(triggered()), SLOT(activateColorPickerOnClick()));
+
+ connect(ui->play, SIGNAL(triggered()), SLOT(activatePlayOnClick()));
+
+ connect(ui->zoom, SIGNAL(triggered()), SLOT(activateZoomOnClick()));
+ connect(ui->colorPicker, SIGNAL(triggered()), SLOT(activateColorPickerOnClick()));
+ connect(ui->select, SIGNAL(triggered()), SLOT(activateSelectToolOnClick()));
+ connect(ui->selectMarquee, SIGNAL(triggered()), SLOT(activateMarqueeSelectToolOnClick()));
+
+ connect(ui->toQml, SIGNAL(triggered()), SLOT(activateToQml()));
+ connect(ui->fromQml, SIGNAL(triggered()), SLOT(activateFromQml()));
+}
+
+QmlToolBar::~QmlToolBar()
+{
+ delete ui;
+}
+
+void QmlToolBar::activateColorPicker()
+{
+ m_emitSignals = false;
+ activateColorPickerOnClick();
+ m_emitSignals = true;
+}
+
+void QmlToolBar::activateSelectTool()
+{
+ m_emitSignals = false;
+ activateSelectToolOnClick();
+ m_emitSignals = true;
+}
+
+void QmlToolBar::activateMarqueeSelectTool()
+{
+ m_emitSignals = false;
+ activateMarqueeSelectToolOnClick();
+ m_emitSignals = true;
+}
+
+void QmlToolBar::activateZoom()
+{
+ m_emitSignals = false;
+ activateZoomOnClick();
+ m_emitSignals = true;
+}
+
+void QmlToolBar::setAnimationSpeed(qreal slowDownFactor)
+{
+ if (m_animationSpeed == slowDownFactor)
+ return;
+
+ m_emitSignals = false;
+ m_animationSpeed = slowDownFactor;
+
+ foreach (QAction *action, ui->playSpeedMenuActions->actions()) {
+ if (action->data().toReal() == slowDownFactor) {
+ action->setChecked(true);
+ break;
+ }
+ }
+
+ m_emitSignals = true;
+}
+
+void QmlToolBar::setAnimationPaused(bool paused)
+{
+ if (m_paused == paused)
+ return;
+
+ m_paused = paused;
+ updatePlayAction();
+}
+
+void QmlToolBar::changeAnimationSpeed()
+{
+ QAction *action = qobject_cast<QAction*>(sender());
+ m_animationSpeed = action->data().toReal();
+ emit animationSpeedChanged(m_animationSpeed);
+}
+
+void QmlToolBar::setDesignModeBehavior(bool inDesignMode)
+{
+ m_emitSignals = false;
+ ui->designmode->setChecked(inDesignMode);
+ setDesignModeBehaviorOnClick(inDesignMode);
+ m_emitSignals = true;
+}
+
+void QmlToolBar::setDesignModeBehaviorOnClick(bool checked)
+{
+ ui->select->setEnabled(checked);
+ ui->selectMarquee->setEnabled(checked);
+ ui->zoom->setEnabled(checked);
+ ui->colorPicker->setEnabled(checked);
+ ui->toQml->setEnabled(checked);
+ ui->fromQml->setEnabled(checked);
+
+ if (m_emitSignals)
+ emit designModeBehaviorChanged(checked);
+}
+
+void QmlToolBar::setColorBoxColor(const QColor &color)
+{
+ ui->colorBox->setColor(color);
+}
+
+void QmlToolBar::activatePlayOnClick()
+{
+ m_paused = !m_paused;
+ emit animationPausedChanged(m_paused);
+ updatePlayAction();
+}
+
+void QmlToolBar::updatePlayAction()
+{
+ ui->play->setIcon(m_paused ? ui->playIcon : ui->pauseIcon);
+}
+
+void QmlToolBar::activateColorPickerOnClick()
+{
+ ui->zoom->setChecked(false);
+ ui->select->setChecked(false);
+ ui->selectMarquee->setChecked(false);
+
+ ui->colorPicker->setChecked(true);
+ if (m_activeTool != Constants::ColorPickerMode) {
+ m_activeTool = Constants::ColorPickerMode;
+ if (m_emitSignals)
+ emit colorPickerSelected();
+ }
+}
+
+void QmlToolBar::activateSelectToolOnClick()
+{
+ ui->zoom->setChecked(false);
+ ui->selectMarquee->setChecked(false);
+ ui->colorPicker->setChecked(false);
+
+ ui->select->setChecked(true);
+ if (m_activeTool != Constants::SelectionToolMode) {
+ m_activeTool = Constants::SelectionToolMode;
+ if (m_emitSignals)
+ emit selectToolSelected();
+ }
+}
+
+void QmlToolBar::activateMarqueeSelectToolOnClick()
+{
+ ui->zoom->setChecked(false);
+ ui->select->setChecked(false);
+ ui->colorPicker->setChecked(false);
+
+ ui->selectMarquee->setChecked(true);
+ if (m_activeTool != Constants::MarqueeSelectionToolMode) {
+ m_activeTool = Constants::MarqueeSelectionToolMode;
+ if (m_emitSignals)
+ emit marqueeSelectToolSelected();
+ }
+}
+
+void QmlToolBar::activateZoomOnClick()
+{
+ ui->select->setChecked(false);
+ ui->selectMarquee->setChecked(false);
+ ui->colorPicker->setChecked(false);
+
+ ui->zoom->setChecked(true);
+ if (m_activeTool != Constants::ZoomMode) {
+ m_activeTool = Constants::ZoomMode;
+ if (m_emitSignals)
+ emit zoomToolSelected();
+ }
+}
+
+void QmlToolBar::activateFromQml()
+{
+ if (m_emitSignals)
+ emit applyChangesFromQmlFileSelected();
+}
+
+void QmlToolBar::activateToQml()
+{
+ if (m_emitSignals)
+ emit applyChangesToQmlFileSelected();
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLTOOLBAR_H
+#define QMLTOOLBAR_H
+
+#include <QtGui/QToolBar>
+#include <QtGui/QIcon>
+
+#include "../qmlobserverconstants_p.h"
+
+QT_FORWARD_DECLARE_CLASS(QActionGroup)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class ToolBarColorBox;
+
+class QmlToolBar : public QToolBar
+{
+ Q_OBJECT
+
+public:
+ explicit QmlToolBar(QWidget *parent = 0);
+ ~QmlToolBar();
+
+public slots:
+ void setDesignModeBehavior(bool inDesignMode);
+ void setColorBoxColor(const QColor &color);
+ void activateColorPicker();
+ void activateSelectTool();
+ void activateMarqueeSelectTool();
+ void activateZoom();
+
+ void setAnimationSpeed(qreal slowDownFactor);
+ void setAnimationPaused(bool paused);
+
+signals:
+ void animationSpeedChanged(qreal factor);
+ void animationPausedChanged(bool paused);
+
+ void designModeBehaviorChanged(bool inDesignMode);
+ void colorPickerSelected();
+ void selectToolSelected();
+ void marqueeSelectToolSelected();
+ void zoomToolSelected();
+
+ void applyChangesToQmlFileSelected();
+ void applyChangesFromQmlFileSelected();
+
+private slots:
+ void setDesignModeBehaviorOnClick(bool inDesignMode);
+ void activatePlayOnClick();
+ void activateColorPickerOnClick();
+ void activateSelectToolOnClick();
+ void activateMarqueeSelectToolOnClick();
+ void activateZoomOnClick();
+
+ void activateFromQml();
+ void activateToQml();
+
+ void changeAnimationSpeed();
+
+ void updatePlayAction();
+
+private:
+ class Ui {
+ public:
+ QAction *designmode;
+ QAction *play;
+ QAction *select;
+ QAction *selectMarquee;
+ QAction *zoom;
+ QAction *colorPicker;
+ QAction *toQml;
+ QAction *fromQml;
+ QIcon playIcon;
+ QIcon pauseIcon;
+ ToolBarColorBox *colorBox;
+
+ QActionGroup *playSpeedMenuActions;
+ };
+
+ bool m_emitSignals;
+ bool m_paused;
+ qreal m_animationSpeed;
+
+ Constants::DesignTool m_activeTool;
+
+ Ui *ui;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QMLTOOLBAR_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "subcomponenteditortool_p.h"
+#include "subcomponentmasklayeritem_p.h"
+#include "livelayeritem_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QtGui/QGraphicsItem>
+#include <QtGui/QGraphicsObject>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QKeyEvent>
+
+#include <QtCore/QTimer>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+const qreal MaxOpacity = 0.5f;
+
+SubcomponentEditorTool::SubcomponentEditorTool(QDeclarativeViewObserver *view)
+ : AbstractLiveEditTool(view),
+ m_animIncrement(0.05f),
+ m_animTimer(new QTimer(this))
+{
+ QDeclarativeViewObserverPrivate *observerPrivate =
+ QDeclarativeViewObserverPrivate::get(view);
+ m_mask = new SubcomponentMaskLayerItem(view, observerPrivate->manipulatorLayer);
+ connect(m_animTimer, SIGNAL(timeout()), SLOT(animate()));
+ m_animTimer->setInterval(20);
+}
+
+SubcomponentEditorTool::~SubcomponentEditorTool()
+{
+
+}
+
+void SubcomponentEditorTool::mousePressEvent(QMouseEvent * /*event*/)
+{
+
+}
+
+void SubcomponentEditorTool::mouseMoveEvent(QMouseEvent * /*event*/)
+{
+
+}
+
+bool SubcomponentEditorTool::containsCursor(const QPoint &mousePos) const
+{
+ if (!m_currentContext.size())
+ return false;
+
+ QPointF scenePos = view()->mapToScene(mousePos);
+ QRectF itemRect = m_currentContext.top()->boundingRect()
+ | m_currentContext.top()->childrenBoundingRect();
+ QRectF polyRect = m_currentContext.top()->mapToScene(itemRect).boundingRect();
+
+ return polyRect.contains(scenePos);
+}
+
+void SubcomponentEditorTool::mouseReleaseEvent(QMouseEvent * /*event*/)
+{
+
+}
+
+void SubcomponentEditorTool::mouseDoubleClickEvent(QMouseEvent *event)
+{
+ if (event->buttons() & Qt::LeftButton
+ && !containsCursor(event->pos())
+ && m_currentContext.size() > 1)
+ {
+ aboutToPopContext();
+ }
+}
+
+void SubcomponentEditorTool::hoverMoveEvent(QMouseEvent *event)
+{
+ if (!containsCursor(event->pos()) && m_currentContext.size() > 1) {
+ QDeclarativeViewObserverPrivate::get(observer())->clearHighlight();
+ }
+}
+
+void SubcomponentEditorTool::wheelEvent(QWheelEvent * /*event*/)
+{
+
+}
+
+void SubcomponentEditorTool::keyPressEvent(QKeyEvent * /*event*/)
+{
+
+}
+
+void SubcomponentEditorTool::keyReleaseEvent(QKeyEvent * /*keyEvent*/)
+{
+
+}
+
+void SubcomponentEditorTool::itemsAboutToRemoved(const QList<QGraphicsItem*> &/*itemList*/)
+{
+
+}
+
+void SubcomponentEditorTool::animate()
+{
+ if (m_animIncrement > 0) {
+ if (m_mask->opacity() + m_animIncrement < MaxOpacity) {
+ m_mask->setOpacity(m_mask->opacity() + m_animIncrement);
+ } else {
+ m_animTimer->stop();
+ m_mask->setOpacity(MaxOpacity);
+ }
+ } else {
+ if (m_mask->opacity() + m_animIncrement > 0) {
+ m_mask->setOpacity(m_mask->opacity() + m_animIncrement);
+ } else {
+ m_animTimer->stop();
+ m_mask->setOpacity(0);
+ popContext();
+ emit contextPathChanged(m_path);
+ }
+ }
+
+}
+
+void SubcomponentEditorTool::clear()
+{
+ m_currentContext.clear();
+ m_mask->setCurrentItem(0);
+ m_animTimer->stop();
+ m_mask->hide();
+ m_path.clear();
+
+ emit contextPathChanged(m_path);
+ emit cleared();
+}
+
+void SubcomponentEditorTool::selectedItemsChanged(const QList<QGraphicsItem*> &/*itemList*/)
+{
+
+}
+
+void SubcomponentEditorTool::setCurrentItem(QGraphicsItem* contextItem)
+{
+ if (!contextItem)
+ return;
+
+ QGraphicsObject *gfxObject = contextItem->toGraphicsObject();
+ if (!gfxObject)
+ return;
+
+ //QString parentClassName = gfxObject->metaObject()->className();
+ //if (parentClassName.contains(QRegExp("_QMLTYPE_\\d+")))
+
+ bool containsSelectableItems = false;
+ foreach (QGraphicsItem *item, gfxObject->childItems()) {
+ if (item->type() == Constants::EditorItemType
+ || item->type() == Constants::ResizeHandleItemType)
+ {
+ continue;
+ }
+ containsSelectableItems = true;
+ break;
+ }
+
+ if (containsSelectableItems) {
+ m_mask->setCurrentItem(gfxObject);
+ m_mask->setOpacity(0);
+ m_mask->show();
+ m_animIncrement = 0.05f;
+ m_animTimer->start();
+
+ QDeclarativeViewObserverPrivate::get(observer())->clearHighlight();
+ observer()->setSelectedItems(QList<QGraphicsItem*>());
+
+ pushContext(gfxObject);
+ }
+}
+
+QGraphicsItem *SubcomponentEditorTool::firstChildOfContext(QGraphicsItem *item) const
+{
+ if (!item)
+ return 0;
+
+ if (isDirectChildOfContext(item))
+ return item;
+
+ QGraphicsItem *parent = item->parentItem();
+ while (parent) {
+ if (isDirectChildOfContext(parent))
+ return parent;
+ parent = parent->parentItem();
+ }
+
+ return 0;
+}
+
+bool SubcomponentEditorTool::isChildOfContext(QGraphicsItem *item) const
+{
+ return (firstChildOfContext(item) != 0);
+}
+
+bool SubcomponentEditorTool::isDirectChildOfContext(QGraphicsItem *item) const
+{
+ return (item->parentItem() == m_currentContext.top());
+}
+
+bool SubcomponentEditorTool::itemIsChildOfQmlSubComponent(QGraphicsItem *item) const
+{
+ if (item->parentItem() && item->parentItem() != m_currentContext.top()) {
+ QGraphicsObject *parent = item->parentItem()->toGraphicsObject();
+ QString parentClassName = QLatin1String(parent->metaObject()->className());
+
+ if (parentClassName.contains(QRegExp(QLatin1String("_QMLTYPE_\\d+")))) {
+ return true;
+ } else {
+ return itemIsChildOfQmlSubComponent(parent);
+ }
+ }
+
+ return false;
+}
+
+void SubcomponentEditorTool::pushContext(QGraphicsObject *contextItem)
+{
+ connect(contextItem, SIGNAL(destroyed(QObject*)), this, SLOT(contextDestroyed(QObject*)));
+ connect(contextItem, SIGNAL(xChanged()), this, SLOT(resizeMask()));
+ connect(contextItem, SIGNAL(yChanged()), this, SLOT(resizeMask()));
+ connect(contextItem, SIGNAL(widthChanged()), this, SLOT(resizeMask()));
+ connect(contextItem, SIGNAL(heightChanged()), this, SLOT(resizeMask()));
+ connect(contextItem, SIGNAL(rotationChanged()), this, SLOT(resizeMask()));
+
+ m_currentContext.push(contextItem);
+ QString title = titleForItem(contextItem);
+ emit contextPushed(title);
+
+ m_path << title;
+ emit contextPathChanged(m_path);
+}
+
+void SubcomponentEditorTool::aboutToPopContext()
+{
+ if (m_currentContext.size() > 2) {
+ popContext();
+ emit contextPathChanged(m_path);
+ } else {
+ m_animIncrement = -0.05f;
+ m_animTimer->start();
+ }
+}
+
+QGraphicsObject *SubcomponentEditorTool::popContext()
+{
+ QGraphicsObject *popped = m_currentContext.pop();
+ m_path.removeLast();
+
+ emit contextPopped();
+
+ disconnect(popped, SIGNAL(xChanged()), this, SLOT(resizeMask()));
+ disconnect(popped, SIGNAL(yChanged()), this, SLOT(resizeMask()));
+ disconnect(popped, SIGNAL(scaleChanged()), this, SLOT(resizeMask()));
+ disconnect(popped, SIGNAL(widthChanged()), this, SLOT(resizeMask()));
+ disconnect(popped, SIGNAL(heightChanged()), this, SLOT(resizeMask()));
+
+ if (m_currentContext.size() > 1) {
+ QGraphicsObject *item = m_currentContext.top();
+ m_mask->setCurrentItem(item);
+ m_mask->setOpacity(MaxOpacity);
+ m_mask->setVisible(true);
+ } else {
+ m_mask->setVisible(false);
+ }
+
+ return popped;
+}
+
+void SubcomponentEditorTool::resizeMask()
+{
+ QGraphicsObject *item = m_currentContext.top();
+ m_mask->setCurrentItem(item);
+}
+
+QGraphicsObject *SubcomponentEditorTool::currentRootItem() const
+{
+ return m_currentContext.top();
+}
+
+void SubcomponentEditorTool::contextDestroyed(QObject *contextToDestroy)
+{
+ disconnect(contextToDestroy, SIGNAL(destroyed(QObject*)),
+ this, SLOT(contextDestroyed(QObject*)));
+
+ // pop out the whole context - it might not be safe anymore.
+ while (m_currentContext.size() > 1) {
+ m_currentContext.pop();
+ m_path.removeLast();
+ emit contextPopped();
+ }
+ m_mask->setVisible(false);
+
+ emit contextPathChanged(m_path);
+}
+
+QGraphicsObject *SubcomponentEditorTool::setContext(int contextIndex)
+{
+ Q_ASSERT(contextIndex >= 0);
+
+ // sometimes we have to delete the context while user was still clicking around,
+ // so just bail out.
+ if (contextIndex >= m_currentContext.size() -1)
+ return 0;
+
+ while (m_currentContext.size() - 1 > contextIndex) {
+ popContext();
+ }
+ emit contextPathChanged(m_path);
+
+ return m_currentContext.top();
+}
+
+int SubcomponentEditorTool::contextIndex() const
+{
+ return m_currentContext.size() - 1;
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SUBCOMPONENTEDITORTOOL_H
+#define SUBCOMPONENTEDITORTOOL_H
+
+#include "abstractliveedittool_p.h"
+
+#include <QtCore/QStack>
+#include <QtCore/QStringList>
+
+QT_FORWARD_DECLARE_CLASS(QGraphicsObject)
+QT_FORWARD_DECLARE_CLASS(QPoint)
+QT_FORWARD_DECLARE_CLASS(QTimer)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class SubcomponentMaskLayerItem;
+
+class SubcomponentEditorTool : public AbstractLiveEditTool
+{
+ Q_OBJECT
+
+public:
+ SubcomponentEditorTool(QDeclarativeViewObserver *view);
+ ~SubcomponentEditorTool();
+
+ void mousePressEvent(QMouseEvent *event);
+ void mouseMoveEvent(QMouseEvent *event);
+ void mouseReleaseEvent(QMouseEvent *event);
+ void mouseDoubleClickEvent(QMouseEvent *event);
+
+ void hoverMoveEvent(QMouseEvent *event);
+ void wheelEvent(QWheelEvent *event);
+
+ void keyPressEvent(QKeyEvent *event);
+ void keyReleaseEvent(QKeyEvent *keyEvent);
+ void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList);
+
+ void clear();
+
+ bool containsCursor(const QPoint &mousePos) const;
+ bool itemIsChildOfQmlSubComponent(QGraphicsItem *item) const;
+
+ bool isChildOfContext(QGraphicsItem *item) const;
+ bool isDirectChildOfContext(QGraphicsItem *item) const;
+ QGraphicsItem *firstChildOfContext(QGraphicsItem *item) const;
+
+ void setCurrentItem(QGraphicsItem *contextObject);
+
+ void pushContext(QGraphicsObject *contextItem);
+
+ QGraphicsObject *currentRootItem() const;
+ QGraphicsObject *setContext(int contextIndex);
+ int contextIndex() const;
+
+signals:
+ void exitContextRequested();
+ void cleared();
+ void contextPushed(const QString &contextTitle);
+ void contextPopped();
+ void contextPathChanged(const QStringList &path);
+
+protected:
+ void selectedItemsChanged(const QList<QGraphicsItem*> &itemList);
+
+private slots:
+ void animate();
+ void contextDestroyed(QObject *context);
+ void resizeMask();
+
+private:
+ QGraphicsObject *popContext();
+ void aboutToPopContext();
+
+private:
+ QStack<QGraphicsObject *> m_currentContext;
+ QStringList m_path;
+
+ qreal m_animIncrement;
+ SubcomponentMaskLayerItem *m_mask;
+ QTimer *m_animTimer;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // SUBCOMPONENTEDITORTOOL_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "subcomponentmasklayeritem_p.h"
+
+#include "../qmlobserverconstants_p.h"
+#include "../qdeclarativeviewobserver_p.h"
+
+#include <QtGui/QPolygonF>
+
+QT_BEGIN_NAMESPACE
+
+SubcomponentMaskLayerItem::SubcomponentMaskLayerItem(QDeclarativeViewObserver *observer,
+ QGraphicsItem *parentItem) :
+ QGraphicsPolygonItem(parentItem),
+ m_observer(observer),
+ m_currentItem(0),
+ m_borderRect(new QGraphicsRectItem(this))
+{
+ m_borderRect->setRect(0,0,0,0);
+ m_borderRect->setPen(QPen(QColor(60, 60, 60), 1));
+ m_borderRect->setData(Constants::EditorItemDataKey, QVariant(true));
+
+ setBrush(QBrush(QColor(160,160,160)));
+ setPen(Qt::NoPen);
+}
+
+int SubcomponentMaskLayerItem::type() const
+{
+ return Constants::EditorItemType;
+}
+
+static QRectF resizeRect(const QRectF &newRect, const QRectF &oldRect)
+{
+ QRectF result = newRect;
+ if (oldRect.left() < newRect.left())
+ result.setLeft(oldRect.left());
+
+ if (oldRect.top() < newRect.top())
+ result.setTop(oldRect.top());
+
+ if (oldRect.right() > newRect.right())
+ result.setRight(oldRect.right());
+
+ if (oldRect.bottom() > newRect.bottom())
+ result.setBottom(oldRect.bottom());
+
+ return result;
+}
+
+
+void SubcomponentMaskLayerItem::setCurrentItem(QGraphicsItem *item)
+{
+ QGraphicsItem *prevItem = m_currentItem;
+ m_currentItem = item;
+
+ if (!m_currentItem)
+ return;
+
+ QPolygonF viewPoly(QRectF(m_observer->declarativeView()->rect()));
+ viewPoly = m_observer->declarativeView()->mapToScene(viewPoly.toPolygon());
+
+ QRectF itemRect = item->boundingRect() | item->childrenBoundingRect();
+ QPolygonF itemPoly(itemRect);
+ itemPoly = item->mapToScene(itemPoly);
+
+ // if updating the same item as before, resize the rectangle only bigger, not smaller.
+ if (prevItem == item && prevItem != 0) {
+ m_itemPolyRect = resizeRect(itemPoly.boundingRect(), m_itemPolyRect);
+ } else {
+ m_itemPolyRect = itemPoly.boundingRect();
+ }
+ QRectF borderRect = m_itemPolyRect;
+ borderRect.adjust(-1, -1, 1, 1);
+ m_borderRect->setRect(borderRect);
+
+ itemPoly = viewPoly.subtracted(QPolygonF(m_itemPolyRect));
+ setPolygon(itemPoly);
+}
+
+QGraphicsItem *SubcomponentMaskLayerItem::currentItem() const
+{
+ return m_currentItem;
+}
+
+QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SUBCOMPONENTMASKLAYERITEM_H
+#define SUBCOMPONENTMASKLAYERITEM_H
+
+#include <QtGui/QGraphicsPolygonItem>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+
+class SubcomponentMaskLayerItem : public QGraphicsPolygonItem
+{
+public:
+ explicit SubcomponentMaskLayerItem(QDeclarativeViewObserver *observer,
+ QGraphicsItem *parentItem = 0);
+ int type() const;
+ void setCurrentItem(QGraphicsItem *item);
+ void setBoundingBox(const QRectF &boundingBox);
+ QGraphicsItem *currentItem() const;
+ QRectF itemRect() const;
+
+private:
+ QDeclarativeViewObserver *m_observer;
+ QGraphicsItem *m_currentItem;
+ QGraphicsRectItem *m_borderRect;
+ QRectF m_itemPolyRect;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // SUBCOMPONENTMASKLAYERITEM_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "toolbarcolorbox_p.h"
+
+#include "../qmlobserverconstants_p.h"
+
+#include <QtGui/QPixmap>
+#include <QtGui/QPainter>
+#include <QtGui/QMenu>
+#include <QtGui/QAction>
+#include <QtGui/QContextMenuEvent>
+#include <QtGui/QClipboard>
+#include <QtGui/QApplication>
+#include <QtGui/QColorDialog>
+#include <QtGui/QDrag>
+
+#include <QtCore/QMimeData>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+ToolBarColorBox::ToolBarColorBox(QWidget *parent) :
+ QLabel(parent)
+{
+ m_copyHexColor = new QAction(QIcon(QLatin1String(":/qml/images/color-picker-hicontrast.png")),
+ tr("Copy Color"), this);
+ connect(m_copyHexColor, SIGNAL(triggered()), SLOT(copyColorToClipboard()));
+ setScaledContents(false);
+}
+
+void ToolBarColorBox::setColor(const QColor &color)
+{
+ m_color = color;
+
+ QPixmap pix = createDragPixmap(width());
+ setPixmap(pix);
+ update();
+}
+
+void ToolBarColorBox::mousePressEvent(QMouseEvent *event)
+{
+ m_dragBeginPoint = event->pos();
+ m_dragStarted = false;
+}
+
+void ToolBarColorBox::mouseMoveEvent(QMouseEvent *event)
+{
+
+ if (event->buttons() & Qt::LeftButton
+ && (QPoint(event->pos() - m_dragBeginPoint).manhattanLength()
+ > Constants::DragStartDistance)
+ && !m_dragStarted)
+ {
+ m_dragStarted = true;
+ QDrag *drag = new QDrag(this);
+ QMimeData *mimeData = new QMimeData;
+
+ mimeData->setText(m_color.name());
+ drag->setMimeData(mimeData);
+ drag->setPixmap(createDragPixmap());
+
+ drag->exec();
+ }
+}
+
+QPixmap ToolBarColorBox::createDragPixmap(int size) const
+{
+ QPixmap pix(size, size);
+ QPainter p(&pix);
+
+ QColor borderColor1 = QColor(143, 143 ,143);
+ QColor borderColor2 = QColor(43, 43, 43);
+
+ p.setBrush(QBrush(m_color));
+ p.setPen(QPen(QBrush(borderColor2),1));
+
+ p.fillRect(0, 0, size, size, borderColor1);
+ p.drawRect(1,1, size - 3, size - 3);
+ return pix;
+}
+
+void ToolBarColorBox::contextMenuEvent(QContextMenuEvent *ev)
+{
+ QMenu contextMenu;
+ contextMenu.addAction(m_copyHexColor);
+ contextMenu.exec(ev->globalPos());
+}
+
+void ToolBarColorBox::copyColorToClipboard()
+{
+ QClipboard *clipboard = QApplication::clipboard();
+ clipboard->setText(m_color.name());
+}
+
+QT_END_NAMESPACE
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef ETERNALAFFECTOR_H
-#define ETERNALAFFECTOR_H
-#include "particleaffector.h"
+#ifndef TOOLBARCOLORBOX_H
+#define TOOLBARCOLORBOX_H
+
+#include <QtGui/QLabel>
+#include <QtGui/QColor>
+#include <QtCore/QPoint>
+
+QT_FORWARD_DECLARE_CLASS(QContextMenuEvent)
+QT_FORWARD_DECLARE_CLASS(QAction)
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class EternalAffector : public ParticleAffector
+class ToolBarColorBox : public QLabel
{
Q_OBJECT
- Q_PROPERTY(int targetLife READ targetLife WRITE setTargetLife NOTIFY targetLifeChanged)
public:
- explicit EternalAffector(QSGItem *parent = 0);
- int targetLife() const
- {
- return m_targetLife;
- }
+ explicit ToolBarColorBox(QWidget *parent = 0);
+ void setColor(const QColor &color);
protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
-
-signals:
+ void contextMenuEvent(QContextMenuEvent *ev);
+ void mousePressEvent(QMouseEvent *ev);
+ void mouseMoveEvent(QMouseEvent *ev);
+private slots:
+ void copyColorToClipboard();
- void targetLifeChanged(int arg);
-
-public slots:
+private:
+ QPixmap createDragPixmap(int size = 24) const;
- void setTargetLife(int arg)
- {
- if (m_targetLife != arg) {
- m_targetLife = arg;
- emit targetLifeChanged(arg);
- }
- }
private:
- int m_targetLife;
+ bool m_dragStarted;
+ QPoint m_dragBeginPoint;
+ QAction *m_copyHexColor;
+ QColor m_color;
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // ETERNALAFFECTOR_H
+#endif // TOOLBARCOLORBOX_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "zoomtool_p.h"
+
+#include "../qdeclarativeviewobserver_p_p.h"
+
+#include <QtGui/QMouseEvent>
+#include <QtGui/QWheelEvent>
+#include <QtGui/QKeyEvent>
+#include <QtGui/QMenu>
+#include <QtGui/QAction>
+
+#include <QtCore/QRectF>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+ZoomTool::ZoomTool(QDeclarativeViewObserver *view) :
+ AbstractLiveEditTool(view),
+ m_rubberbandManipulator(),
+ m_smoothZoomMultiplier(0.05f),
+ m_currentScale(1.0f)
+{
+ m_zoomTo100Action = new QAction(tr("Zoom to &100%"), this);
+ m_zoomInAction = new QAction(tr("Zoom In"), this);
+ m_zoomOutAction = new QAction(tr("Zoom Out"), this);
+ m_zoomInAction->setShortcut(QKeySequence(Qt::Key_Plus));
+ m_zoomOutAction->setShortcut(QKeySequence(Qt::Key_Minus));
+
+
+ LiveLayerItem *layerItem = QDeclarativeViewObserverPrivate::get(view)->manipulatorLayer;
+ QGraphicsObject *layerObject = reinterpret_cast<QGraphicsObject *>(layerItem);
+ m_rubberbandManipulator = new LiveRubberBandSelectionManipulator(layerObject, view);
+
+
+ connect(m_zoomTo100Action, SIGNAL(triggered()), SLOT(zoomTo100()));
+ connect(m_zoomInAction, SIGNAL(triggered()), SLOT(zoomIn()));
+ connect(m_zoomOutAction, SIGNAL(triggered()), SLOT(zoomOut()));
+}
+
+ZoomTool::~ZoomTool()
+{
+ delete m_rubberbandManipulator;
+}
+
+void ZoomTool::mousePressEvent(QMouseEvent *event)
+{
+ m_mousePos = event->pos();
+
+ QPointF scenePos = view()->mapToScene(event->pos());
+
+ if (event->buttons() & Qt::RightButton) {
+ QMenu contextMenu;
+ contextMenu.addAction(m_zoomTo100Action);
+ contextMenu.addSeparator();
+ contextMenu.addAction(m_zoomInAction);
+ contextMenu.addAction(m_zoomOutAction);
+ contextMenu.exec(event->globalPos());
+ } else if (event->buttons() & Qt::LeftButton) {
+ m_dragBeginPos = scenePos;
+ m_dragStarted = false;
+ }
+}
+
+void ZoomTool::mouseMoveEvent(QMouseEvent *event)
+{
+ m_mousePos = event->pos();
+
+ QPointF scenePos = view()->mapToScene(event->pos());
+
+ if (event->buttons() & Qt::LeftButton
+ && (QPointF(scenePos - m_dragBeginPos).manhattanLength()
+ > Constants::DragStartDistance / 3)
+ && !m_dragStarted)
+ {
+ m_dragStarted = true;
+ m_rubberbandManipulator->begin(m_dragBeginPos);
+ return;
+ }
+
+ if (m_dragStarted)
+ m_rubberbandManipulator->update(scenePos);
+
+}
+
+void ZoomTool::mouseReleaseEvent(QMouseEvent *event)
+{
+ m_mousePos = event->pos();
+ QPointF scenePos = view()->mapToScene(event->pos());
+
+ if (m_dragStarted) {
+ m_rubberbandManipulator->end();
+
+ int x1 = qMin(scenePos.x(), m_rubberbandManipulator->beginPoint().x());
+ int x2 = qMax(scenePos.x(), m_rubberbandManipulator->beginPoint().x());
+ int y1 = qMin(scenePos.y(), m_rubberbandManipulator->beginPoint().y());
+ int y2 = qMax(scenePos.y(), m_rubberbandManipulator->beginPoint().y());
+
+ QPointF scenePosTopLeft = QPoint(x1, y1);
+ QPointF scenePosBottomRight = QPoint(x2, y2);
+
+ QRectF sceneArea(scenePosTopLeft, scenePosBottomRight);
+
+ m_currentScale = qMin(view()->rect().width() / sceneArea.width(),
+ view()->rect().height() / sceneArea.height());
+
+
+ QTransform transform;
+ transform.scale(m_currentScale, m_currentScale);
+
+ view()->setTransform(transform);
+ view()->setSceneRect(sceneArea);
+ } else {
+ Qt::KeyboardModifier modifierKey = Qt::ControlModifier;
+#ifdef Q_WS_MAC
+ modifierKey = Qt::AltModifier;
+#endif
+ if (event->modifiers() & modifierKey) {
+ zoomOut();
+ } else {
+ zoomIn();
+ }
+ }
+}
+
+void ZoomTool::zoomIn()
+{
+ m_currentScale = nextZoomScale(ZoomIn);
+ scaleView(view()->mapToScene(m_mousePos));
+}
+
+void ZoomTool::zoomOut()
+{
+ m_currentScale = nextZoomScale(ZoomOut);
+ scaleView(view()->mapToScene(m_mousePos));
+}
+
+void ZoomTool::mouseDoubleClickEvent(QMouseEvent *event)
+{
+ m_mousePos = event->pos();
+}
+
+
+void ZoomTool::hoverMoveEvent(QMouseEvent *event)
+{
+ m_mousePos = event->pos();
+}
+
+
+void ZoomTool::keyPressEvent(QKeyEvent * /*event*/)
+{
+}
+
+void ZoomTool::wheelEvent(QWheelEvent *event)
+{
+ if (event->orientation() != Qt::Vertical)
+ return;
+
+ Qt::KeyboardModifier smoothZoomModifier = Qt::ControlModifier;
+ if (event->modifiers() & smoothZoomModifier) {
+ int numDegrees = event->delta() / 8;
+ m_currentScale += m_smoothZoomMultiplier * (numDegrees / 15.0f);
+
+ scaleView(view()->mapToScene(m_mousePos));
+
+ } else if (!event->modifiers()) {
+ if (event->delta() > 0) {
+ m_currentScale = nextZoomScale(ZoomIn);
+ } else if (event->delta() < 0) {
+ m_currentScale = nextZoomScale(ZoomOut);
+ }
+ scaleView(view()->mapToScene(m_mousePos));
+ }
+}
+
+void ZoomTool::keyReleaseEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Plus:
+ zoomIn();
+ break;
+ case Qt::Key_Minus:
+ zoomOut();
+ break;
+ case Qt::Key_1:
+ case Qt::Key_2:
+ case Qt::Key_3:
+ case Qt::Key_4:
+ case Qt::Key_5:
+ case Qt::Key_6:
+ case Qt::Key_7:
+ case Qt::Key_8:
+ case Qt::Key_9:
+ {
+ m_currentScale = ((event->key() - Qt::Key_0) * 1.0f);
+ scaleView(view()->mapToScene(m_mousePos)); // view()->mapToScene(view()->rect().center())
+ break;
+ }
+
+ default:
+ break;
+ }
+
+}
+
+void ZoomTool::itemsAboutToRemoved(const QList<QGraphicsItem*> &/*itemList*/)
+{
+}
+
+void ZoomTool::clear()
+{
+ view()->setCursor(Qt::ArrowCursor);
+}
+
+void ZoomTool::selectedItemsChanged(const QList<QGraphicsItem*> &/*itemList*/)
+{
+}
+
+void ZoomTool::scaleView(const QPointF ¢erPos)
+{
+
+ QTransform transform;
+ transform.scale(m_currentScale, m_currentScale);
+ view()->setTransform(transform);
+
+ QPointF adjustedCenterPos = centerPos;
+ QSize rectSize(view()->rect().width() / m_currentScale,
+ view()->rect().height() / m_currentScale);
+
+ QRectF sceneRect;
+ if (qAbs(m_currentScale - 1.0f) < Constants::ZoomSnapDelta) {
+ adjustedCenterPos.rx() = rectSize.width() / 2;
+ adjustedCenterPos.ry() = rectSize.height() / 2;
+ }
+
+ if (m_currentScale < 1.0f) {
+ adjustedCenterPos.rx() = rectSize.width() / 2;
+ adjustedCenterPos.ry() = rectSize.height() / 2;
+ sceneRect.setRect(view()->rect().width() / 2 -rectSize.width() / 2,
+ view()->rect().height() / 2 -rectSize.height() / 2,
+ rectSize.width(),
+ rectSize.height());
+ } else {
+ sceneRect.setRect(adjustedCenterPos.x() - rectSize.width() / 2,
+ adjustedCenterPos.y() - rectSize.height() / 2,
+ rectSize.width(),
+ rectSize.height());
+ }
+
+ view()->setSceneRect(sceneRect);
+}
+
+void ZoomTool::zoomTo100()
+{
+ m_currentScale = 1.0f;
+ scaleView(view()->mapToScene(view()->rect().center()));
+}
+
+qreal ZoomTool::nextZoomScale(ZoomDirection direction) const
+{
+ static QList<qreal> zoomScales =
+ QList<qreal>()
+ << 0.125f
+ << 1.0f / 6.0f
+ << 0.25f
+ << 1.0f / 3.0f
+ << 0.5f
+ << 2.0f / 3.0f
+ << 1.0f
+ << 2.0f
+ << 3.0f
+ << 4.0f
+ << 5.0f
+ << 6.0f
+ << 7.0f
+ << 8.0f
+ << 12.0f
+ << 16.0f
+ << 32.0f
+ << 48.0f;
+
+ if (direction == ZoomIn) {
+ for (int i = 0; i < zoomScales.length(); ++i) {
+ if (zoomScales[i] > m_currentScale || i == zoomScales.length() - 1)
+ return zoomScales[i];
+ }
+ } else {
+ for (int i = zoomScales.length() - 1; i >= 0; --i) {
+ if (zoomScales[i] < m_currentScale || i == 0)
+ return zoomScales[i];
+ }
+ }
+
+ return 1.0f;
+}
+
+QT_END_NAMESPACE
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef SPRITEPARTICLE_H
-#define SPRITEPARTICLE_H
-#include "particle.h"
-#include <QDeclarativeListProperty>
+#ifndef ZOOMTOOL_H
+#define ZOOMTOOL_H
+
+#include "abstractliveedittool_p.h"
+#include "liverubberbandselectionmanipulator_p.h"
+
+QT_FORWARD_DECLARE_CLASS(QAction)
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class SpriteState;
-class SpriteEngine;
-class QSGGeometryNode;
-class SpriteParticlesMaterial;
-class SpriteParticleVertex;
-
-class SpriteParticle : public ParticleType
+class ZoomTool : public AbstractLiveEditTool
{
Q_OBJECT
- Q_PROPERTY(QDeclarativeListProperty<SpriteState> sprites READ sprites)
- Q_CLASSINFO("DefaultProperty", "sprites")
+
public:
- explicit SpriteParticle(QSGItem *parent = 0);
- virtual void load(ParticleData*);
- virtual void reload(ParticleData*);
- virtual void setCount(int c);
+ enum ZoomDirection {
+ ZoomIn,
+ ZoomOut
+ };
+
+ explicit ZoomTool(QDeclarativeViewObserver *view);
+
+ virtual ~ZoomTool();
+
+ void mousePressEvent(QMouseEvent *event);
+ void mouseMoveEvent(QMouseEvent *event);
+ void mouseReleaseEvent(QMouseEvent *event);
+ void mouseDoubleClickEvent(QMouseEvent *event);
- QDeclarativeListProperty<SpriteState> sprites();
- SpriteEngine* spriteEngine() {return m_spriteEngine;}
-signals:
+ void hoverMoveEvent(QMouseEvent *event);
+ void wheelEvent(QWheelEvent *event);
+
+ void keyPressEvent(QKeyEvent *event);
+ void keyReleaseEvent(QKeyEvent *keyEvent);
+ void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList);
+
+ void clear();
-public slots:
protected:
- QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *);
- void reset();
- void prepareNextFrame();
- QSGGeometryNode* buildParticleNode();
+ void selectedItemsChanged(const QList<QGraphicsItem*> &itemList);
+
private slots:
- void createEngine();
-private:
- QSGGeometryNode *m_node;
- SpriteParticlesMaterial *m_material;
+ void zoomTo100();
+ void zoomIn();
+ void zoomOut();
- int m_particle_duration;
- int m_last_particle;
+private:
+ qreal nextZoomScale(ZoomDirection direction) const;
+ void scaleView(const QPointF ¢erPos);
- QList<SpriteState*> m_sprites;
- SpriteEngine* m_spriteEngine;
+private:
+ bool m_dragStarted;
+ QPoint m_mousePos; // in view coords
+ QPointF m_dragBeginPos;
+ QAction *m_zoomTo100Action;
+ QAction *m_zoomInAction;
+ QAction *m_zoomOutAction;
+ LiveRubberBandSelectionManipulator *m_rubberbandManipulator;
- void vertexCopy(SpriteParticleVertex &b,const ParticleVertex& a);
+ qreal m_smoothZoomMultiplier;
+ qreal m_currentScale;
};
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SPRITEPARTICLE_H
+#endif // ZOOMTOOL_H
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#include "driftaffector.h"
-#include "particlesystem.h"
+#include "qdeclarativeobserverplugin.h"
+
+#include "qdeclarativeviewobserver_p.h"
+
+#include <QtCore/qplugin.h>
+#include <QtDeclarative/private/qdeclarativeobserverservice_p.h>
+
QT_BEGIN_NAMESPACE
-DriftAffector::DriftAffector(QSGItem *parent) :
- ParticleAffector(parent)
+
+QDeclarativeObserverPlugin::QDeclarativeObserverPlugin() :
+ m_observer(0)
{
}
-DriftAffector::~DriftAffector()
+QDeclarativeObserverPlugin::~QDeclarativeObserverPlugin()
{
+ delete m_observer;
}
-bool DriftAffector::affectParticle(ParticleData *data, qreal dt)
+void QDeclarativeObserverPlugin::activate()
{
- if(!m_xDrift && !m_yDrift)
- return false;
- qreal dx = (((qreal)qrand() / (qreal)RAND_MAX) - 0.5) * 2 * m_xDrift * dt;
- qreal dy = (((qreal)qrand() / (qreal)RAND_MAX) - 0.5) * 2 * m_yDrift * dt;
- if(dx)
- data->setInstantaneousSX(data->curSX() + dx);
- if(dy)
- data->setInstantaneousSY(data->curSY() + dy);
+ QDeclarativeObserverService *service = QDeclarativeObserverService::instance();
+ QList<QDeclarativeView*> views = service->views();
+ if (views.isEmpty())
+ return;
+
+ // TODO: Support multiple views
+ QDeclarativeView *view = service->views().at(0);
+ m_observer = new QDeclarativeViewObserver(view, view);
+}
- return true;
+void QDeclarativeObserverPlugin::deactivate()
+{
+ delete m_observer;
}
+
+Q_EXPORT_PLUGIN2(declarativeobserver, QDeclarativeObserverPlugin)
+
QT_END_NAMESPACE
+
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEOBSERVERPLUGIN_H
+#define QDECLARATIVEOBSERVERPLUGIN_H
+
+#include <QtCore/QPointer>
+#include <QtDeclarative/private/qdeclarativeobserverinterface_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDeclarativeViewObserver;
+
+class QDeclarativeObserverPlugin : public QObject, public QDeclarativeObserverInterface
+{
+ Q_OBJECT
+ Q_DISABLE_COPY(QDeclarativeObserverPlugin)
+ Q_INTERFACES(QDeclarativeObserverInterface)
+
+public:
+ QDeclarativeObserverPlugin();
+ ~QDeclarativeObserverPlugin();
+
+ void activate();
+ void deactivate();
+
+private:
+ QPointer<QDeclarativeViewObserver> m_observer;
+};
+
+QT_END_NAMESPACE
+
+#endif // QDECLARATIVEOBSERVERPLUGIN_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEOBSERVERPROTOCOL_H
+#define QDECLARATIVEOBSERVERPROTOCOL_H
+
+#include <QtCore/QDebug>
+#include <QtCore/QMetaType>
+#include <QtCore/QMetaEnum>
+#include <QtCore/QObject>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class ObserverProtocol : public QObject
+{
+ Q_OBJECT
+ Q_ENUMS(Message Tool)
+
+public:
+ enum Message {
+ AnimationSpeedChanged = 0,
+ AnimationPausedChanged = 19, // highest value
+ ChangeTool = 1,
+ ClearComponentCache = 2,
+ ColorChanged = 3,
+ ContextPathUpdated = 4,
+ CreateObject = 5,
+ CurrentObjectsChanged = 6,
+ DestroyObject = 7,
+ MoveObject = 8,
+ ObjectIdList = 9,
+ Reload = 10,
+ Reloaded = 11,
+ SetAnimationSpeed = 12,
+ SetAnimationPaused = 18,
+ SetContextPathIdx = 13,
+ SetCurrentObjects = 14,
+ SetDesignMode = 15,
+ ShowAppOnTop = 16,
+ ToolChanged = 17
+ };
+
+ enum Tool {
+ ColorPickerTool,
+ SelectMarqueeTool,
+ SelectTool,
+ ZoomTool
+ };
+
+ static inline QString toString(Message message)
+ {
+ return QLatin1String(staticMetaObject.enumerator(0).valueToKey(message));
+ }
+
+ static inline QString toString(Tool tool)
+ {
+ return QLatin1String(staticMetaObject.enumerator(1).valueToKey(tool));
+ }
+};
+
+inline QDataStream & operator<< (QDataStream &stream, ObserverProtocol::Message message)
+{
+ return stream << static_cast<quint32>(message);
+}
+
+inline QDataStream & operator>> (QDataStream &stream, ObserverProtocol::Message &message)
+{
+ quint32 i;
+ stream >> i;
+ message = static_cast<ObserverProtocol::Message>(i);
+ return stream;
+}
+
+inline QDebug operator<< (QDebug dbg, ObserverProtocol::Message message)
+{
+ dbg << ObserverProtocol::toString(message);
+ return dbg;
+}
+
+inline QDataStream & operator<< (QDataStream &stream, ObserverProtocol::Tool tool)
+{
+ return stream << static_cast<quint32>(tool);
+}
+
+inline QDataStream & operator>> (QDataStream &stream, ObserverProtocol::Tool &tool)
+{
+ quint32 i;
+ stream >> i;
+ tool = static_cast<ObserverProtocol::Tool>(i);
+ return stream;
+}
+
+inline QDebug operator<< (QDebug dbg, ObserverProtocol::Tool tool)
+{
+ dbg << ObserverProtocol::toString(tool);
+ return dbg;
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEOBSERVERPROTOCOL_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "QtDeclarative/private/qdeclarativeobserverservice_p.h"
+#include "QtDeclarative/private/qdeclarativedebughelper_p.h"
+
+#include "qdeclarativeviewobserver_p.h"
+#include "qdeclarativeviewobserver_p_p.h"
+#include "qdeclarativeobserverprotocol.h"
+
+#include "editor/liveselectiontool_p.h"
+#include "editor/zoomtool_p.h"
+#include "editor/colorpickertool_p.h"
+#include "editor/livelayeritem_p.h"
+#include "editor/boundingrecthighlighter_p.h"
+#include "editor/subcomponenteditortool_p.h"
+#include "editor/qmltoolbar_p.h"
+
+#include <QtDeclarative/QDeclarativeItem>
+#include <QtDeclarative/QDeclarativeEngine>
+#include <QtDeclarative/QDeclarativeContext>
+#include <QtDeclarative/QDeclarativeExpression>
+#include <QtGui/QWidget>
+#include <QtGui/QVBoxLayout>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QGraphicsObject>
+#include <QtGui/QApplication>
+#include <QtCore/QSettings>
+
+static inline void initEditorResource() { Q_INIT_RESOURCE(editor); }
+
+QT_BEGIN_NAMESPACE
+
+const char * const KEY_TOOLBOX_GEOMETRY = "toolBox/geometry";
+
+const int SceneChangeUpdateInterval = 5000;
+
+
+class ToolBox : public QWidget
+{
+ Q_OBJECT
+
+public:
+ ToolBox(QWidget *parent = 0);
+ ~ToolBox();
+
+ QmlToolBar *toolBar() const { return m_toolBar; }
+
+private:
+ QSettings m_settings;
+ QmlToolBar *m_toolBar;
+};
+
+ToolBox::ToolBox(QWidget *parent)
+ : QWidget(parent, Qt::Tool)
+ , m_settings(QLatin1String("Nokia"), QLatin1String("QmlObserver"), this)
+ , m_toolBar(new QmlToolBar)
+{
+ setWindowFlags((windowFlags() & ~Qt::WindowCloseButtonHint) | Qt::CustomizeWindowHint);
+ setWindowTitle(tr("Qt Quick Toolbox"));
+
+ QVBoxLayout *verticalLayout = new QVBoxLayout;
+ verticalLayout->setMargin(0);
+ verticalLayout->addWidget(m_toolBar);
+ setLayout(verticalLayout);
+
+ restoreGeometry(m_settings.value(QLatin1String(KEY_TOOLBOX_GEOMETRY)).toByteArray());
+}
+
+ToolBox::~ToolBox()
+{
+ m_settings.setValue(QLatin1String(KEY_TOOLBOX_GEOMETRY), saveGeometry());
+}
+
+
+QDeclarativeViewObserverPrivate::QDeclarativeViewObserverPrivate(QDeclarativeViewObserver *q) :
+ q(q),
+ designModeBehavior(false),
+ showAppOnTop(false),
+ animationPaused(false),
+ slowDownFactor(1.0f),
+ toolBox(0)
+{
+}
+
+QDeclarativeViewObserverPrivate::~QDeclarativeViewObserverPrivate()
+{
+}
+
+QDeclarativeViewObserver::QDeclarativeViewObserver(QDeclarativeView *view,
+ QObject *parent) :
+ QObject(parent),
+ data(new QDeclarativeViewObserverPrivate(this))
+{
+ initEditorResource();
+
+ data->view = view;
+ data->manipulatorLayer = new LiveLayerItem(view->scene());
+ data->selectionTool = new LiveSelectionTool(this);
+ data->zoomTool = new ZoomTool(this);
+ data->colorPickerTool = new ColorPickerTool(this);
+ data->boundingRectHighlighter = new BoundingRectHighlighter(this);
+ data->subcomponentEditorTool = new SubcomponentEditorTool(this);
+ data->currentTool = data->selectionTool;
+
+ // to capture ChildRemoved event when viewport changes
+ data->view->installEventFilter(this);
+
+ data->setViewport(data->view->viewport());
+
+ data->debugService = QDeclarativeObserverService::instance();
+ connect(data->debugService, SIGNAL(gotMessage(QByteArray)),
+ this, SLOT(handleMessage(QByteArray)));
+
+ connect(data->view, SIGNAL(statusChanged(QDeclarativeView::Status)),
+ data.data(), SLOT(_q_onStatusChanged(QDeclarativeView::Status)));
+
+ connect(data->colorPickerTool, SIGNAL(selectedColorChanged(QColor)),
+ SIGNAL(selectedColorChanged(QColor)));
+ connect(data->colorPickerTool, SIGNAL(selectedColorChanged(QColor)),
+ this, SLOT(sendColorChanged(QColor)));
+
+ connect(data->subcomponentEditorTool, SIGNAL(cleared()), SIGNAL(inspectorContextCleared()));
+ connect(data->subcomponentEditorTool, SIGNAL(contextPushed(QString)),
+ SIGNAL(inspectorContextPushed(QString)));
+ connect(data->subcomponentEditorTool, SIGNAL(contextPopped()),
+ SIGNAL(inspectorContextPopped()));
+ connect(data->subcomponentEditorTool, SIGNAL(contextPathChanged(QStringList)),
+ this, SLOT(sendContextPathUpdated(QStringList)));
+
+ data->_q_changeToSingleSelectTool();
+}
+
+QDeclarativeViewObserver::~QDeclarativeViewObserver()
+{
+}
+
+void QDeclarativeViewObserver::setObserverContext(int contextIndex)
+{
+ if (data->subcomponentEditorTool->contextIndex() != contextIndex) {
+ QGraphicsObject *object = data->subcomponentEditorTool->setContext(contextIndex);
+ if (object)
+ setSelectedItems(QList<QGraphicsItem*>() << object);
+ }
+}
+
+void QDeclarativeViewObserverPrivate::_q_setToolBoxVisible(bool visible)
+{
+#if !defined(Q_OS_SYMBIAN) && !defined(Q_WS_MAEMO_5) && !defined(Q_WS_SIMULATOR)
+ if (!toolBox && visible)
+ createToolBox();
+ if (toolBox)
+ toolBox->setVisible(visible);
+#else
+ Q_UNUSED(visible)
+#endif
+}
+
+void QDeclarativeViewObserverPrivate::_q_reloadView()
+{
+ subcomponentEditorTool->clear();
+ clearHighlight();
+ emit q->reloadRequested();
+}
+
+void QDeclarativeViewObserverPrivate::setViewport(QWidget *widget)
+{
+ if (viewport.data() == widget)
+ return;
+
+ if (viewport)
+ viewport.data()->removeEventFilter(q);
+
+ viewport = widget;
+ if (viewport) {
+ // make sure we get mouse move events
+ viewport.data()->setMouseTracking(true);
+ viewport.data()->installEventFilter(q);
+ }
+}
+
+void QDeclarativeViewObserverPrivate::clearEditorItems()
+{
+ clearHighlight();
+ setSelectedItems(QList<QGraphicsItem*>());
+}
+
+bool QDeclarativeViewObserver::eventFilter(QObject *obj, QEvent *event)
+{
+ if (obj == data->view) {
+ // Event from view
+ if (event->type() == QEvent::ChildRemoved) {
+ // Might mean that viewport has changed
+ if (data->view->viewport() != data->viewport.data())
+ data->setViewport(data->view->viewport());
+ }
+ return QObject::eventFilter(obj, event);
+ }
+
+ // Event from viewport
+ switch (event->type()) {
+ case QEvent::Leave: {
+ if (leaveEvent(event))
+ return true;
+ break;
+ }
+ case QEvent::MouseButtonPress: {
+ if (mousePressEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::MouseMove: {
+ if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::MouseButtonRelease: {
+ if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::KeyPress: {
+ if (keyPressEvent(static_cast<QKeyEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::KeyRelease: {
+ if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::MouseButtonDblClick: {
+ if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ }
+ case QEvent::Wheel: {
+ if (wheelEvent(static_cast<QWheelEvent*>(event)))
+ return true;
+ break;
+ }
+ default: {
+ break;
+ }
+ } //switch
+
+ // standard event processing
+ return QObject::eventFilter(obj, event);
+}
+
+bool QDeclarativeViewObserver::leaveEvent(QEvent * /*event*/)
+{
+ if (!data->designModeBehavior)
+ return false;
+ data->clearHighlight();
+ return true;
+}
+
+bool QDeclarativeViewObserver::mousePressEvent(QMouseEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+ data->cursorPos = event->pos();
+ data->currentTool->mousePressEvent(event);
+ return true;
+}
+
+bool QDeclarativeViewObserver::mouseMoveEvent(QMouseEvent *event)
+{
+ if (!data->designModeBehavior) {
+ data->clearEditorItems();
+ return false;
+ }
+ data->cursorPos = event->pos();
+
+ QList<QGraphicsItem*> selItems = data->selectableItems(event->pos());
+ if (!selItems.isEmpty()) {
+ declarativeView()->setToolTip(data->currentTool->titleForItem(selItems.first()));
+ } else {
+ declarativeView()->setToolTip(QString());
+ }
+ if (event->buttons()) {
+ data->subcomponentEditorTool->mouseMoveEvent(event);
+ data->currentTool->mouseMoveEvent(event);
+ } else {
+ data->subcomponentEditorTool->hoverMoveEvent(event);
+ data->currentTool->hoverMoveEvent(event);
+ }
+ return true;
+}
+
+bool QDeclarativeViewObserver::mouseReleaseEvent(QMouseEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+ data->subcomponentEditorTool->mouseReleaseEvent(event);
+
+ data->cursorPos = event->pos();
+ data->currentTool->mouseReleaseEvent(event);
+ return true;
+}
+
+bool QDeclarativeViewObserver::keyPressEvent(QKeyEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+
+ data->currentTool->keyPressEvent(event);
+ return true;
+}
+
+bool QDeclarativeViewObserver::keyReleaseEvent(QKeyEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+
+ switch (event->key()) {
+ case Qt::Key_V:
+ data->_q_changeToSingleSelectTool();
+ break;
+// disabled because multiselection does not do anything useful without design mode
+// case Qt::Key_M:
+// data->_q_changeToMarqueeSelectTool();
+// break;
+ case Qt::Key_I:
+ data->_q_changeToColorPickerTool();
+ break;
+ case Qt::Key_Z:
+ data->_q_changeToZoomTool();
+ break;
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ if (!data->selectedItems().isEmpty())
+ data->subcomponentEditorTool->setCurrentItem(data->selectedItems().first());
+ break;
+ case Qt::Key_Space:
+ setAnimationPaused(!data->animationPaused);
+ break;
+ default:
+ break;
+ }
+
+ data->currentTool->keyReleaseEvent(event);
+ return true;
+}
+
+void QDeclarativeViewObserverPrivate::_q_createQmlObject(const QString &qml, QObject *parent,
+ const QStringList &importList,
+ const QString &filename)
+{
+ if (!parent)
+ return;
+
+ QString imports;
+ foreach (const QString &s, importList) {
+ imports += s;
+ imports += QLatin1Char('\n');
+ }
+
+ QDeclarativeContext *parentContext = view->engine()->contextForObject(parent);
+ QDeclarativeComponent component(view->engine(), q);
+ QByteArray constructedQml = QString(imports + qml).toLatin1();
+
+ component.setData(constructedQml, QUrl::fromLocalFile(filename));
+ QObject *newObject = component.create(parentContext);
+ if (newObject) {
+ newObject->setParent(parent);
+ QDeclarativeItem *parentItem = qobject_cast<QDeclarativeItem*>(parent);
+ QDeclarativeItem *newItem = qobject_cast<QDeclarativeItem*>(newObject);
+ if (parentItem && newItem)
+ newItem->setParentItem(parentItem);
+ }
+}
+
+void QDeclarativeViewObserverPrivate::_q_reparentQmlObject(QObject *object, QObject *newParent)
+{
+ if (!newParent)
+ return;
+
+ object->setParent(newParent);
+ QDeclarativeItem *newParentItem = qobject_cast<QDeclarativeItem*>(newParent);
+ QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(object);
+ if (newParentItem && item)
+ item->setParentItem(newParentItem);
+}
+
+void QDeclarativeViewObserverPrivate::_q_clearComponentCache()
+{
+ view->engine()->clearComponentCache();
+}
+
+void QDeclarativeViewObserverPrivate::_q_removeFromSelection(QObject *obj)
+{
+ QList<QGraphicsItem*> items = selectedItems();
+ if (QGraphicsItem *item = qobject_cast<QGraphicsObject*>(obj))
+ items.removeOne(item);
+ setSelectedItems(items);
+}
+
+QGraphicsItem *QDeclarativeViewObserverPrivate::currentRootItem() const
+{
+ return subcomponentEditorTool->currentRootItem();
+}
+
+bool QDeclarativeViewObserver::mouseDoubleClickEvent(QMouseEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+
+ if (data->currentToolMode != Constants::SelectionToolMode
+ && data->currentToolMode != Constants::MarqueeSelectionToolMode)
+ return true;
+
+ QGraphicsItem *itemToEnter = 0;
+ QList<QGraphicsItem*> itemList = data->view->items(event->pos());
+ data->filterForSelection(itemList);
+
+ if (data->selectedItems().isEmpty() && !itemList.isEmpty()) {
+ itemToEnter = itemList.first();
+ } else if (!data->selectedItems().isEmpty() && !itemList.isEmpty()) {
+ itemToEnter = itemList.first();
+ }
+
+ if (itemToEnter)
+ itemToEnter = data->subcomponentEditorTool->firstChildOfContext(itemToEnter);
+
+ data->subcomponentEditorTool->setCurrentItem(itemToEnter);
+ data->subcomponentEditorTool->mouseDoubleClickEvent(event);
+
+ if ((event->buttons() & Qt::LeftButton) && itemToEnter) {
+ if (QGraphicsObject *objectToEnter = itemToEnter->toGraphicsObject())
+ setSelectedItems(QList<QGraphicsItem*>() << objectToEnter);
+ }
+
+ return true;
+}
+
+bool QDeclarativeViewObserver::wheelEvent(QWheelEvent *event)
+{
+ if (!data->designModeBehavior)
+ return false;
+ data->currentTool->wheelEvent(event);
+ return true;
+}
+
+void QDeclarativeViewObserverPrivate::enterContext(QGraphicsItem *itemToEnter)
+{
+ QGraphicsItem *itemUnderCurrentContext = itemToEnter;
+ if (itemUnderCurrentContext)
+ itemUnderCurrentContext = subcomponentEditorTool->firstChildOfContext(itemToEnter);
+
+ if (itemUnderCurrentContext)
+ subcomponentEditorTool->setCurrentItem(itemToEnter);
+}
+
+void QDeclarativeViewObserver::setDesignModeBehavior(bool value)
+{
+ emit designModeBehaviorChanged(value);
+
+ if (data->toolBox)
+ data->toolBox->toolBar()->setDesignModeBehavior(value);
+ sendDesignModeBehavior(value);
+
+ data->designModeBehavior = value;
+ if (data->subcomponentEditorTool) {
+ data->subcomponentEditorTool->clear();
+ data->clearHighlight();
+ data->setSelectedItems(QList<QGraphicsItem*>());
+
+ if (data->view->rootObject())
+ data->subcomponentEditorTool->pushContext(data->view->rootObject());
+ }
+
+ if (!data->designModeBehavior)
+ data->clearEditorItems();
+}
+
+bool QDeclarativeViewObserver::designModeBehavior()
+{
+ return data->designModeBehavior;
+}
+
+bool QDeclarativeViewObserver::showAppOnTop() const
+{
+ return data->showAppOnTop;
+}
+
+void QDeclarativeViewObserver::setShowAppOnTop(bool appOnTop)
+{
+ if (data->view) {
+ QWidget *window = data->view->window();
+ Qt::WindowFlags flags = window->windowFlags();
+ if (appOnTop)
+ flags |= Qt::WindowStaysOnTopHint;
+ else
+ flags &= ~Qt::WindowStaysOnTopHint;
+
+ window->setWindowFlags(flags);
+ window->show();
+ }
+
+ data->showAppOnTop = appOnTop;
+ sendShowAppOnTop(appOnTop);
+
+ emit showAppOnTopChanged(appOnTop);
+}
+
+void QDeclarativeViewObserverPrivate::changeTool(Constants::DesignTool tool,
+ Constants::ToolFlags /*flags*/)
+{
+ switch (tool) {
+ case Constants::SelectionToolMode:
+ _q_changeToSingleSelectTool();
+ break;
+ case Constants::NoTool:
+ default:
+ currentTool = 0;
+ break;
+ }
+}
+
+void QDeclarativeViewObserverPrivate::setSelectedItemsForTools(QList<QGraphicsItem *> items)
+{
+ foreach (const QWeakPointer<QGraphicsObject> &obj, currentSelection) {
+ if (QGraphicsItem *item = obj.data()) {
+ if (!items.contains(item)) {
+ QObject::disconnect(obj.data(), SIGNAL(destroyed(QObject*)),
+ this, SLOT(_q_removeFromSelection(QObject*)));
+ currentSelection.removeOne(obj);
+ }
+ }
+ }
+
+ foreach (QGraphicsItem *item, items) {
+ if (item) {
+ if (QGraphicsObject *obj = item->toGraphicsObject()) {
+ QObject::connect(obj, SIGNAL(destroyed(QObject*)),
+ this, SLOT(_q_removeFromSelection(QObject*)));
+ currentSelection.append(obj);
+ }
+ }
+ }
+
+ currentTool->updateSelectedItems();
+}
+
+void QDeclarativeViewObserverPrivate::setSelectedItems(QList<QGraphicsItem *> items)
+{
+ QList<QWeakPointer<QGraphicsObject> > oldList = currentSelection;
+ setSelectedItemsForTools(items);
+ if (oldList != currentSelection) {
+ QList<QObject*> objectList;
+ foreach (const QWeakPointer<QGraphicsObject> &graphicsObject, currentSelection) {
+ if (graphicsObject)
+ objectList << graphicsObject.data();
+ }
+
+ q->sendCurrentObjects(objectList);
+ }
+}
+
+QList<QGraphicsItem *> QDeclarativeViewObserverPrivate::selectedItems() const
+{
+ QList<QGraphicsItem *> selection;
+ foreach (const QWeakPointer<QGraphicsObject> &selectedObject, currentSelection) {
+ if (selectedObject.data())
+ selection << selectedObject.data();
+ }
+
+ return selection;
+}
+
+void QDeclarativeViewObserver::setSelectedItems(QList<QGraphicsItem *> items)
+{
+ data->setSelectedItems(items);
+}
+
+QList<QGraphicsItem *> QDeclarativeViewObserver::selectedItems() const
+{
+ return data->selectedItems();
+}
+
+QDeclarativeView *QDeclarativeViewObserver::declarativeView()
+{
+ return data->view;
+}
+
+void QDeclarativeViewObserverPrivate::clearHighlight()
+{
+ boundingRectHighlighter->clear();
+}
+
+void QDeclarativeViewObserverPrivate::highlight(QGraphicsObject * item, ContextFlags flags)
+{
+ highlight(QList<QGraphicsObject*>() << item, flags);
+}
+
+void QDeclarativeViewObserverPrivate::highlight(QList<QGraphicsObject *> items, ContextFlags flags)
+{
+ if (items.isEmpty())
+ return;
+
+ QList<QGraphicsObject*> objectList;
+ foreach (QGraphicsItem *item, items) {
+ QGraphicsItem *child = item;
+ if (flags & ContextSensitive)
+ child = subcomponentEditorTool->firstChildOfContext(item);
+
+ if (child) {
+ QGraphicsObject *childObject = child->toGraphicsObject();
+ if (childObject)
+ objectList << childObject;
+ }
+ }
+
+ boundingRectHighlighter->highlight(objectList);
+}
+
+bool QDeclarativeViewObserverPrivate::mouseInsideContextItem() const
+{
+ return subcomponentEditorTool->containsCursor(cursorPos.toPoint());
+}
+
+QList<QGraphicsItem*> QDeclarativeViewObserverPrivate::selectableItems(
+ const QPointF &scenePos) const
+{
+ QList<QGraphicsItem*> itemlist = view->scene()->items(scenePos);
+ return filterForCurrentContext(itemlist);
+}
+
+QList<QGraphicsItem*> QDeclarativeViewObserverPrivate::selectableItems(const QPoint &pos) const
+{
+ QList<QGraphicsItem*> itemlist = view->items(pos);
+ return filterForCurrentContext(itemlist);
+}
+
+QList<QGraphicsItem*> QDeclarativeViewObserverPrivate::selectableItems(
+ const QRectF &sceneRect, Qt::ItemSelectionMode selectionMode) const
+{
+ QList<QGraphicsItem*> itemlist = view->scene()->items(sceneRect, selectionMode);
+
+ return filterForCurrentContext(itemlist);
+}
+
+void QDeclarativeViewObserverPrivate::_q_changeToSingleSelectTool()
+{
+ currentToolMode = Constants::SelectionToolMode;
+ selectionTool->setRubberbandSelectionMode(false);
+
+ changeToSelectTool();
+
+ emit q->selectToolActivated();
+ q->sendCurrentTool(Constants::SelectionToolMode);
+}
+
+void QDeclarativeViewObserverPrivate::changeToSelectTool()
+{
+ if (currentTool == selectionTool)
+ return;
+
+ currentTool->clear();
+ currentTool = selectionTool;
+ currentTool->clear();
+ currentTool->updateSelectedItems();
+}
+
+void QDeclarativeViewObserverPrivate::_q_changeToMarqueeSelectTool()
+{
+ changeToSelectTool();
+ currentToolMode = Constants::MarqueeSelectionToolMode;
+ selectionTool->setRubberbandSelectionMode(true);
+
+ emit q->marqueeSelectToolActivated();
+ q->sendCurrentTool(Constants::MarqueeSelectionToolMode);
+}
+
+void QDeclarativeViewObserverPrivate::_q_changeToZoomTool()
+{
+ currentToolMode = Constants::ZoomMode;
+ currentTool->clear();
+ currentTool = zoomTool;
+ currentTool->clear();
+
+ emit q->zoomToolActivated();
+ q->sendCurrentTool(Constants::ZoomMode);
+}
+
+void QDeclarativeViewObserverPrivate::_q_changeToColorPickerTool()
+{
+ if (currentTool == colorPickerTool)
+ return;
+
+ currentToolMode = Constants::ColorPickerMode;
+ currentTool->clear();
+ currentTool = colorPickerTool;
+ currentTool->clear();
+
+ emit q->colorPickerActivated();
+ q->sendCurrentTool(Constants::ColorPickerMode);
+}
+
+void QDeclarativeViewObserverPrivate::_q_changeContextPathIndex(int index)
+{
+ subcomponentEditorTool->setContext(index);
+}
+
+void QDeclarativeViewObserver::setAnimationSpeed(qreal slowDownFactor)
+{
+ Q_ASSERT(slowDownFactor > 0);
+ if (data->slowDownFactor == slowDownFactor)
+ return;
+
+ animationSpeedChangeRequested(slowDownFactor);
+ sendAnimationSpeed(slowDownFactor);
+}
+
+void QDeclarativeViewObserver::setAnimationPaused(bool paused)
+{
+ if (data->animationPaused == paused)
+ return;
+
+ animationPausedChangeRequested(paused);
+ sendAnimationPaused(paused);
+}
+
+void QDeclarativeViewObserver::animationSpeedChangeRequested(qreal factor)
+{
+ if (data->slowDownFactor != factor) {
+ data->slowDownFactor = factor;
+ emit animationSpeedChanged(factor);
+ }
+
+ const float effectiveFactor = data->animationPaused ? 0 : factor;
+ QDeclarativeDebugHelper::setAnimationSlowDownFactor(effectiveFactor);
+}
+
+void QDeclarativeViewObserver::animationPausedChangeRequested(bool paused)
+{
+ if (data->animationPaused != paused) {
+ data->animationPaused = paused;
+ emit animationPausedChanged(paused);
+ }
+
+ const float effectiveFactor = paused ? 0 : data->slowDownFactor;
+ QDeclarativeDebugHelper::setAnimationSlowDownFactor(effectiveFactor);
+}
+
+
+void QDeclarativeViewObserverPrivate::_q_applyChangesFromClient()
+{
+}
+
+
+QList<QGraphicsItem*> QDeclarativeViewObserverPrivate::filterForSelection(
+ QList<QGraphicsItem*> &itemlist) const
+{
+ foreach (QGraphicsItem *item, itemlist) {
+ if (isEditorItem(item) || !subcomponentEditorTool->isChildOfContext(item))
+ itemlist.removeOne(item);
+ }
+
+ return itemlist;
+}
+
+QList<QGraphicsItem*> QDeclarativeViewObserverPrivate::filterForCurrentContext(
+ QList<QGraphicsItem*> &itemlist) const
+{
+ foreach (QGraphicsItem *item, itemlist) {
+
+ if (isEditorItem(item) || !subcomponentEditorTool->isDirectChildOfContext(item)) {
+
+ // if we're a child, but not directly, replace with the parent that is directly in context.
+ if (QGraphicsItem *contextParent = subcomponentEditorTool->firstChildOfContext(item)) {
+ if (contextParent != item) {
+ if (itemlist.contains(contextParent)) {
+ itemlist.removeOne(item);
+ } else {
+ itemlist.replace(itemlist.indexOf(item), contextParent);
+ }
+ }
+ } else {
+ itemlist.removeOne(item);
+ }
+ }
+ }
+
+ return itemlist;
+}
+
+bool QDeclarativeViewObserverPrivate::isEditorItem(QGraphicsItem *item) const
+{
+ return (item->type() == Constants::EditorItemType
+ || item->type() == Constants::ResizeHandleItemType
+ || item->data(Constants::EditorItemDataKey).toBool());
+}
+
+void QDeclarativeViewObserverPrivate::_q_onStatusChanged(QDeclarativeView::Status status)
+{
+ if (status == QDeclarativeView::Ready) {
+ if (view->rootObject()) {
+ if (subcomponentEditorTool->contextIndex() != -1)
+ subcomponentEditorTool->clear();
+ subcomponentEditorTool->pushContext(view->rootObject());
+ }
+ q->sendReloaded();
+ }
+}
+
+void QDeclarativeViewObserverPrivate::_q_onCurrentObjectsChanged(QList<QObject*> objects)
+{
+ QList<QGraphicsItem*> items;
+ QList<QGraphicsObject*> gfxObjects;
+ foreach (QObject *obj, objects) {
+ QDeclarativeItem* declarativeItem = qobject_cast<QDeclarativeItem*>(obj);
+ if (declarativeItem) {
+ items << declarativeItem;
+ if (QGraphicsObject *gfxObj = declarativeItem->toGraphicsObject())
+ gfxObjects << gfxObj;
+ }
+ }
+ if (designModeBehavior) {
+ setSelectedItemsForTools(items);
+ clearHighlight();
+ highlight(gfxObjects, QDeclarativeViewObserverPrivate::IgnoreContext);
+ }
+}
+
+// adjusts bounding boxes on edges of screen to be visible
+QRectF QDeclarativeViewObserver::adjustToScreenBoundaries(const QRectF &boundingRectInSceneSpace)
+{
+ int marginFromEdge = 1;
+ QRectF boundingRect(boundingRectInSceneSpace);
+ if (qAbs(boundingRect.left()) - 1 < 2)
+ boundingRect.setLeft(marginFromEdge);
+
+ QRect rect = data->view->rect();
+
+ if (boundingRect.right() >= rect.right())
+ boundingRect.setRight(rect.right() - marginFromEdge);
+
+ if (qAbs(boundingRect.top()) - 1 < 2)
+ boundingRect.setTop(marginFromEdge);
+
+ if (boundingRect.bottom() >= rect.bottom())
+ boundingRect.setBottom(rect.bottom() - marginFromEdge);
+
+ return boundingRect;
+}
+
+void QDeclarativeViewObserverPrivate::createToolBox()
+{
+ toolBox = new ToolBox(q->declarativeView());
+
+ QmlToolBar *toolBar = toolBox->toolBar();
+
+ QObject::connect(q, SIGNAL(selectedColorChanged(QColor)),
+ toolBar, SLOT(setColorBoxColor(QColor)));
+
+ QObject::connect(q, SIGNAL(designModeBehaviorChanged(bool)),
+ toolBar, SLOT(setDesignModeBehavior(bool)));
+
+ QObject::connect(toolBar, SIGNAL(designModeBehaviorChanged(bool)),
+ q, SLOT(setDesignModeBehavior(bool)));
+ QObject::connect(toolBar, SIGNAL(animationSpeedChanged(qreal)), q, SLOT(setAnimationSpeed(qreal)));
+ QObject::connect(toolBar, SIGNAL(animationPausedChanged(bool)), q, SLOT(setAnimationPaused(bool)));
+ QObject::connect(toolBar, SIGNAL(colorPickerSelected()), this, SLOT(_q_changeToColorPickerTool()));
+ QObject::connect(toolBar, SIGNAL(zoomToolSelected()), this, SLOT(_q_changeToZoomTool()));
+ QObject::connect(toolBar, SIGNAL(selectToolSelected()), this, SLOT(_q_changeToSingleSelectTool()));
+ QObject::connect(toolBar, SIGNAL(marqueeSelectToolSelected()),
+ this, SLOT(_q_changeToMarqueeSelectTool()));
+
+ QObject::connect(toolBar, SIGNAL(applyChangesFromQmlFileSelected()),
+ this, SLOT(_q_applyChangesFromClient()));
+
+ QObject::connect(q, SIGNAL(animationSpeedChanged(qreal)), toolBar, SLOT(setAnimationSpeed(qreal)));
+ QObject::connect(q, SIGNAL(animationPausedChanged(bool)), toolBar, SLOT(setAnimationPaused(bool)));
+
+ QObject::connect(q, SIGNAL(selectToolActivated()), toolBar, SLOT(activateSelectTool()));
+
+ // disabled features
+ //connect(d->m_toolBar, SIGNAL(applyChangesToQmlFileSelected()), SLOT(applyChangesToClient()));
+ //connect(q, SIGNAL(resizeToolActivated()), d->m_toolBar, SLOT(activateSelectTool()));
+ //connect(q, SIGNAL(moveToolActivated()), d->m_toolBar, SLOT(activateSelectTool()));
+
+ QObject::connect(q, SIGNAL(colorPickerActivated()), toolBar, SLOT(activateColorPicker()));
+ QObject::connect(q, SIGNAL(zoomToolActivated()), toolBar, SLOT(activateZoom()));
+ QObject::connect(q, SIGNAL(marqueeSelectToolActivated()),
+ toolBar, SLOT(activateMarqueeSelectTool()));
+}
+
+void QDeclarativeViewObserver::handleMessage(const QByteArray &message)
+{
+ QDataStream ds(message);
+
+ ObserverProtocol::Message type;
+ ds >> type;
+
+ switch (type) {
+ case ObserverProtocol::SetCurrentObjects: {
+ int itemCount = 0;
+ ds >> itemCount;
+
+ QList<QObject*> selectedObjects;
+ for (int i = 0; i < itemCount; ++i) {
+ int debugId = -1;
+ ds >> debugId;
+ QObject *obj = QDeclarativeDebugService::objectForId(debugId);
+
+ if (obj)
+ selectedObjects << obj;
+ }
+
+ data->_q_onCurrentObjectsChanged(selectedObjects);
+ break;
+ }
+ case ObserverProtocol::Reload: {
+ data->_q_reloadView();
+ break;
+ }
+ case ObserverProtocol::SetAnimationSpeed: {
+ qreal speed;
+ ds >> speed;
+ animationSpeedChangeRequested(speed);
+ break;
+ }
+ case ObserverProtocol::SetAnimationPaused: {
+ bool paused;
+ ds >> paused;
+ animationPausedChangeRequested(paused);
+ break;
+ }
+ case ObserverProtocol::ChangeTool: {
+ ObserverProtocol::Tool tool;
+ ds >> tool;
+ switch (tool) {
+ case ObserverProtocol::ColorPickerTool:
+ data->_q_changeToColorPickerTool();
+ break;
+ case ObserverProtocol::SelectTool:
+ data->_q_changeToSingleSelectTool();
+ break;
+ case ObserverProtocol::SelectMarqueeTool:
+ data->_q_changeToMarqueeSelectTool();
+ break;
+ case ObserverProtocol::ZoomTool:
+ data->_q_changeToZoomTool();
+ break;
+ default:
+ qWarning() << "Warning: Unhandled tool:" << tool;
+ }
+ break;
+ }
+ case ObserverProtocol::SetDesignMode: {
+ bool inDesignMode;
+ ds >> inDesignMode;
+ setDesignModeBehavior(inDesignMode);
+ break;
+ }
+ case ObserverProtocol::ShowAppOnTop: {
+ bool showOnTop;
+ ds >> showOnTop;
+ setShowAppOnTop(showOnTop);
+ break;
+ }
+ case ObserverProtocol::CreateObject: {
+ QString qml;
+ int parentId;
+ QString filename;
+ QStringList imports;
+ ds >> qml >> parentId >> imports >> filename;
+ data->_q_createQmlObject(qml, QDeclarativeDebugService::objectForId(parentId),
+ imports, filename);
+ break;
+ }
+ case ObserverProtocol::DestroyObject: {
+ int debugId;
+ ds >> debugId;
+ if (QObject* obj = QDeclarativeDebugService::objectForId(debugId))
+ obj->deleteLater();
+ break;
+ }
+ case ObserverProtocol::MoveObject: {
+ int debugId, newParent;
+ ds >> debugId >> newParent;
+ data->_q_reparentQmlObject(QDeclarativeDebugService::objectForId(debugId),
+ QDeclarativeDebugService::objectForId(newParent));
+ break;
+ }
+ case ObserverProtocol::ObjectIdList: {
+ int itemCount;
+ ds >> itemCount;
+ data->stringIdForObjectId.clear();
+ for (int i = 0; i < itemCount; ++i) {
+ int itemDebugId;
+ QString itemIdString;
+ ds >> itemDebugId
+ >> itemIdString;
+
+ data->stringIdForObjectId.insert(itemDebugId, itemIdString);
+ }
+ break;
+ }
+ case ObserverProtocol::SetContextPathIdx: {
+ int contextPathIndex;
+ ds >> contextPathIndex;
+ data->_q_changeContextPathIndex(contextPathIndex);
+ break;
+ }
+ case ObserverProtocol::ClearComponentCache: {
+ data->_q_clearComponentCache();
+ break;
+ }
+ default:
+ qWarning() << "Warning: Not handling message:" << type;
+ }
+}
+
+void QDeclarativeViewObserver::sendDesignModeBehavior(bool inDesignMode)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::SetDesignMode
+ << inDesignMode;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendCurrentObjects(QList<QObject*> objects)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::CurrentObjectsChanged
+ << objects.length();
+
+ foreach (QObject *object, objects) {
+ int id = QDeclarativeDebugService::idForObject(object);
+ ds << id;
+ }
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendCurrentTool(Constants::DesignTool toolId)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::ToolChanged
+ << toolId;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendAnimationSpeed(qreal slowDownFactor)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::AnimationSpeedChanged
+ << slowDownFactor;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendAnimationPaused(bool paused)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::AnimationPausedChanged
+ << paused;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendReloaded()
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::Reloaded;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendShowAppOnTop(bool showAppOnTop)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::ShowAppOnTop << showAppOnTop;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendColorChanged(const QColor &color)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::ColorChanged
+ << color;
+
+ data->debugService->sendMessage(message);
+}
+
+void QDeclarativeViewObserver::sendContextPathUpdated(const QStringList &contextPath)
+{
+ QByteArray message;
+ QDataStream ds(&message, QIODevice::WriteOnly);
+
+ ds << ObserverProtocol::ContextPathUpdated
+ << contextPath;
+
+ data->debugService->sendMessage(message);
+}
+
+QString QDeclarativeViewObserver::idStringForObject(QObject *obj) const
+{
+ int id = QDeclarativeDebugService::idForObject(obj);
+ QString idString = data->stringIdForObjectId.value(id, QString());
+ return idString;
+}
+
+QT_END_NAMESPACE
+
+#include "qdeclarativeviewobserver.moc"
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEVIEWOBSERVER_P_H
+#define QDECLARATIVEVIEWOBSERVER_P_H
+
+#include <private/qdeclarativeglobal_p.h>
+#include "qmlobserverconstants_p.h"
+
+#include <QtCore/QScopedPointer>
+#include <QtDeclarative/QDeclarativeView>
+
+QT_FORWARD_DECLARE_CLASS(QDeclarativeItem)
+QT_FORWARD_DECLARE_CLASS(QMouseEvent)
+QT_FORWARD_DECLARE_CLASS(QToolBar)
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserverPrivate;
+
+class QDeclarativeViewObserver : public QObject
+{
+ Q_OBJECT
+
+public:
+ explicit QDeclarativeViewObserver(QDeclarativeView *view, QObject *parent = 0);
+ ~QDeclarativeViewObserver();
+
+ void setSelectedItems(QList<QGraphicsItem *> items);
+ QList<QGraphicsItem *> selectedItems() const;
+
+ QDeclarativeView *declarativeView();
+
+ QRectF adjustToScreenBoundaries(const QRectF &boundingRectInSceneSpace);
+
+ bool showAppOnTop() const;
+
+ void sendDesignModeBehavior(bool inDesignMode);
+ void sendCurrentObjects(QList<QObject*> items);
+ void sendAnimationSpeed(qreal slowDownFactor);
+ void sendAnimationPaused(bool paused);
+ void sendCurrentTool(Constants::DesignTool toolId);
+ void sendReloaded();
+ void sendShowAppOnTop(bool showAppOnTop);
+
+ QString idStringForObject(QObject *obj) const;
+
+public Q_SLOTS:
+ void sendColorChanged(const QColor &color);
+ void sendContextPathUpdated(const QStringList &contextPath);
+
+ void setDesignModeBehavior(bool value);
+ bool designModeBehavior();
+
+ void setShowAppOnTop(bool appOnTop);
+
+ void setAnimationSpeed(qreal factor);
+ void setAnimationPaused(bool paused);
+
+ void setObserverContext(int contextIndex);
+
+Q_SIGNALS:
+ void designModeBehaviorChanged(bool inDesignMode);
+ void showAppOnTopChanged(bool showAppOnTop);
+ void reloadRequested();
+ void marqueeSelectToolActivated();
+ void selectToolActivated();
+ void zoomToolActivated();
+ void colorPickerActivated();
+ void selectedColorChanged(const QColor &color);
+
+ void animationSpeedChanged(qreal factor);
+ void animationPausedChanged(bool paused);
+
+ void inspectorContextCleared();
+ void inspectorContextPushed(const QString &contextTitle);
+ void inspectorContextPopped();
+
+protected:
+ bool eventFilter(QObject *obj, QEvent *event);
+
+ bool leaveEvent(QEvent *);
+ bool mousePressEvent(QMouseEvent *event);
+ bool mouseMoveEvent(QMouseEvent *event);
+ bool mouseReleaseEvent(QMouseEvent *event);
+ bool keyPressEvent(QKeyEvent *event);
+ bool keyReleaseEvent(QKeyEvent *keyEvent);
+ bool mouseDoubleClickEvent(QMouseEvent *event);
+ bool wheelEvent(QWheelEvent *event);
+
+ void setSelectedItemsForTools(QList<QGraphicsItem *> items);
+
+private slots:
+ void handleMessage(const QByteArray &message);
+
+ void animationSpeedChangeRequested(qreal factor);
+ void animationPausedChangeRequested(bool paused);
+
+private:
+ Q_DISABLE_COPY(QDeclarativeViewObserver)
+
+ inline QDeclarativeViewObserverPrivate *d_func() { return data.data(); }
+ QScopedPointer<QDeclarativeViewObserverPrivate> data;
+ friend class QDeclarativeViewObserverPrivate;
+ friend class AbstractLiveEditTool;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEVIEWOBSERVER_P_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEVIEWOBSERVER_P_P_H
+#define QDECLARATIVEVIEWOBSERVER_P_P_H
+
+#include "qdeclarativeviewobserver_p.h"
+
+#include <QtCore/QWeakPointer>
+#include <QtCore/QPointF>
+
+#include "QtDeclarative/private/qdeclarativeobserverservice_p.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Declarative)
+
+class QDeclarativeViewObserver;
+class LiveSelectionTool;
+class ZoomTool;
+class ColorPickerTool;
+class LiveLayerItem;
+class BoundingRectHighlighter;
+class SubcomponentEditorTool;
+class ToolBox;
+class AbstractLiveEditTool;
+
+class QDeclarativeViewObserverPrivate : public QObject
+{
+ Q_OBJECT
+public:
+ enum ContextFlags {
+ IgnoreContext,
+ ContextSensitive
+ };
+
+ QDeclarativeViewObserverPrivate(QDeclarativeViewObserver *);
+ ~QDeclarativeViewObserverPrivate();
+
+ QDeclarativeView *view;
+ QDeclarativeViewObserver *q;
+ QDeclarativeObserverService *debugService;
+ QWeakPointer<QWidget> viewport;
+ QHash<int, QString> stringIdForObjectId;
+
+ QPointF cursorPos;
+ QList<QWeakPointer<QGraphicsObject> > currentSelection;
+
+ Constants::DesignTool currentToolMode;
+ AbstractLiveEditTool *currentTool;
+
+ LiveSelectionTool *selectionTool;
+ ZoomTool *zoomTool;
+ ColorPickerTool *colorPickerTool;
+ SubcomponentEditorTool *subcomponentEditorTool;
+ LiveLayerItem *manipulatorLayer;
+
+ BoundingRectHighlighter *boundingRectHighlighter;
+
+ bool designModeBehavior;
+ bool showAppOnTop;
+
+ bool animationPaused;
+ qreal slowDownFactor;
+
+ ToolBox *toolBox;
+
+ void setViewport(QWidget *widget);
+
+ void clearEditorItems();
+ void createToolBox();
+ void changeToSelectTool();
+ QList<QGraphicsItem*> filterForCurrentContext(QList<QGraphicsItem*> &itemlist) const;
+ QList<QGraphicsItem*> filterForSelection(QList<QGraphicsItem*> &itemlist) const;
+
+ QList<QGraphicsItem*> selectableItems(const QPoint &pos) const;
+ QList<QGraphicsItem*> selectableItems(const QPointF &scenePos) const;
+ QList<QGraphicsItem*> selectableItems(const QRectF &sceneRect, Qt::ItemSelectionMode selectionMode) const;
+
+ void setSelectedItemsForTools(QList<QGraphicsItem *> items);
+ void setSelectedItems(QList<QGraphicsItem *> items);
+ QList<QGraphicsItem *> selectedItems() const;
+
+ void changeTool(Constants::DesignTool tool,
+ Constants::ToolFlags flags = Constants::NoToolFlags);
+
+ void clearHighlight();
+ void highlight(QList<QGraphicsObject *> item, ContextFlags flags = ContextSensitive);
+ void highlight(QGraphicsObject *item, ContextFlags flags = ContextSensitive);
+
+ bool mouseInsideContextItem() const;
+ bool isEditorItem(QGraphicsItem *item) const;
+
+ QGraphicsItem *currentRootItem() const;
+
+ void enterContext(QGraphicsItem *itemToEnter);
+
+public slots:
+ void _q_setToolBoxVisible(bool visible);
+
+ void _q_reloadView();
+ void _q_onStatusChanged(QDeclarativeView::Status status);
+ void _q_onCurrentObjectsChanged(QList<QObject*> objects);
+ void _q_applyChangesFromClient();
+ void _q_createQmlObject(const QString &qml, QObject *parent,
+ const QStringList &imports, const QString &filename = QString());
+ void _q_reparentQmlObject(QObject *, QObject *);
+
+ void _q_changeToSingleSelectTool();
+ void _q_changeToMarqueeSelectTool();
+ void _q_changeToZoomTool();
+ void _q_changeToColorPickerTool();
+ void _q_changeContextPathIndex(int index);
+ void _q_clearComponentCache();
+ void _q_removeFromSelection(QObject *);
+
+public:
+ static QDeclarativeViewObserverPrivate *get(QDeclarativeViewObserver *v) { return v->d_func(); }
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEVIEWOBSERVER_P_P_H
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
-** This file is part of the Declarative module of the Qt Toolkit.
+** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
**
****************************************************************************/
-#ifndef SPEEDLIMITAFFECTOR_H
-#define SPEEDLIMITAFFECTOR_H
-#include "particleaffector.h"
+#ifndef QMLOBSERVERCONSTANTS_H
+#define QMLOBSERVERCONSTANTS_H
+
+#include <QtDeclarative/private/qdeclarativeglobal_p.h>
QT_BEGIN_HEADER
QT_MODULE(Declarative)
-class SpeedLimitAffector : public ParticleAffector
-{
- Q_OBJECT
- Q_PROPERTY(qreal speedLimit READ speedLimit WRITE setSpeedLimit NOTIFY speedLimitChanged)
+namespace Constants {
+enum DesignTool {
+ NoTool = 0,
+ SelectionToolMode = 1,
+ MarqueeSelectionToolMode = 2,
+ MoveToolMode = 3,
+ ResizeToolMode = 4,
+ ColorPickerMode = 5,
+ ZoomMode = 6
+};
-public:
- explicit SpeedLimitAffector(QSGItem *parent = 0);
+enum ToolFlags {
+ NoToolFlags = 0,
+ UseCursorPos = 1
+};
- qreal speedLimit() const
- {
- return m_speedLimit;
- }
+static const int DragStartTime = 50;
-protected:
- virtual bool affectParticle(ParticleData *d, qreal dt);
-signals:
+static const int DragStartDistance = 20;
- void speedLimitChanged(qreal arg);
+static const double ZoomSnapDelta = 0.04;
-public slots:
-void setSpeedLimit(qreal arg)
-{
- if (m_speedLimit != arg) {
- m_speedLimit = arg;
- emit speedLimitChanged(arg);
- }
-}
+static const int EditorItemDataKey = 1000;
-private:
-qreal m_speedLimit;
+enum GraphicsItemTypes {
+ EditorItemType = 0xEAAA,
+ ResizeHandleItemType = 0xEAEA
};
+
+} // namespace Constants
+
QT_END_NAMESPACE
QT_END_HEADER
-#endif // SPEEDLIMITAFFECTOR_H
+#endif // QMLOBSERVERCONSTANTS_H
d->protocol = 0;
}
+bool QmlOstPlugin::waitForMessage()
+{
+ Q_D(QmlOstPlugin);
+ return d->protocol->waitForReadyRead(-1);
+}
+
void QmlOstPlugin::setPort(int port, bool block)
{
Q_UNUSED(port);
bool isConnected() const;
void send(const QByteArray &message);
void disconnect();
+ bool waitForMessage();
private Q_SLOTS:
void readyRead();
Cancel();
}
+ TInt& AoFlags() { return ((TInt*)&iStatus)[1]; }
+
private:
void RunL();
void DoCancel();
RUsbOstComm ost;
TBuf8<4096> readBuf;
QByteArray dataBuf;
+ TBool inReadyRead;
};
QOstDevice::QOstDevice(QObject *parent) :
ost.ReadMessage(iStatus, readBuf);
SetActive();
- emit q->readyRead();
+ if (!inReadyRead) {
+ inReadyRead = true;
+ emit q->readyRead();
+ inReadyRead = false;
+ }
} else {
q->setErrorString(QString("Error %1 from RUsbOstComm::ReadMessage()").arg(iStatus.Int()));
}
Q_D(const QOstDevice);
return d->dataBuf.length();
}
+
+bool QOstDevice::waitForReadyRead(int msecs)
+{
+ Q_D(QOstDevice);
+ if (msecs >= 0) {
+ RTimer timer;
+ TInt err = timer.CreateLocal();
+ if (err) return false;
+ TRequestStatus timeoutStat;
+ timer.After(timeoutStat, msecs*1000);
+ User::WaitForRequest(timeoutStat, d->iStatus);
+ if (timeoutStat != KRequestPending) {
+ // Timed out
+ timer.Close();
+ return false;
+ } else {
+ // We got data, so cancel timer
+ timer.Cancel();
+ User::WaitForRequest(timeoutStat);
+ timer.Close();
+ // And drop through
+ }
+ } else {
+ // Just wait forever for data
+ User::WaitForRequest(d->iStatus);
+ }
+
+ // If we get here we have data
+ TInt err = d->iStatus.Int();
+ d->AoFlags() &= ~3; // This is necessary to clean up the scheduler as you're not supposed to bypass it like this
+ TRAP_IGNORE(d->RunL());
+ return err == KErrNone;
+}
bool open(int ostProtocolId);
void close();
+ bool waitForReadyRead(int msecs);
+ qint64 bytesAvailable() const;
+
protected:
qint64 readData(char *data, qint64 maxSize);
qint64 writeData(const char *data, qint64 maxSize);
- qint64 bytesAvailable() const;
private:
QOstDevicePrivate* d_ptr;
#include "qtcpserverconnection.h"
+#include <QtCore/qplugin.h>
#include <QtNetwork/qtcpserver.h>
#include <QtNetwork/qtcpsocket.h>
#ifndef QTCPSERVERCONNECTION_H
#define QTCPSERVERCONNECTION_H
-#include <QtGui/QStylePlugin>
#include <QtDeclarative/private/qdeclarativedebugserverconnection_p.h>
QT_BEGIN_NAMESPACE
TEMPLATE = subdirs
-SUBDIRS = qmldbg_tcp
+SUBDIRS = qmldbg_tcp declarativeobserver
symbian:SUBDIRS += qmldbg_ost
%moduleheaders = ( # restrict the module headers to those found in relative path
);
%classnames = (
+ "qtdeclarativeversion.h" => "QtDeclarativeVersion",
);
%mastercontent = (
"gui" => "#include <QtGui/QtGui>\n",
projects / profile / ivi / qtdeclarative.git / commitdiff
