← Back to branch summary

~ubuntu-branches/ubuntu/breezy/kdemultimedia/breezy

« back to all changes in this revision

Viewing changes to noatun/library/effects.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2005-03-24 04:48:58 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050324044858-8ff88o9jxej6ii3d
Tags: 4:3.4.0-0ubuntu3
Add kubuntu_02_hide_arts_menu_entries.diff to hide artsbuilder and artscontrol k-menu entries

Show diffs side-by-side

added added

removed removed

Lines of Context:
noatun/library/effects.cpp
 
1
#include "effects.h"
 
2
#include "engine.h"
 
3
#include <common.h>
 
4
#include <dynamicrequest.h>
 
5
#include <artsflow.h>
 
6
#include <app.h>
 
7
#include <player.h>
 
8
#include <soundserver.h>
 
9
#include <noatunarts.h>
 
10
#include <qlayout.h>
 
11
 
 
12
#include <config.h>
 
13
 
 
14
#define HAS_ARTSVERSION_H
 
15
 
 
16
#ifdef HAS_ARTSVERSION_H
 
17
#include <artsgui.h>
 
18
#include <kartswidget.h>
 
19
#endif
 
20
 
 
21
#define engine napp->player()->engine()
 
22
#define server (*(engine->server()))
 
23
#define stack (*engine->effectStack())
 
24
 
 
25
using namespace std;
 
26
using namespace Arts;
 
27
 
 
28
class EffectConfigWidget : public QWidget
 
29
{
 
30
public:
 
31
        EffectConfigWidget(Effect *e, QWidget *parent=0)
 
32
                : QWidget(parent), mEf(e)
 
33
        {}
 
34
 
 
35
        virtual ~EffectConfigWidget()
 
36
        {
 
37
                mEf->mConfig=0;
 
38
        }
 
39
 
 
40
private:
 
41
        Effect *mEf;
 
42
};
 
43
 
 
44
 
 
45
Effect::Effect(const char *name)
 
46
        : mId(0), mName(name), mConfig(0)
 
47
{
 
48
        mEffect=new StereoEffect;
 
49
        *mEffect=DynamicCast(server.createObject(std::string(name)));
 
50
        napp->effects()->mItems.append(this);
 
51
}
 
52
 
 
53
long Effect::id() const
 
54
{
 
55
        return mId;
 
56
}
 
57
 
 
58
StereoEffect *Effect::effect() const
 
59
{
 
60
        return mEffect;
 
61
}
 
62
 
 
63
Effect *Effect::after() const
 
64
{
 
65
        QPtrList<Effect> effects=napp->effects()->effects();
 
66
        QPtrListIterator<Effect> i(effects);
 
67
        for(; i.current(); ++i)
 
68
                if ((*i)->id()==mId)
 
69
                {
 
70
                        ++i;
 
71
                        if (*i)
 
72
                                return *i;
 
73
                }
 
74
 
 
75
        return 0;
 
76
}
 
77
 
 
78
Effect *Effect::before() const
 
79
{
 
80
        QPtrList<Effect> effects=napp->effects()->effects();
 
81
        QPtrListIterator<Effect> i(effects);
 
82
        for(; i.current(); ++i)
 
83
                if ((*i)->id()==mId)
 
84
                {
 
85
                        --i;
 
86
                        if (*i)
 
87
                                return *i;
 
88
                }
 
89
 
 
90
        return 0;
 
91
}
 
92
 
 
93
QCString Effect::name() const
 
94
{
 
95
        return mName;
 
96
}
 
97
 
 
98
QString Effect::title() const
 
99
{
 
100
        return clean(mName);
 
101
}
 
102
 
 
103
QString Effect::clean(const QCString &name)
 
104
{
 
105
        int pos=name.findRev("::");
 
106
        if (pos>0)
 
107
                return name.right(name.length()-pos-2);
 
108
        return name;
 
109
}
 
110
 
 
111
bool Effect::isNull() const
 
112
{
 
113
        return effect()->isNull();
 
114
}
 
115
 
 
116
QWidget *Effect::configure(bool /*friendly*/)
 
117
{
 
118
#ifdef HAS_ARTSVERSION_H
 
119
        if (mConfig) return mConfig;
 
120
        if (!configurable()) return 0;
 
121
 
 
122
        GenericGuiFactory factory;
 
123
        Widget gui = factory.createGui(*mEffect);
 
124
 
 
125
        if(!gui.isNull())
 
126
        {
 
127
                mConfig=new EffectConfigWidget(this);
 
128
                mConfig->setCaption(title());
 
129
 
 
130
                QBoxLayout *l=new QHBoxLayout(mConfig);
 
131
                l->add(new KArtsWidget(gui, mConfig));
 
132
                l->freeze();
 
133
        }
 
134
 
 
135
        return mConfig;
 
136
#else
 
137
        return 0;
 
138
#endif
 
139
}
 
140
 
 
141
bool Effect::configurable() const
 
142
{
 
143
#ifdef HAS_ARTSVERSION_H
 
144
        TraderQuery query;
 
145
        query.supports("Interface","Arts::GuiFactory");
 
146
        query.supports("CanCreate", mEffect->_interfaceName());
 
147
 
 
148
        vector<TraderOffer> *queryResults = query.query();
 
149
        bool yes= queryResults->size();
 
150
        delete queryResults;
 
151
 
 
152
        return yes;
 
153
#else
 
154
        return 0;
 
155
#endif
 
156
}
 
157
 
 
158
Effect::~Effect()
 
159
{
 
160
        delete mConfig;
 
161
        napp->effects()->remove(this, false);
 
162
        emit napp->effects()->deleting(this);
 
163
        delete mEffect;
 
164
        napp->effects()->mItems.removeRef(this);
 
165
}
 
166
 
 
167
 
 
168
Effects::Effects()
 
169
{
 
170
        mItems.setAutoDelete(false);
 
171
}
 
172
 
 
173
bool Effects::insert(const Effect *after, Effect *item)
 
174
{
 
175
        if (!item) return false;
 
176
        if (item->id()) return false;
 
177
        if (item->isNull()) return false;
 
178
        long i;
 
179
        item->effect()->start();
 
180
 
 
181
        if (!after)
 
182
                i=stack.insertTop(*item->effect(), (const char*)item->name());
 
183
        else
 
184
                i=stack.insertAfter(after->id(), *item->effect(), (const char*)item->name());
 
185
        if (!i)
 
186
        {
 
187
                item->effect()->stop();
 
188
                return false;
 
189
        }
 
190
 
 
191
        item->mId=i;
 
192
        emit added(item);
 
193
        return true;
 
194
}
 
195
 
 
196
bool Effects::append(Effect *item)
 
197
{
 
198
        if (!item) return false;
 
199
        if (item->id()) return false;
 
200
        if (item->isNull()) return false;
 
201
 
 
202
        item->effect()->start();
 
203
        item->mId=stack.insertBottom(*item->effect(), (const char*)item->name());
 
204
        if (!item->mId)
 
205
        {
 
206
                item->effect()->stop();
 
207
                return false;
 
208
        }
 
209
        emit added(item);
 
210
        return true;
 
211
}
 
212
 
 
213
void Effects::move(const Effect *after, Effect *item)
 
214
{
 
215
        if (!item) return;
 
216
        if (!item->id()) return;
 
217
        long id=after ? after->id() : 0;
 
218
        stack.move(id, item->id());
 
219
        emit moved(item);
 
220
}
 
221
 
 
222
void Effects::remove(Effect *item, bool del)
 
223
{
 
224
        if (!item) return;
 
225
        if (!item->id()) return;
 
226
 
 
227
        stack.remove(item->id());
 
228
        item->effect()->stop();
 
229
        item->mId=0;
 
230
        removed(item);
 
231
 
 
232
        if (del)
 
233
                delete item;
 
234
}
 
235
 
 
236
void Effects::removeAll(bool del)
 
237
{
 
238
        for (QPtrListIterator<Effect> i(mItems); i.current(); ++i)
 
239
                if ((*i)->id())
 
240
                        remove(*i, del);
 
241
}
 
242
 
 
243
QStrList Effects::available() const
 
244
{
 
245
        QStrList val;
 
246
        Arts::TraderQuery query;
 
247
        query.supports("Interface", "Arts::StereoEffect");
 
248
        query.supports("Interface", "Arts::SynthModule");
 
249
        vector<Arts::TraderOffer> *offers = query.query();
 
250
        for (vector<Arts::TraderOffer>::iterator i=offers->begin(); i!=offers->end(); i++)
 
251
        {
 
252
                Arts::TraderOffer &offer=*i;
 
253
                QCString name = offer.interfaceName().c_str();
 
254
                val.append(name);
 
255
        }
 
256
        delete offers;
 
257
        return val;
 
258
}
 
259
 
 
260
Effect *Effects::findId(long id) const
 
261
{
 
262
        for (QPtrListIterator<Effect> i(mItems); i.current(); ++i)
 
263
                if ((*i)->id()==id)
 
264
                        return *i;
 
265
        return 0;
 
266
}
 
267
 
 
268
QPtrList<Effect> Effects::effects() const
 
269
{
 
270
        vector<long> *items=stack.effectList();
 
271
        QPtrList<Effect> effects;
 
272
        for (vector<long>::iterator i=items->begin();i!=items->end();i++)
 
273
                if (Effect *e=findId(*i))
 
274
                        effects.append(e);
 
275
 
 
276
        delete items;
 
277
        return effects;
 
278
}
 
279
 
 
280
#undef server
 
281
#undef stack
 
282
#undef engine
 
283
 
 
284
#include "effects.moc"