?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Other fix compile error
[kdeartwork.git] / kscreensaver / xsavers / swarm.cpp
blob263a610f9485a3522d2616c72d9d1f6b3944b50c
1 /*-
2 * swarm.c - swarm of bees for xlock, the X Window System lockscreen.
3 *
4 * Copyright (c) 1991 by Patrick J. Naughton.
5 *
6 * Revision History:
7 * 31-Aug-90: Adapted from xswarm by Jeff Butterworth. (butterwo@ncsc.org)
8 */
9
10 /* Ported to kscreensaver:
11 July 1997, Emanuel Pirker <epirker@edu.uni-klu.ac.at>
12 Contact me in case of problems, not the original author!
13 Last revised: 10-Jul-97
14 */
15 // layout management added 1998/04/19 by Mario Weilguni <mweilguni@kde.org>
16
17 #define MAXSPEED 100
18 #define MINSPEED 0
19 #define DEFSPEED 50
20 #define MAXBATCH 200
21 #define MINBATCH 0
22 #define DEFBATCH 20
23
24 #include <qslider.h>
25 //Added by qt3to4:
26 #include <QVBoxLayout>
27 #include <QHBoxLayout>
28 #include <kglobal.h>
29 #include <kconfig.h>
30 #include <krandomsequence.h>
31 #include "xlock.h"
32
33 #undef index
34
35 #define TIMES 4 /* number of time positions recorded */
36 #define BEEACC 2 /* acceleration of bees */
37 #define WASPACC 5 /* maximum acceleration of wasp */
38 #define BEEVEL 12 /* maximum bee velocity */
39 #define WASPVEL 10 /* maximum wasp velocity */
40
41 /* Macros */
42 #define X(t,b) (sp->x[(t)*sp->beecount+(b)])
43 #define Y(t,b) (sp->y[(t)*sp->beecount+(b)])
44 #define balance_rand(v) (rnd.getLong(v)-((v)/2)) /* random number around 0 */
45
46 //ModeSpecOpt swarm_opts = {0, NULL, NULL, NULL};
47
48 typedef struct {
49 int pix;
50 int width;
51 int height;
52 int border; /* wasp won't go closer than this to the edge */
53 int beecount; /* number of bees */
54 XSegment segs[MAXBATCH]; /* bee lines */
55 XSegment old_segs[MAXBATCH]; /* old bee lines */
56 short x[MAXBATCH*TIMES];
57 short y[MAXBATCH*TIMES]; /* bee positions x[time][bee#] */
58 short xv[MAXBATCH];
59 short yv[MAXBATCH]; /* bee velocities xv[bee#] */
60 short wx[3];
61 short wy[3];
62 short wxv;
63 short wyv;
64 } swarmstruct;
65
66 static swarmstruct swarms[MAXSCREENS];
67
68 void
69 initswarm(Window win, KRandomSequence &rnd)
70 {
71 swarmstruct *sp = &swarms[screen];
72 int b;
73 XWindowAttributes xwa;
74
75 sp->beecount = batchcount;
76 (void) XGetWindowAttributes(dsp, win, &xwa);
77 sp->width = xwa.width;
78 sp->height = xwa.height;
79
80 sp->border = (sp->width + sp->height) / 50;
81
82 /* Clear the background. */
83 XSetForeground(dsp, Scr[screen].gc, BlackPixel(dsp, screen));
84 XFillRectangle(dsp, win, Scr[screen].gc, 0, 0, sp->width, sp->height);
85
86 /* Now static data structures. epirker */
87 //if (!sp->segs) {
88 //sp->segs = (XSegment *) malloc(sizeof (XSegment) * sp->beecount);
89 //sp->old_segs = (XSegment *) malloc(sizeof (XSegment) * sp->beecount);
90 //sp->x = (short *) malloc(sizeof (short) * sp->beecount * TIMES);
91 //sp->y = (short *) malloc(sizeof (short) * sp->beecount * TIMES);
92 //sp->xv = (short *) malloc(sizeof (short) * sp->beecount);
93 //sp->yv = (short *) malloc(sizeof (short) * sp->beecount);
94 //}
95 /* Initialize point positions, velocities, etc. */
96
97 /* wasp */
98 sp->wx[0] = sp->border + rnd.getLong(sp->width - 2 * sp->border);
99 sp->wy[0] = sp->border + rnd.getLong(sp->height - 2 * sp->border);
100 sp->wx[1] = sp->wx[0];
101 sp->wy[1] = sp->wy[0];
102 sp->wxv = 0;
103 sp->wyv = 0;
104
105 /* bees */
106 for (b = 0; b < sp->beecount; b++) {
107 X(0, b) = rnd.getLong(sp->width);
108 X(1, b) = X(0, b);
109 Y(0, b) = rnd.getLong(sp->height);
110 Y(1, b) = Y(0, b);
111 sp->xv[b] = balance_rand(7);
112 sp->yv[b] = balance_rand(7);
113 }
114 }
115
116
117
118 void
119 drawswarm(Window win, KRandomSequence &rnd)
120 {
121 swarmstruct *sp = &swarms[screen];
122 int b;
123
124 /* <=- Wasp -=> */
125 /* Age the arrays. */
126 sp->wx[2] = sp->wx[1];
127 sp->wx[1] = sp->wx[0];
128 sp->wy[2] = sp->wy[1];
129 sp->wy[1] = sp->wy[0];
130 /* Accelerate */
131 sp->wxv += balance_rand(WASPACC);
132 sp->wyv += balance_rand(WASPACC);
133
134 /* Speed Limit Checks */
135 if (sp->wxv > WASPVEL)
136 sp->wxv = WASPVEL;
137 if (sp->wxv < -WASPVEL)
138 sp->wxv = -WASPVEL;
139 if (sp->wyv > WASPVEL)
140 sp->wyv = WASPVEL;
141 if (sp->wyv < -WASPVEL)
142 sp->wyv = -WASPVEL;
143
144 /* Move */
145 sp->wx[0] = sp->wx[1] + sp->wxv;
146 sp->wy[0] = sp->wy[1] + sp->wyv;
147
148 /* Bounce Checks */
149 if ((sp->wx[0] < sp->border) || (sp->wx[0] > sp->width - sp->border - 1)) {
150 sp->wxv = -sp->wxv;
151 sp->wx[0] += sp->wxv;
152 }
153 if ((sp->wy[0] < sp->border) || (sp->wy[0] > sp->height - sp->border - 1)) {
154 sp->wyv = -sp->wyv;
155 sp->wy[0] += sp->wyv;
156 }
157 /* Don't let things settle down. */
158 sp->xv[rnd.getLong(sp->beecount)] += balance_rand(3);
159 sp->yv[rnd.getLong(sp->beecount)] += balance_rand(3);
160
161 /* <=- Bees -=> */
162 for (b = 0; b < sp->beecount; b++) {
163 int distance, dx, dy;
164
165 /* Age the arrays. */
166 X(2, b) = X(1, b);
167 X(1, b) = X(0, b);
168 Y(2, b) = Y(1, b);
169 Y(1, b) = Y(0, b);
170
171 /* Accelerate */
172 dx = sp->wx[1] - X(1, b);
173 dy = sp->wy[1] - Y(1, b);
174 distance = abs(dx) + abs(dy); /* approximation */
175 if (distance == 0)
176 distance = 1;
177 sp->xv[b] += (dx * BEEACC) / distance;
178 sp->yv[b] += (dy * BEEACC) / distance;
179
180 /* Speed Limit Checks */
181 if (sp->xv[b] > BEEVEL)
182 sp->xv[b] = BEEVEL;
183 if (sp->xv[b] < -BEEVEL)
184 sp->xv[b] = -BEEVEL;
185 if (sp->yv[b] > BEEVEL)
186 sp->yv[b] = BEEVEL;
187 if (sp->yv[b] < -BEEVEL)
188 sp->yv[b] = -BEEVEL;
189
190 /* Move */
191 X(0, b) = X(1, b) + sp->xv[b];
192 Y(0, b) = Y(1, b) + sp->yv[b];
193
194 /* Fill the segment lists. */
195 sp->segs[b].x1 = X(0, b);
196 sp->segs[b].y1 = Y(0, b);
197 sp->segs[b].x2 = X(1, b);
198 sp->segs[b].y2 = Y(1, b);
199 sp->old_segs[b].x1 = X(1, b);
200 sp->old_segs[b].y1 = Y(1, b);
201 sp->old_segs[b].x2 = X(2, b);
202 sp->old_segs[b].y2 = Y(2, b);
203 }
204
205 XSetForeground(dsp, Scr[screen].gc, BlackPixel(dsp, screen));
206 XDrawLine(dsp, win, Scr[screen].gc,
207 sp->wx[1], sp->wy[1], sp->wx[2], sp->wy[2]);
208 XDrawSegments(dsp, win, Scr[screen].gc, sp->old_segs, sp->beecount);
209
210 XSetForeground(dsp, Scr[screen].gc, WhitePixel(dsp, screen));
211 XDrawLine(dsp, win, Scr[screen].gc,
212 sp->wx[0], sp->wy[0], sp->wx[1], sp->wy[1]);
213 if (!mono && Scr[screen].npixels > 2) {
214 XSetForeground(dsp, Scr[screen].gc, Scr[screen].pixels[sp->pix]);
215 if (++sp->pix >= Scr[screen].npixels)
216 sp->pix = 0;
217 }
218 XDrawSegments(dsp, win, Scr[screen].gc, sp->segs, sp->beecount);
219 }
220
221 //-----------------------------------------------------------------------------
222
223 #include <qcheckbox.h>
224 #include <qlabel.h>
225 #include <qcolor.h>
226 #include <qlayout.h>
227 #include <QX11Info>
228 #include <klocale.h>
229 #include <kmessagebox.h>
230
231 #include "swarm.h"
232 #include "swarm.moc"
233 #include "helpers.h"
234
235 #undef Below
236
237 static kSwarmSaver *saver = NULL;
238
239 void startScreenSaver( Drawable d )
240 {
241 if ( saver )
242 return;
243 saver = new kSwarmSaver( d );
244 }
245
246 void stopScreenSaver()
247 {
248 if ( saver )
249 delete saver;
250 saver = NULL;
251 }
252
253 int setupScreenSaver()
254 {
255 kSwarmSetup dlg;
256
257 return dlg.exec();
258 }
259
260 //-----------------------------------------------------------------------------
261
262 kSwarmSaver::kSwarmSaver( Drawable drawable ) : kScreenSaver( drawable )
263 {
264 readSettings();
265
266 // Clear to background colour when exposed
267 XSetWindowBackground(QX11Info::display(), mDrawable,
268 BlackPixel(QX11Info::display(), QX11Info::appScreen()));
269
270 colorContext = QColor::enterAllocContext();
271
272 batchcount = maxLevels;
273
274 initXLock( mGc );
275 initswarm( mDrawable, rnd );
276
277 timer.start( speed );
278 connect( &timer, SIGNAL( timeout() ), SLOT( slotTimeout() ) );
279 }
280
281 kSwarmSaver::~kSwarmSaver()
282 {
283 timer.stop();
284 QColor::leaveAllocContext();
285 QColor::destroyAllocContext( colorContext );
286 }
287
288 void kSwarmSaver::setSpeed( int spd )
289 {
290 timer.stop();
291 speed = MAXSPEED - spd;
292 timer.start( speed );
293 }
294
295 void kSwarmSaver::setLevels( int l )
296 {
297 batchcount = maxLevels = l;
298 initswarm( mDrawable, rnd );
299 }
300
301 void kSwarmSaver::readSettings()
302 {
303 KConfig *config = klock_config();
304 config->setGroup( "Settings" );
305
306 speed = MAXSPEED - config->readNumEntry( "Speed", MAXSPEED - DEFSPEED );
307 maxLevels = config->readNumEntry( "MaxLevels", DEFBATCH );
308
309 delete config;
310 }
311
312 void kSwarmSaver::slotTimeout()
313 {
314 drawswarm( mDrawable, rnd );
315 }
316
317 //-----------------------------------------------------------------------------
318
319 kSwarmSetup::kSwarmSetup( QWidget *parent, const char *name )
320 : KDialogBase( parent, name, true, i18n( "Setup Swarm Screen Saver" ),
321 Ok|Cancel|Help, Ok, true )
322 {
323 readSettings();
324
325 setButtonText( Help, i18n( "A&bout" ) );
326 QWidget *main = makeMainWidget();
327
328 QHBoxLayout *top = new QHBoxLayout( main/*, 0, spacingHint()*/ );
329 QVBoxLayout *left = new QVBoxLayout(top/*, spacingHint()*/);
330
331 QLabel *label = new QLabel( i18n("Speed:"), main );
332 min_size(label);
333 left->addWidget(label);
334
335 QSlider *slider = new QSlider(MINSPEED, MAXSPEED, 10, speed,
336 Qt::Horizontal, main );
337 slider->setMinimumSize( 120, 20 );
338 slider->setTickPosition(QSlider::TicksBelow);
339 slider->setTickInterval(10);
340 connect( slider, SIGNAL( valueChanged( int ) ),
341 SLOT( slotSpeed( int ) ) );
342 left->addWidget(slider);
343
344 label = new QLabel( i18n("Number of bees:"), main );
345 min_size(label);
346 left->addWidget(label);
347
348 slider = new QSlider(MINBATCH, MAXBATCH, 20, maxLevels, Qt::Horizontal, main );
349 slider->setMinimumSize( 120, 20 );
350 slider->setTickPosition(QSlider::TicksBelow);
351 slider->setTickInterval(20);
352 connect( slider, SIGNAL( valueChanged( int ) ),
353 SLOT( slotLevels( int ) ) );
354 left->addWidget(slider);
355 left->addStretch();
356
357 preview = new QWidget( main );
358 preview->setFixedSize( 220, 170 );
359 preview->setBackgroundColor( Qt::black );
360 preview->show(); // otherwise saver does not get correct size
361 saver = new kSwarmSaver( preview->winId() );
362 top->addWidget(preview);
363
364 top->addStretch();
365 }
366
367 void kSwarmSetup::readSettings()
368 {
369 KConfig *config = klock_config();
370 config->setGroup( "Settings" );
371
372 speed = config->readNumEntry( "Speed", speed );
373
374 if ( speed > MAXSPEED )
375 speed = MAXSPEED;
376 else if ( speed < MINSPEED )
377 speed = MINSPEED;
378
379 maxLevels = config->readNumEntry( "MaxLevels", DEFBATCH );
380 delete config;
381 }
382
383 void kSwarmSetup::slotSpeed( int num )
384 {
385 speed = num;
386
387 if ( saver )
388 saver->setSpeed( speed );
389 }
390
391 void kSwarmSetup::slotLevels( int num )
392 {
393 maxLevels = num;
394
395 if ( saver )
396 saver->setLevels( maxLevels );
397 }
398
399 void kSwarmSetup::slotOk()
400 {
401 KConfig *config = klock_config();
402 config->setGroup( "Settings" );
403
404 QString sspeed;
405 sspeed.setNum( speed );
406 config->writeEntry( "Speed", sspeed );
407
408 QString slevels;
409 slevels.setNum( maxLevels );
410 config->writeEntry( "MaxLevels", slevels );
411
412 config->sync();
413 delete config;
414 accept();
415 }
416
417 void kSwarmSetup::slotHelp()
418 {
419 KMessageBox::information(this,
420 i18n("Swarm\n\nCopyright (c) 1991 by Patrick J. Naughton\n\nPorted to kscreensaver by Emanuel Pirker."),
421 i18n("About Swarm"));
422 }
kdeartwork experimental stuff