← Back to branch summary

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

« back to all changes in this revision

Viewing changes to noatun/noatun/modules/winskin/waSkin.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/noatun/modules/winskin/waSkin.cpp
1
 
/*
2
 
  Winamp Skin
3
 
  Copyright (C) 1999  Martin Vogt
4
 
 
5
 
  This program is free software; you can redistribute it and/or modify
6
 
  it under the terms of the GNU General Public License as published by
7
 
  the Free Software Foundation.
8
 
 
9
 
  For more information look at the file COPYRIGHT in this package
10
 
 
11
 
 */
12
 
 
13
 
#include <kconfig.h>
14
 
#include <qstringlist.h>
15
 
#include <kglobal.h>
16
 
#include <kstddirs.h>
17
 
 
18
 
#include "waSkin.h"
19
 
 
20
 
 
21
 
WaSkin::WaSkin(QString loadDir,QWidget *parent, const char *name) 
22
 
  : GuiPlugin(parent,name) { 
23
 
 
24
 
  
25
 
  waSkinModell=new WaSkinModell();
26
 
 
27
 
  
28
 
  loadSkin(loadDir);
29
 
 
30
 
  createButtons();
31
 
  createHighLevelElements();
32
 
  sizeButtons();
33
 
  setMinimumSize(sizeHint());
34
 
  setMaximumSize(sizeHint());
35
 
}
36
 
 
37
 
 
38
 
WaSkin::~WaSkin() {
39
 
 
40
 
}
41
 
 
42
 
void WaSkin::loadSkin(QString newSkinDir) {
43
 
  if (skinDir != newSkinDir) {
44
 
    WaSkinOperation::loadSkinSet(newSkinDir,waSkinModell);
45
 
    skinDir=newSkinDir;
46
 
  }
47
 
 
48
 
}
49
 
 
50
 
 
51
 
void WaSkin::setSong(QString song) {
52
 
  waInfo->setSong(song);
53
 
}
54
 
 
55
 
 
56
 
 
57
 
 
58
 
int  WaSkin::getSkinId() {
59
 
  return __SKINID_WINAMP;
60
 
}
61
 
 
62
 
 
63
 
 
64
 
QSize WaSkin::sizeHint() const {
65
 
  WaSkinDesc* waSkinDesc=waSkinModell->getWaSkinDesc(_WA_SKIN_MAIN);
66
 
  int w=waSkinDesc->getWidth();
67
 
  int h=waSkinDesc->getHeight();
68
 
  return QSize(w,h);
69
 
}
70
 
 
71
 
 
72
 
void WaSkin::paintEvent (QPaintEvent* paintEvent) {
73
 
  QPixmap* pixmapCurrent=waSkinModell->get(_WA_SKIN_MAIN);
74
 
  QPainter paint;
75
 
  paint.begin( this );
76
 
  paint.drawPixmap ( 0, 0, *pixmapCurrent);
77
 
  paint.end();
78
 
}
79
 
 
80
 
 
81
 
void WaSkin::createButtons() {
82
 
  prev=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_PREV,this);
83
 
  play=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_PLAY,this);
84
 
  pause=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_PAUSE,this);
85
 
  stop=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_STOP,this);
86
 
  next=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_NEXT,this);
87
 
  eject=new WaButton(waSkinModell,_WA_MAPPING_CBUTTONS_EJECT,this);
88
 
  shuffle=new WaButton(waSkinModell,_WA_MAPPING_SHUFFLE,this);
89
 
  repeat=new WaButton(waSkinModell,_WA_MAPPING_REPEAT,this);
90
 
  playlist=new WaButton(waSkinModell,_WA_MAPPING_PLAYLIST,this);
91
 
  eq=new WaButton(waSkinModell,_WA_MAPPING_EQ,this);
92
 
 
93
 
        titleshade = new WaButton(waSkinModell, _WA_MAPPING_TITLE_SHADE, this);
94
 
        titleshade->setPixmapUp(SIGNAL(event_WA_SKIN_TITLE_SHADE_NORM()), _WA_SKIN_TITLE_SHADE_NORM);
95
 
        titleshade->setPixmapDown(SIGNAL(event_WA_SKIN_TITLE_SHADE_PRES()), _WA_SKIN_TITLE_SHADE_PRES);
96
 
        connect(titleshade,SIGNAL(pressed()),this,SIGNAL(shadeEvent()));
97
 
 
98
 
  shuffle->setToggleFlag(true);
99
 
  repeat->setToggleFlag(true);
100
 
  playlist->setToggleFlag(true);
101
 
  connect(shuffle,SIGNAL(setSelectedEvent(int)),
102
 
          this,SIGNAL(shuffleClickedEvent(int)));
103
 
 
104
 
  connect(repeat,SIGNAL(setSelectedEvent(int)),
105
 
          this,SIGNAL(repeatClickedEvent(int)));
106
 
 
107
 
  connect(playlist,SIGNAL(setSelectedEvent(int)),
108
 
          this,SIGNAL(playlistClickedEvent(int)));
109
 
 
110
 
  prev->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_PREV_NORM()),
111
 
                    _WA_SKIN_CBUTTONS_PREV_NORM);
112
 
  prev->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_PREV_PRES()),
113
 
                      _WA_SKIN_CBUTTONS_PREV_PRES);
114
 
  connect(prev,SIGNAL(pressed()),this,SIGNAL(playPrevEvent()));
115
 
 
116
 
  play->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_PLAY_NORM()),
117
 
                     _WA_SKIN_CBUTTONS_PLAY_NORM);
118
 
  play->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_PLAY_PRES()),
119
 
                     _WA_SKIN_CBUTTONS_PLAY_PRES);
120
 
  connect(play,SIGNAL(pressed()),this,SIGNAL(playCurrentEvent()));
121
 
 
122
 
 
123
 
  
124
 
  
125
 
  pause->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_PAUSE_NORM()),
126
 
                    _WA_SKIN_CBUTTONS_PAUSE_NORM);
127
 
  pause->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_PAUSE_PRES()),
128
 
                      _WA_SKIN_CBUTTONS_PAUSE_PRES);
129
 
  connect(pause,SIGNAL(pressed()),this,SIGNAL(playPauseEvent()));
130
 
 
131
 
 
132
 
 
133
 
  stop->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_STOP_NORM()),
134
 
                    _WA_SKIN_CBUTTONS_STOP_NORM);
135
 
  stop->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_STOP_PRES()),
136
 
                      _WA_SKIN_CBUTTONS_STOP_PRES);
137
 
  connect(stop,SIGNAL(pressed()),this,SIGNAL(playStopEvent()));
138
 
 
139
 
 
140
 
 
141
 
  next->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_NEXT_NORM()),
142
 
                    _WA_SKIN_CBUTTONS_NEXT_NORM);
143
 
  next->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_NEXT_PRES()),
144
 
                     _WA_SKIN_CBUTTONS_NEXT_PRES);
145
 
  connect(next,SIGNAL(pressed()),this,SIGNAL(playNextEvent()));
146
 
 
147
 
 
148
 
  eject->setPixmapUp(SIGNAL(event_WA_SKIN_CBUTTONS_EJECT_NORM()),
149
 
                    _WA_SKIN_CBUTTONS_EJECT_NORM);
150
 
  eject->setPixmapDown(SIGNAL(event_WA_SKIN_CBUTTONS_EJECT_PRESS()),
151
 
                      _WA_SKIN_CBUTTONS_EJECT_PRESS);
152
 
  connect(eject,SIGNAL(pressed()),this,SIGNAL(ejectEvent()));
153
 
 
154
 
 
155
 
 
156
 
  shuffle->setPixmapUp(SIGNAL(event_WA_SKIN_SHUFREP_SHUFFLE_NOT_SET_NORM()),
157
 
                       _WA_SKIN_SHUFREP_SHUFFLE_NOT_SET_NORM);
158
 
  shuffle->setPixmapDown(SIGNAL(event_WA_SKIN_SHUFREP_SHUFFLE_NOT_SET_PRES()),
159
 
                     _WA_SKIN_SHUFREP_SHUFFLE_NOT_SET_PRES);
160
 
  shuffle->setPixmapUpSelected(
161
 
           SIGNAL(event_WA_SKIN_SHUFREP_SHUFFLE_SET_NORM()),
162
 
           _WA_SKIN_SHUFREP_SHUFFLE_SET_NORM);
163
 
  shuffle->setPixmapDownSelected(
164
 
           SIGNAL(event_WA_SKIN_SHUFREP_SHUFFLE_SET_PRES()),
165
 
           _WA_SKIN_SHUFREP_SHUFFLE_SET_PRES);
166
 
  shuffle->setSelected(true);
167
 
 
168
 
  repeat->setPixmapUp(SIGNAL(event_WA_SKIN_SHUFREP_REPEAT_NOT_SET_NORM()),
169
 
                     _WA_SKIN_SHUFREP_REPEAT_NOT_SET_NORM);
170
 
  repeat->setPixmapDown(SIGNAL(event_WA_SKIN_SHUFREP_REPEAT_NOT_SET_PRES()),
171
 
                     _WA_SKIN_SHUFREP_REPEAT_NOT_SET_PRES );
172
 
  repeat->setPixmapUpSelected(
173
 
          SIGNAL(event_WA_SKIN_SHUFREP_REPEAT_SET_NORM()),
174
 
          _WA_SKIN_SHUFREP_REPEAT_SET_NORM);
175
 
  repeat->setPixmapDownSelected(
176
 
          SIGNAL(event_WA_SKIN_SHUFREP_REPEAT_SET_PRES()),
177
 
          _WA_SKIN_SHUFREP_REPEAT_SET_PRES );
178
 
 
179
 
 
180
 
  eq->setPixmapUp(SIGNAL(event_WA_SKIN_SHUFREP_EQ_NOT_SET_NORM()),
181
 
                  _WA_SKIN_SHUFREP_EQ_NOT_SET_NORM);
182
 
  eq->setPixmapDown(SIGNAL(event_WA_SKIN_SHUFREP_EQ_NOT_SET_PRES()),
183
 
                    _WA_SKIN_SHUFREP_EQ_NOT_SET_PRES );
184
 
 
185
 
  
186
 
 
187
 
  playlist->setPixmapUp(SIGNAL(event_WA_SKIN_SHUFREP_PLAYLIST_NOT_SET_NORM()),
188
 
                        _WA_SKIN_SHUFREP_PLAYLIST_NOT_SET_NORM);
189
 
 playlist->setPixmapDown(SIGNAL(event_WA_SKIN_SHUFREP_PLAYLIST_NOT_SET_PRES())
190
 
                         ,_WA_SKIN_SHUFREP_PLAYLIST_NOT_SET_PRES);
191
 
 
192
 
  playlist->setPixmapUpSelected(
193
 
            SIGNAL(event_WA_SKIN_SHUFREP_PLAYLIST_SET_NORM()),
194
 
            _WA_SKIN_SHUFREP_PLAYLIST_SET_NORM);
195
 
 playlist->setPixmapDownSelected(
196
 
            SIGNAL(event_WA_SKIN_SHUFREP_PLAYLIST_SET_PRES())
197
 
            ,_WA_SKIN_SHUFREP_PLAYLIST_SET_PRES);
198
 
 
199
 
}
200
 
 
201
 
 
202
 
 
203
 
void WaSkin::sizeButtons() {
204
 
  prev->setFixedSize(prev->sizeHint());
205
 
  play->setFixedSize(play->sizeHint());
206
 
  pause->setFixedSize(pause->sizeHint());
207
 
  stop->setFixedSize(stop->sizeHint());
208
 
  next->setFixedSize(next->sizeHint());
209
 
  eject->setFixedSize(eject->sizeHint());
210
 
  shuffle->setFixedSize(shuffle->sizeHint());
211
 
  repeat->setFixedSize(repeat->sizeHint());
212
 
  playlist->setFixedSize(playlist->sizeHint());
213
 
  eq->setFixedSize(eq->sizeHint());
214
 
  titleshade->setFixedSize(titleshade->sizeHint());
215
 
 
216
 
}
217
 
 
218
 
 
219
 
 
220
 
 
221
 
void WaSkin::createHighLevelElements() {
222
 
        KConfig *config = KGlobal::config();
223
 
        config->setGroup("Winskin");
224
 
        int refreshRate = config->readNumEntry("ScopeFPS", 2);
225
 
  WaSkinDesc* waSkinDesc;
226
 
        if (refreshRate == 0)
227
 
        {
228
 
                // Wants 10 FPS
229
 
                guiSpectrumAnalyser = new GuiSpectrumAnalyser(this, "WinSkin", 100);
230
 
        }
231
 
        if (refreshRate == 1)
232
 
        {
233
 
                // Wants 25 FPS
234
 
                guiSpectrumAnalyser = new GuiSpectrumAnalyser(this, "WinSkin", 40);
235
 
        }
236
 
        if (refreshRate == 2)
237
 
        {
238
 
                // Wants 40 FPS
239
 
                guiSpectrumAnalyser = new GuiSpectrumAnalyser(this,"WinSkin" ,25);
240
 
        }
241
 
        if (refreshRate == 3)
242
 
        {
243
 
                // Wants ~ 55 FPS
244
 
                guiSpectrumAnalyser = new GuiSpectrumAnalyser(this, "WinSkin", 18);
245
 
        }
246
 
        if (refreshRate == 4)
247
 
        {
248
 
                // Wants ~ 70 FPS
249
 
                guiSpectrumAnalyser = new GuiSpectrumAnalyser(this, "WinSkin", 14);
250
 
        }
251
 
 
252
 
  waSkinDesc=waSkinModell->getWaSkinMapDesc(_WA_MAPPING_ANALYSER);
253
 
  guiSpectrumAnalyser->setGeometry((*waSkinDesc->getGeometry()));
254
 
 
255
 
  waJumpSlider= new WaJumpSlider(waSkinModell,this);
256
 
  waJumpSlider->buildGui();
257
 
  waJumpSlider->setFixedSize(waJumpSlider->sizeHint());
258
 
 
259
 
 
260
 
  waVolumeSlider= new WaVolumeSlider(waSkinModell,this);
261
 
  waVolumeSlider->buildGui();
262
 
  waVolumeSlider->setFixedSize(waVolumeSlider->sizeHint());
263
 
  connect(waVolumeSlider,SIGNAL(volumeSetValue(int)),
264
 
          this,SIGNAL(volumeSetValue(int)));
265
 
 
266
 
  waBalanceSlider= new WaBalanceSlider(waSkinModell,this);
267
 
  waBalanceSlider->buildGui();
268
 
  waBalanceSlider->setFixedSize(waBalanceSlider->sizeHint());
269
 
  connect(waBalanceSlider,SIGNAL(balanceSetValue(int)),
270
 
          this,SIGNAL(balanceSetValue(int)));
271
 
 
272
 
 
273
 
  waDigit= new WaDigit(waSkinModell,this);
274
 
  waDigit->setFixedSize(waDigit->sizeHint());
275
 
 
276
 
 
277
 
  waBPS= new WaBPS(waSkinModell,this);
278
 
  waBPS->setFixedSize(waBPS->sizeHint());
279
 
 
280
 
  waFreq= new WaFreq(waSkinModell,this);
281
 
  waFreq->setFixedSize(waFreq->sizeHint());
282
 
 
283
 
  waInfo= new WaInfo(waSkinModell,this);
284
 
  waInfo->setFixedSize(waInfo->sizeHint());
285
 
 
286
 
  waStatus= new WaStatus(waSkinModell,this);
287
 
  waStatus->setFixedSize(waStatus->sizeHint());
288
 
 
289
 
  waStereo= new WaStereo(waSkinModell,this);
290
 
  waStereo->setFixedSize(waStereo->sizeHint());
291
 
 
292
 
  waMono= new WaMono(waSkinModell,this);
293
 
  waMono->setFixedSize(waMono->sizeHint());
294
 
 
295
 
  waTitleBar = new WaTitleBar(waSkinModell, this);
296
 
  waTitleBar->setFixedSize(waTitleBar->sizeHint());
297
 
 
298
 
  connect(waJumpSlider,SIGNAL(jump(int)),this,SIGNAL(jump(int)));
299
 
  connect(waJumpSlider,SIGNAL(jumpSliderPressed()),
300
 
          this,SIGNAL(jumpSliderPressed()));
301
 
  connect(waJumpSlider,SIGNAL(jumpSliderReleased()),
302
 
          this,SIGNAL(jumpSliderReleased()));
303
 
 
304
 
  // now a few connections to the modell
305
 
  connect(waSkinModell,SIGNAL(event_WA_SKIN_MAIN()),
306
 
          this,SLOT(pixmapChange()));
307
 
 
308
 
}
309
 
 
310
 
 
311
 
 
312
 
 
313
 
void WaSkin::pixmapChange() {
314
 
  repaint(false);
315
 
}
316
 
 
317
 
 
318
 
 
319
 
 
320
 
void WaSkin::setRepeat(int val) {
321
 
  repeat->setSelected(val);
322
 
}
323
 
 
324
 
 
325
 
void WaSkin::setShuffle(int val) {
326
 
  shuffle->setSelected(val);
327
 
}
328
 
 
329
 
 
330
 
void WaSkin::setPlaylist(int val) {
331
 
  playlist->setSelected(val);
332
 
}
333
 
 
334
 
  
335
 
void WaSkin::setBPS(int val) {
336
 
  waBPS->setBPS(val);
337
 
}
338
 
 
339
 
 
340
 
void WaSkin::setFreq(int val) {
341
 
  waFreq->setFreq(val);
342
 
}
343
 
 
344
 
void WaSkin::setJumpValue(int val) {
345
 
  waJumpSlider->setJumpValue(val);
346
 
}
347
 
 
348
 
void WaSkin::setJumpRange(int val) {
349
 
  waJumpSlider->setJumpRange(val);
350
 
}
351
 
 
352
 
void WaSkin::setVolumeValue(int val) {
353
 
  waVolumeSlider->setVolumeValue(val);
354
 
}
355
 
 
356
 
 
357
 
void WaSkin::setBalanceValue(int val) {
358
 
  waBalanceSlider->setBalanceValue(val);
359
 
}
360
 
 
361
 
 
362
 
void WaSkin::setStatus(int val) {
363
 
  waStatus->setStatus(val);
364
 
}
365
 
 
366
 
void WaSkin::setStereo(int val) {
367
 
  if (val == true) {
368
 
    waStereo->setStereo(true);
369
 
    waMono->setMono(false);
370
 
  } else {
371
 
    waStereo->setStereo(false);
372
 
    waMono->setMono(true);
373
 
  }
374
 
}
375
 
 
376
 
 
377
 
void WaSkin::setTime(QString timeString) {
378
 
  waDigit->setTime(timeString);
379
 
}
380
 
 
381
 
 
382
 
void WaSkin::setSpectrum(float floatArray[75]) {
383
 
  // What is this thing? - (Name redacted due to shame)
384
 
  // guiSpectrumAnalyser->setValues(floatArray);
385
 
}
386
 
#include "waSkin.moc"