Change copyrights from Nokia to Digia
[qt:qtfeedback.git] / src / feedback / qfeedbackeffect.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the QtFeedback module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.  For licensing terms and
14 ** conditions see http://qt.digia.com/licensing.  For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file.  Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights.  These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file.  Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include "qfeedbackeffect.h"
43 #include "qfeedbackeffect_p.h"
44 #include "qfeedbackplugininterfaces.h"
45
46 #include <QtCore>
47 #include <QDebug>
48
49
50 QT_BEGIN_NAMESPACE
51
52 /*!
53     \class QFeedbackEffect
54     \brief The QFeedbackEffect class is the abstract base class for feedback effects.
55     \ingroup feedback
56     \inmodule QtFeedback
57
58     It represents an effect to provide feedback to a person (i.e., an effect that
59     affect human senses). The technology available today usually only
60     provides haptic effects, which deal with the sense of touch, and audio effects. The
61     QFeedbackHapticsEffect and QFeedbackFileEffect are implementations
62     of haptic effects and can be used to control a mobile device's
63     vibrator.  In addition, the QFeedbackFileEffect can also be used to play
64     audio feedback.
65
66     Feedback effects have a duration, which is measured in
67     milliseconds. Subclasses reimplement duration() to inform how long
68     the effect lasts.  The duration is the total time the effect will
69     last, and thus includes any envelope modifiers (attack and fade).
70
71     At any given time, a feedback effect is in one of four states:
72     Loading, Stopped, Running, or Paused. See the
73     \l{QFeedbackEffect::}{State} enum documentation for further
74     details. Subclasses must reimplement state() to report which
75     state an effect is in, and setState() to receive state change
76     requests. The start(), pause(), and stop() slots calls
77     setState() with the corresponding new \l{QFeedbackEffect::}{State}.  Changes
78     in state are reported through the stateChanged() signal and may happen
79     asynchronously some time after the state change request.
80
81     A system often has a set of standard feedback effects for user
82     interface interaction (e.g., button clicks). The
83     \l{QFeedbackEffect::}{Effect} describes the standard effects
84     that QFeedbackEffect supports. It is named so because the effects
85     often depend on the theme of the user interface. You can play
86     these effects using the playThemeEffect() function.
87
88     \code
89         QFeedbackEffect::playThemeEffect(QFeedbackEffect::Press);
90     \endcode
91
92     The playThemeEffect() function returns true if the effect was
93     played successfully. An effect may not be played if the system does
94     not support it or if an error occurred.
95 */
96
97 /*!
98     \fn void QFeedbackEffect::error(QFeedbackEffect::ErrorType error) const
99
100     This signal is emitted by subclasses if an \a error occurred during
101     playback of an effect. The \l{QFeedbackEffect::}{ErrorType} enum
102     describes the errors that can be reported.
103 */
104
105 /*!
106     \fn void QFeedbackEffect::stateChanged()
107
108     This signal is emitted by subclasses when the \l State of the
109     effect changes.
110
111     \sa state()
112 */
113
114 /*!
115     \enum QFeedbackEffect::State
116
117     This enum describes the state of the effect. An effect will be in
118     one of these states.
119
120     \value Stopped The effect is not running. This is the initial
121     state. The state changes to either Loading when loading an effect
122     or to Running when the effect is started by calling start().  When
123     an effect has finished playing, it will enter the Stopped state
124     again.
125
126     \value Paused The effect is paused. Calling start() will resume it.
127
128     \value Running The effect is running. You can control the current state
129     by calling the stop() or pause() functions.
130
131     \value Loading The effect is loading. That can happen when loading
132     is done asynchronously.  When the effect has loaded, the state will change
133     to either Running (if start() has been called) or Stopped.
134
135     \sa state()
136 */
137
138
139 /*!
140     \enum QFeedbackEffect::ErrorType
141
142     This enum describes the possible errors happening on the effect.
143
144     \value UnknownError An unknown error occurred.
145
146     \value DeviceBusy The feedback could not start because the device is busy.
147
148     \sa error()
149 */
150
151 /*!
152     \enum QFeedbackEffect::Effect
153
154     This enum describes all possible effect types. Effects might
155     be tactile, or audio or visual.
156
157     Not all platforms and devices have distinct effects for each type.
158
159     \value Effect.Undefined - Undefined feedback. No feedback is given.
160     \value Effect.Press - Feedback for when the screen is pressed.
161     \value Effect.Release - Feedback for touch release.
162     \value Effect.PressWeak - A weak feedback for press.
163     \value Effect.ReleaseWeak - A weak feedback for release.
164     \value Effect.PressStrong - A strong feedback for press.
165     \value Effect.ReleaseStrong - A strong feedback for release.
166     \value Effect.DragStart - Feedback for when dragging starts.
167     \value Effect.DragDropInZone - Feedback for when dragging ends and touch is released inside a drop zone.
168     \value Effect.DragDropOutOfZone - Feedback for when dragging ends and touch is released outside a drop zone.
169     \value Effect.DragCrossBoundary - Feedback for when crossing a boundary while dragging.
170     \value Effect.Appear - Feedback for when an item is shown.
171     \value Effect.Disappear - Feedback for when an item is closed.
172     \value Effect.Move - Feedback for dragging on screen.
173     \value NumberOfEffects The number of built-in effects.
174     \value UserEffect The starting point for any user defined effects, where supported.
175  */
176
177 /*!
178     \enum QFeedbackEffect::Duration
179     This enum describes the possible effect predefined duration types.  Generally a specific
180     milliseconds value can be supplied instead of one of these values.
181
182     \value Infinite  Infinite effect duration
183   */
184
185 /*!
186     \property QFeedbackEffect::state
187     \brief state of the feedback effect.
188
189     This returns the state of the feedback effect.  The \l State enumeration reports
190     the possible states.
191 */
192
193 /*!
194     \property QFeedbackEffect::duration
195     \brief duration of the feedback effect, in milliseconds.
196
197     In some cases the duration will be unknown, which will be reported as 0.  If the duration
198     is infinite, QFeedbackEffect::Infinite will be returned.  Some subclasses may have
199     more than one type of duration (for example, \l QFeedbackHapticsEffect), and this
200     property will return the total duration of the effect.
201 */
202
203 /*!
204     Constructs the QFeedbackEffect base class, and passes \a parent to
205     QObject's constructor.  This is called by the classes that inherit
206     from this class.
207 */
208 QFeedbackEffect::QFeedbackEffect(QObject *parent) : QObject(parent)
209 {
210 }
211
212 /*!
213     \fn void QFeedbackEffect::start()
214
215     Starts playing the effect. If an error occurs the
216     error() signal will be emitted.
217
218     \sa stop()
219 */
220 void QFeedbackEffect::start()
221 {
222     setState(Running);
223 }
224
225 /*!
226     \fn void QFeedbackEffect::stop()
227
228     Stops a playing effect. If an error occurs the
229     error() signal will be emitted.
230
231     \sa start(), pause(), setState()
232 */
233 void QFeedbackEffect::stop()
234 {
235     setState(Stopped);
236 }
237
238 /*!
239     \fn void QFeedbackEffect::pause()
240
241     Pauses a playing effect. If an error occurs the
242     error() signal will be emitted.  Not all systems
243     support pausing an effect during playback.
244 */
245 void QFeedbackEffect::pause()
246 {
247     setState(Paused);
248 }
249
250 /*!
251     \fn QFeedbackEffect::playThemeEffect(Effect effect)
252
253     This function plays \a effect instantly and returns true if the
254     effect could be played; otherwise, returns false.
255 */
256 bool QFeedbackEffect::playThemeEffect(Effect effect)
257 {
258     if (QFeedbackThemeInterface *iface = QFeedbackThemeInterface::instance())
259         return iface->play(effect);
260     return false;
261 }
262
263 /*!
264     \fn QFeedbackEffect::supportsThemeEffect()
265
266     Returns true if playing themed feedback is available.
267
268 */
269 bool QFeedbackEffect::supportsThemeEffect()
270 {
271     return QFeedbackThemeInterface::instance() != 0;
272 }
273
274 /*!
275     \class QFeedbackHapticsEffect
276     \ingroup feedback
277     \inmodule QtFeedback
278     \brief The QFeedbackHapticsEffect class allows you to play a haptics effect.
279
280     A haptics effect is an effect that takes advantage of the sense of
281     touch. Most mobile devices today supports one such effect,
282     vibration, which will then be the default when you create a
283     QFeedbackHapticsEffect.
284
285     A haptics effect has a few parameters that must be set up before
286     it can be played:
287
288     \list
289         \li duration(): The total duration of the effect in milliseconds.
290         \li intensity(): The intensity, e.g., how hard the device will vibrate.
291     \endlist
292
293     An effect can, for example, be set up as follows:
294
295     \omit I'm right that this is all that is required to be set? \endomit
296     \code
297         QFeedbackHapticsEffect rumble;
298         rumble.setIntensity(1.0);
299         rumble.setDuration(100);
300     \endcode
301
302     You can now start() the effect.
303
304     \code
305         rumble.start();
306     \endcode
307
308     At any given time, the effect is in one of four states:
309     \l{QFeedbackEffect::}{Stopped}, \l{QFeedbackEffect::}{Paused},
310     \l{QFeedbackEffect::}{Running}, or \l{QFeedbackEffect::}{Loading}.
311     You can request a state change by calling start(), pause(), or
312     stop(). The state is queried with state().
313
314     The haptics effect also supports a fade-in of the effect. For
315     vibration, this means that the vibration will grow (or sink) in
316     intensity from when the effect starts until intensity() is
317     reached. You can set that up as follows:
318
319     \code
320         rumble.setAttackIntensity(0.0);
321         rumble.setAttackTime(250);
322     \endcode
323
324     Attack intensity is the start intensity and attack time is the
325     duration of the fade-in. We have a similar fade-out:
326
327     \code
328         rumble.setFadeTime(250);
329         rumble.setFadeIntensity(0.0);
330     \endcode
331
332     When using fade-in and fade-out the total duration of the haptics
333     effect will be: duration(); the main intensity() will be played for
334     (duration() - (attackTime() + fadeTime())) milliseconds.
335
336     A QFeedbackHapticsEffect is played on an
337     \l{QFeedbackHapticsEffect::}{actuator()}, which is the physical component that
338     performs the effect. You can query if other actuators are
339     available - see the QFeedbackActuator::actuators() function
340     documentation for details.
341
342     Errors occurring during playback are notified through the
343     error() signal.
344
345     \sa QFeedbackActuator
346 */
347
348 /*!
349     \fn virtual void QFeedbackEffect::setState(State state) = 0
350
351     Requests the effect to change its State to change to the specified \a state.
352
353     Subclasses reimplement this function to handle state change requests
354     for the effect.
355 */
356
357 /*!
358     Constructs the QFeedbackHapticsEffect class, and passes \a parent to
359     QObject's constructor.  The default QFeedbackActuator will be used.
360
361     \sa QFeedbackActuator::actuators()
362 */
363 QFeedbackHapticsEffect::QFeedbackHapticsEffect(QObject *parent) : QFeedbackEffect(parent), priv(new QFeedbackHapticsEffectPrivate)
364 {
365     setActuator(0);
366 }
367
368
369 /*!
370     Destroys this effect and stops the feedback if it is running.
371 */
372 QFeedbackHapticsEffect::~QFeedbackHapticsEffect()
373 {
374     stop();
375 }
376
377 /*!
378     \property QFeedbackHapticsEffect::duration
379     \brief the expected duration of the effect.
380
381     This property defines the total duration of the feedback effect, in milliseconds.
382     It includes the duration of any fade-in or fade-out parts, if any, in non-periodic
383     effects, and includes all repetitions of the period in periodic-effects, if any.
384
385     If the duration is set to a value less than attackTime() + fadeTime(), or less
386     than the period() of the effect, the waveform which will result is
387     backend-specific.
388
389     \sa fadeTime(), attackTime(), period()
390 */
391 int QFeedbackHapticsEffect::duration() const
392 {
393     return priv->duration;
394 }
395 void QFeedbackHapticsEffect::setDuration(int msecs)
396 {
397     if (priv->duration == msecs)
398         return;
399     priv->duration = msecs;
400     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::Duration);
401 }
402
403 /*!
404     \property QFeedbackHapticsEffect::intensity
405     \brief the intensity of the effect.
406
407     This property defines the intensity of the feedback effect.
408     The value can be between 0 and 1.
409
410     For non-periodic effects, the effect will be at this intensity for
411     (duration() - (attackTime() + fadeTime())) milliseconds.
412     For periodic effects, the effect will be at this intensity once per
413     period for (period() - (attackTime() + fadeTime())) milliseconds.
414 */
415 qreal QFeedbackHapticsEffect::intensity() const
416 {
417     return priv->intensity;
418 }
419 void QFeedbackHapticsEffect::setIntensity(qreal intensity)
420 {
421     if (priv->intensity == intensity)
422         return;
423     priv->intensity = intensity;
424     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::Intensity);
425 }
426
427 /*!
428     \property QFeedbackHapticsEffect::attackTime
429     \brief the duration of the fade-in effect.
430
431     This property defines the duration of the fade-in effect in milliseconds.
432     The effect will ramp up (or down) from attackIntensity() to intensity() in attackTime() milliseconds.
433
434     If the attack time is set to a value such that attackTime() + fadeTime()
435     is greater than duration() for non-periodic effects, or greater than
436     period() for periodic effects, the waveform which will result is
437     backend-specific.
438
439     \sa duration(), period()
440 */
441 int QFeedbackHapticsEffect::attackTime() const
442 {
443     return priv->attackTime;
444 }
445 void QFeedbackHapticsEffect::setAttackTime(int msecs)
446 {
447     if (priv->attackTime == msecs)
448         return;
449     priv->attackTime = msecs;
450     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::AttackTime);
451 }
452
453 /*!
454     \property QFeedbackHapticsEffect::attackIntensity
455     \brief the initial intensity of the effect.
456
457     This property defines the initial intensity of the effect, before it fades in.
458     It is usually lower than \l intensity.  The effect will ramp up (or down) from
459     attackIntensity() to intensity() in attackTime() milliseconds.
460 */
461 qreal QFeedbackHapticsEffect::attackIntensity() const
462 {
463     return priv->attackIntensity;
464 }
465 void QFeedbackHapticsEffect::setAttackIntensity(qreal intensity)
466 {
467     if (priv->attackIntensity == intensity)
468         return;
469     priv->attackIntensity = intensity;
470     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::AttackIntensity);
471 }
472
473 /*!
474     \property QFeedbackHapticsEffect::fadeTime
475     \brief the duration of the fade-out effect.
476
477     This property defines the duration of the fade-out effect in milliseconds.
478     The effect will ramp down (or up) from intensity() to fadeIntensity() in fadeTime() milliseconds.
479
480     If the fade time is set to a value such that attackTime() + fadeTime()
481     is greater than duration() for non-periodic effects, or greater than
482     period() for periodic effects, the waveform which will result is
483     backend-specific.
484
485     \sa duration(), period()
486 */
487 int QFeedbackHapticsEffect::fadeTime() const
488 {
489     return priv->fadeTime;
490 }
491 void QFeedbackHapticsEffect::setFadeTime(int msecs)
492 {
493     if (priv->fadeTime == msecs)
494         return;
495     priv->fadeTime = msecs;
496     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::FadeTime);
497 }
498
499 /*!
500     \property QFeedbackHapticsEffect::fadeIntensity
501     \brief the final intensity of the effect.
502
503     This property defines the final intensity of the effect, after it fades out.
504     It is usually lower than \l intensity.
505     The effect will ramp down (or up) from intensity() to fadeIntensity() in fadeTime() milliseconds.
506 */
507 qreal QFeedbackHapticsEffect::fadeIntensity() const
508 {
509     return priv->fadeIntensity;
510 }
511 void QFeedbackHapticsEffect::setFadeIntensity(qreal intensity)
512 {
513     if (priv->fadeIntensity == intensity)
514         return;
515     priv->fadeIntensity = intensity;
516     QFeedbackHapticsInterface::instance()->updateEffectProperty(this, QFeedbackHapticsInterface::FadeIntensity);
517 }
518
519 /*!
520     \property QFeedbackHapticsEffect::actuator
521     \brief the actuator on which the effect operates.
522
523     This property defines the actuator on which the effect operates.  You can only
524     change the actuator used when the effect is stopped.  Setting a null actuator
525     resets the effect to use the default actuator.
526 */
527 QFeedbackActuator* QFeedbackHapticsEffect::actuator() const
528 {
529     return priv->actuator;
530 }
531 void QFeedbackHapticsEffect::setActuator(QFeedbackActuator *actuator)
532 {
533     if (state() != Stopped) {
534         qWarning("QFeedbackHapticsEffect::setActuator: The effect is not stopped");
535         return;
536     }
537
538     if (actuator) {
539         priv->actuator = actuator;
540     } else {
541         QList<QFeedbackActuator*> list = QFeedbackActuator::actuators();
542         if  (!list.isEmpty()) {
543             priv->actuator = list.first();
544         } else {
545             priv->actuator = new QFeedbackActuator(this);
546         }
547     }
548 }
549
550 /*!
551     \property QFeedbackHapticsEffect::period
552     \brief set the period for the effect.
553
554     It has a default value of -1, which means that it is not a periodic effect.
555     You can only change the period when the effect is stopped.
556     The duration of the effect should be set to a value larger than the
557     period of the effect if you wish the periodicity to be discernable.
558     \note Not all actuators support periodic effects
559
560     The period defines the total length of the periodic envelope, which will
561     be repeated up until duration() milliseconds has elapsed.  For a periodic
562     effect, the intensity will start at attackIntensity(), ramp to intensity()
563     (where it stays for (period() - (attackTime() + fadeTime())) milliseconds),
564     then ramp to fadeIntensity().  This waveform will be repeated as many times
565     as required until the duration() has elapsed.
566
567     If the period is set to a value which is less than attackTime() + fadeTime(),
568     the waveform which will result is backend-specific.
569 */
570 int QFeedbackHapticsEffect::period() const
571 {
572     return priv->period;
573 }
574 void QFeedbackHapticsEffect::setPeriod(int msecs)
575 {
576     if (state() != Stopped) {
577         qWarning("QFeedbackHapticsEffect::setPeriod: the period can only be changed if the effect is stopped");
578         return;
579     }
580     priv->period = msecs;
581 }
582
583 /*!
584     \internal
585 */
586 void QFeedbackHapticsEffect::setState(State state)
587 {
588     State oldState = this->state();
589     if (oldState != state) {
590         QFeedbackHapticsInterface::instance()->setEffectState(this, state);
591         emit stateChanged();
592     }
593 }
594
595 /*!
596     \internal
597 */
598 QFeedbackEffect::State QFeedbackHapticsEffect::state() const
599 {
600     return QFeedbackHapticsInterface::instance()->effectState(this);
601 }
602
603 /*!
604 \internal
605     \class QFeedbackFileEffect
606     \ingroup feedback
607     \inmodule QtFeedback
608     \brief The QFeedbackFileEffect class allows to play feedback from a file.
609
610     Several different mime types may be supported on a system, including
611     both haptic data files, and audio files.
612
613     The files containing haptics data are usually suffixed \c .ivt.
614     The feedback is usually varying in
615     \l{QFeedbackHapticsEffect::}{intensity()}, and is for that reason
616     often referred to as a "haptic tune". They are created, for
617     instance, from music files where the feedback is based on a
618     specific feature in the audio data. For example, you could have a
619     phone vibrating along with the bass of a rock song.
620
621     Although Qt Feedback does not let you record \c .ivt files, it lets
622     you play them back using the QFeedbackFileEffect class. Setting
623     up a QFeedbackFileEffect and starting it is done as follows:
624
625     \code
626         QFeedbackFileEffect hapticTune;
627         hapticTune.setSource(QUrl::fromLocalFile("mySavedRumble.ivt"));
628         hapticTune.load();
629         hapticTune.start();
630     \endcode
631
632     As with other \l{QFeedbackEffect}s, QFeedbackFileEffect is at any
633     given time in one of four states: \l{QFeedbackEffect::}{Loading},
634     \l{QFeedbackEffect::}{Running}, \l{QFeedbackEffect::}{Paused}, or
635     \l{QFeedbackEffect::}{Stopped}. You request state changes with
636     start(), pause(), and stop().
637
638     You can load() and unload() the file at will to free resources or
639     be as fast as possible. The file must be loaded before it can be
640     started, and it cannot be unloaded while playing. After the file is
641     loaded, you can query its duration().  Some mime types may not
642     support duration information - in these cases, 0 will be returned.
643
644     QFeedbackFileEffect reports errors through the error() signal.
645
646     \sa QFeedbackHapticsEffect
647 */
648
649
650 /*!
651     \internal
652 */
653 void QFeedbackFileEffectPrivate::loadFinished(bool success)
654 {
655     loaded = success;
656     if( !success)
657         backendUsed = -1;
658 }
659
660
661 /*!
662     \internal
663     Constructs the QFeedbackFileEffect class, and passes \a parent to
664     QObject's constructor.
665 */
666 QFeedbackFileEffect::QFeedbackFileEffect(QObject *parent) : QFeedbackEffect(parent), priv(new QFeedbackFileEffectPrivate(this))
667 {
668 }
669
670 /*!
671     \internal
672     Stops the feedback and unloads the file if necessary.
673 */
674 QFeedbackFileEffect::~QFeedbackFileEffect()
675 {
676     setLoaded(false); //ensures we unload the file and frees resources
677 }
678
679 /*!
680     \reimp
681 */
682 int QFeedbackFileEffect::duration() const
683 {
684     return QFeedbackFileInterface::instance()->effectDuration(this);
685 }
686
687 /*!
688     \internal
689     \property QFeedbackFileEffect::source
690     \brief the url of the file that is loaded.
691
692     Setting that property will automatically unload the previous file (if any) and load the new one.
693     Some backends may not support all URL schemes - for example, they may only support
694     local files.
695
696     You can only change the source of an effect when it is stopped.
697 */
698 QUrl QFeedbackFileEffect::source() const
699 {
700     return priv->url;
701 }
702 void QFeedbackFileEffect::setSource(const QUrl &source)
703 {
704     if (state() != QFeedbackEffect::Stopped) {
705         qWarning("QFeedbackFileEffect::setSource: can't set the file while the feedback is running");
706         return;
707     }
708     if (source != priv->url) {
709         setLoaded(false);
710         priv->url = source;
711         setLoaded(true);
712     }
713 }
714
715 /*!
716     \internal
717     \property QFeedbackFileEffect::loaded
718     \brief reports if the file has been successfully loaded.
719 */
720 bool QFeedbackFileEffect::isLoaded() const
721 {
722     return priv->loaded;
723 }
724 void QFeedbackFileEffect::setLoaded(bool load)
725 {
726     if (priv->loaded == load)
727         return;
728
729     if (state() != QFeedbackEffect::Stopped) {
730         qWarning() << "QFeedbackFileEffect::setLoaded: can't load/unload a file while the effect is not stopped";
731         return;
732     }
733
734     QFeedbackFileInterface::instance()->setLoaded(this, load);
735 }
736
737
738 /*!
739     \internal
740     \fn void QFeedbackFileEffect::load()
741
742     Makes sure that the file associated with the feedback object is loaded.
743     It will be automatically loaded when the setSource() or start() functions
744     are called.
745 */
746 void QFeedbackFileEffect::load()
747 {
748     setLoaded(true);
749 }
750
751 /*!
752     \internal
753     \fn void QFeedbackFileEffect::unload()
754
755     makes sure that the file associated with the feedback object is unloaded.
756     It will be automatically unloaded when the setSource function is called with
757     another file or the object is destroyed.
758 */
759 void QFeedbackFileEffect::unload()
760 {
761     setLoaded(false);
762 }
763
764
765 /*!
766     \internal
767     \fn QStringList QFeedbackFileEffect::supportedMimeTypes()
768
769     returns the MIME types supported for playing effects from file.
770 */
771 QStringList QFeedbackFileEffect::supportedMimeTypes()
772 {
773     return QFeedbackFileInterface::instance()->supportedMimeTypes();
774 }
775
776
777 /*!
778     \reimp
779 */
780 void QFeedbackFileEffect::setState(State newState)
781 {
782     State oldState = state();
783     if (oldState != newState) {
784         if (newState != Stopped && state() == Stopped)
785             load(); // makes sure the file is loaded
786         QFeedbackFileInterface::instance()->setEffectState(this, newState);
787         emit stateChanged();
788     }
789 }
790
791 /*!
792     \reimp
793 */
794 QFeedbackEffect::State QFeedbackFileEffect::state() const
795 {
796     return QFeedbackFileInterface::instance()->effectState(this);
797 }
798
799 QT_END_NAMESPACE