00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
#include <config.h>
00015
#include <unistd.h>
00016
#include <math.h>
00017
00018
#include <qstring.h>
00019
#include <qstringlist.h>
00020
#include <qbitmap.h>
00021
#include <qpixmap.h>
00022
#include <qimage.h>
00023
#include <qcolor.h>
00024
#include <qwidget.h>
00025
#include <qpainter.h>
00026
#include <qpen.h>
00027
00028
#include <kdebug.h>
00029
#include <kglobal.h>
00030
#include <kconfig.h>
00031
#include <kglobalsettings.h>
00032
#include <kicontheme.h>
00033
#include "kiconeffect.h"
00034
00035
#if defined(Q_WS_WIN) || defined(Q_WS_MACX)
00036
static bool qt_use_xrender=
true;
00037
static bool qt_has_xft=
true;
00038
#else
00039
extern bool qt_use_xrender;
00040
extern bool qt_has_xft;
00041
#endif
00042
class KIconEffectPrivate
00043 {
00044
public:
00045
QString mKey[6][3];
00046
QColor mColor2[6][3];
00047 };
00048
00049 KIconEffect::KIconEffect()
00050 {
00051 d =
new KIconEffectPrivate;
00052
init();
00053 }
00054
00055 KIconEffect::~KIconEffect()
00056 {
00057
delete d;
00058 d = 0L;
00059 }
00060
00061 void KIconEffect::init()
00062 {
00063
KConfig *config =
KGlobal::config();
00064
00065
int i, j, effect=-1;
00066
QStringList groups;
00067 groups +=
"Desktop";
00068 groups +=
"Toolbar";
00069 groups +=
"MainToolbar";
00070 groups +=
"Small";
00071 groups +=
"Panel";
00072
00073
QStringList states;
00074 states +=
"Default";
00075 states +=
"Active";
00076 states +=
"Disabled";
00077
00078 QStringList::ConstIterator it, it2;
00079
QString _togray(
"togray");
00080
QString _colorize(
"colorize");
00081
QString _desaturate(
"desaturate");
00082
QString _togamma(
"togamma");
00083
QString _none(
"none");
00084
QString _tomonochrome(
"tomonochrome");
00085
00086
KConfigGroupSaver cs(config,
"default");
00087
00088
for (it=groups.begin(), i=0; it!=groups.end(); it++, i++)
00089 {
00090
00091 mEffect[i][0] = NoEffect;
00092 mEffect[i][1] = ((i==0)||(i==4)) ? ToGamma : NoEffect;
00093 mEffect[i][2] = ToGray;
00094
00095 mTrans[i][0] =
false;
00096 mTrans[i][1] =
false;
00097 mTrans[i][2] =
true;
00098 mValue[i][0] = 1.0;
00099 mValue[i][1] = ((i==0)||(i==4)) ? 0.7 : 1.0;
00100 mValue[i][2] = 1.0;
00101 mColor[i][0] =
QColor(144,128,248);
00102 mColor[i][1] = QColor(169,156,255);
00103 mColor[i][2] = QColor(34,202,0);
00104 d->mColor2[i][0] = QColor(0,0,0);
00105 d->mColor2[i][1] = QColor(0,0,0);
00106 d->mColor2[i][2] = QColor(0,0,0);
00107
00108 config->
setGroup(*it +
"Icons");
00109
for (it2=states.begin(), j=0; it2!=states.end(); it2++, j++)
00110 {
00111
QString tmp = config->
readEntry(*it2 +
"Effect");
00112
if (tmp == _togray)
00113 effect = ToGray;
00114
else if (tmp == _colorize)
00115 effect = Colorize;
00116
else if (tmp == _desaturate)
00117 effect = DeSaturate;
00118
else if (tmp == _togamma)
00119 effect = ToGamma;
00120
else if (tmp == _tomonochrome)
00121 effect =
ToMonochrome;
00122
else if (tmp == _none)
00123 effect = NoEffect;
00124
else
00125
continue;
00126
if(effect != -1)
00127 mEffect[i][j] = effect;
00128 mValue[i][j] = config->
readDoubleNumEntry(*it2 +
"Value");
00129 mColor[i][j] = config->
readColorEntry(*it2 +
"Color");
00130 d->mColor2[i][j] = config->
readColorEntry(*it2 +
"Color2");
00131 mTrans[i][j] = config->
readBoolEntry(*it2 +
"SemiTransparent");
00132
00133 }
00134 }
00135 }
00136
00137 bool KIconEffect::hasEffect(
int group,
int state)
const
00138
{
00139
return mEffect[group][state] != NoEffect;
00140 }
00141
00142 QString KIconEffect::fingerprint(
int group,
int state)
const
00143
{
00144
if ( group >= KIcon::LastGroup )
return "";
00145
QString cached = d->mKey[group][state];
00146
if (cached.isEmpty())
00147 {
00148
QString tmp;
00149 cached = tmp.setNum(mEffect[group][state]);
00150 cached +=
':';
00151 cached += tmp.setNum(mValue[group][state]);
00152 cached +=
':';
00153 cached += mTrans[group][state] ? QString::fromLatin1(
"trans")
00154 : QString::fromLatin1(
"notrans");
00155
if (mEffect[group][state] == Colorize || mEffect[group][state] ==
ToMonochrome)
00156 {
00157 cached +=
':';
00158 cached += mColor[group][state].name();
00159 }
00160
if (mEffect[group][state] ==
ToMonochrome)
00161 {
00162 cached +=
':';
00163 cached += d->mColor2[group][state].name();
00164 }
00165
00166 d->mKey[group][state] = cached;
00167 }
00168
00169
return cached;
00170 }
00171
00172 QImage KIconEffect::apply(
QImage image,
int group,
int state)
const
00173
{
00174
if (state >= KIcon::LastState)
00175 {
00176 kdDebug(265) <<
"Illegal icon state: " << state <<
"\n";
00177
return image;
00178 }
00179
if (group >= KIcon::LastGroup)
00180 {
00181 kdDebug(265) <<
"Illegal icon group: " << group <<
"\n";
00182
return image;
00183 }
00184
return apply(image, mEffect[group][state], mValue[group][state],
00185 mColor[group][state], d->mColor2[group][state], mTrans[group][state]);
00186 }
00187
00188 QImage KIconEffect::apply(
QImage image,
int effect,
float value,
const QColor col,
bool trans)
const
00189
{
00190
return apply (image, effect, value, col, KGlobalSettings::baseColor(), trans);
00191 }
00192
00193 QImage KIconEffect::apply(
QImage image,
int effect,
float value,
const QColor col,
const QColor col2,
bool trans)
const
00194
{
00195
if (effect >= LastEffect )
00196 {
00197 kdDebug(265) <<
"Illegal icon effect: " << effect <<
"\n";
00198
return image;
00199 }
00200
if (value > 1.0)
00201 value = 1.0;
00202
else if (value < 0.0)
00203 value = 0.0;
00204
switch (effect)
00205 {
00206
case ToGray:
00207
toGray(image, value);
00208
break;
00209
case DeSaturate:
00210
deSaturate(image, value);
00211
break;
00212
case Colorize:
00213
colorize(image, col, value);
00214
break;
00215
case ToGamma:
00216
toGamma(image, value);
00217
break;
00218
case ToMonochrome:
00219
toMonochrome(image, col, col2, value);
00220
break;
00221 }
00222
if (trans ==
true)
00223 {
00224
semiTransparent(image);
00225 }
00226
return image;
00227 }
00228
00229 QPixmap KIconEffect::apply(
QPixmap pixmap,
int group,
int state)
const
00230
{
00231
if (state >= KIcon::LastState)
00232 {
00233 kdDebug(265) <<
"Illegal icon state: " << state <<
"\n";
00234
return pixmap;
00235 }
00236
if (group >= KIcon::LastGroup)
00237 {
00238 kdDebug(265) <<
"Illegal icon group: " << group <<
"\n";
00239
return pixmap;
00240 }
00241
return apply(pixmap, mEffect[group][state], mValue[group][state],
00242 mColor[group][state], d->mColor2[group][state], mTrans[group][state]);
00243 }
00244
00245 QPixmap KIconEffect::apply(
QPixmap pixmap,
int effect,
float value,
00246
const QColor col,
bool trans)
const
00247
{
00248
return apply (pixmap, effect, value, col, KGlobalSettings::baseColor(), trans);
00249 }
00250
00251 QPixmap KIconEffect::apply(
QPixmap pixmap,
int effect,
float value,
00252
const QColor col,
const QColor col2,
bool trans)
const
00253
{
00254
QPixmap result;
00255
00256
if (effect >= LastEffect )
00257 {
00258 kdDebug(265) <<
"Illegal icon effect: " << effect <<
"\n";
00259
return result;
00260 }
00261
00262
if ((trans ==
true) && (effect == NoEffect))
00263 {
00264 result = pixmap;
00265
semiTransparent(result);
00266 }
00267
else if ( effect != NoEffect )
00268 {
00269
QImage tmpImg = pixmap.convertToImage();
00270 tmpImg =
apply(tmpImg, effect, value, col, col2, trans);
00271 result.convertFromImage(tmpImg);
00272 }
00273
else
00274 result = pixmap;
00275
00276
return result;
00277 }
00278
00279
00280
00281
00282 void KIconEffect::toGray(
QImage &img,
float value)
00283 {
00284
int pixels = (img.depth() > 8) ? img.width()*img.height()
00285 : img.numColors();
00286
unsigned int *data = img.depth() > 8 ? (
unsigned int *) img.bits()
00287 : (
unsigned int *) img.colorTable();
00288
int rval, gval, bval, val, alpha, i;
00289
for (i=0; i<pixels; i++)
00290 {
00291 val = qGray(data[i]);
00292 alpha = qAlpha(data[i]);
00293
if (value < 1.0)
00294 {
00295 rval = static_cast<int>(value*val+(1.0-value)*qRed(data[i]));
00296 gval = static_cast<int>(value*val+(1.0-value)*qGreen(data[i]));
00297 bval = static_cast<int>(value*val+(1.0-value)*qBlue(data[i]));
00298 data[i] = qRgba(rval, gval, bval, alpha);
00299 }
else
00300 data[i] = qRgba(val, val, val, alpha);
00301 }
00302 }
00303
00304 void KIconEffect::colorize(
QImage &img,
const QColor &col,
float value)
00305 {
00306
int pixels = (img.depth() > 8) ? img.width()*img.height()
00307 : img.numColors();
00308
unsigned int *data = img.depth() > 8 ? (
unsigned int *) img.bits()
00309 : (
unsigned int *) img.colorTable();
00310
int rval, gval, bval, val, alpha, i;
00311
float rcol = col.red(), gcol = col.green(), bcol = col.blue();
00312
for (i=0; i<pixels; i++)
00313 {
00314 val = qGray(data[i]);
00315
if (val < 128)
00316 {
00317 rval = static_cast<int>(rcol/128*val);
00318 gval = static_cast<int>(gcol/128*val);
00319 bval = static_cast<int>(bcol/128*val);
00320 }
00321
else if (val > 128)
00322 {
00323 rval = static_cast<int>((val-128)*(2-rcol/128)+rcol-1);
00324 gval = static_cast<int>((val-128)*(2-gcol/128)+gcol-1);
00325 bval = static_cast<int>((val-128)*(2-bcol/128)+bcol-1);
00326 }
00327
else
00328 {
00329 rval = static_cast<int>(rcol);
00330 gval = static_cast<int>(gcol);
00331 bval = static_cast<int>(bcol);
00332 }
00333
if (value < 1.0)
00334 {
00335 rval = static_cast<int>(value*rval+(1.0 - value)*qRed(data[i]));
00336 gval = static_cast<int>(value*gval+(1.0 - value)*qGreen(data[i]));
00337 bval = static_cast<int>(value*bval+(1.0 - value)*qBlue(data[i]));
00338 }
00339
00340 alpha = qAlpha(data[i]);
00341 data[i] = qRgba(rval, gval, bval, alpha);
00342 }
00343 }
00344
00345 void KIconEffect::toMonochrome(
QImage &img,
const QColor &black,
const QColor &white,
float value) {
00346
int pixels = (img.depth() > 8) ? img.width()*img.height() : img.numColors();
00347
unsigned int *data = img.depth() > 8 ? (
unsigned int *) img.bits()
00348 : (
unsigned int *) img.colorTable();
00349
int rval, gval, bval, alpha, i;
00350
int rw = white.red(), gw = white.green(), bw = white.blue();
00351
int rb = black.red(), gb = black.green(), bb = black.blue();
00352
00353
double values = 0, sum = 0;
00354
bool grayscale =
true;
00355
00356
for (i=0; i<pixels; i++) {
00357 sum += qGray(data[i])*qAlpha(data[i]) + 255*(255-qAlpha(data[i]));
00358 values += 255;
00359
if ((qRed(data[i]) != qGreen(data[i]) ) || (qGreen(data[i]) != qBlue(data[i]) ))
00360 grayscale =
false;
00361 }
00362
double medium = sum/values;
00363
00364
00365
if (grayscale) {
00366
for (i=0; i<pixels; i++) {
00367
int v = qRed(data[i]);
00368 rval = static_cast<int>( ((255-v)*rb + v*rw)*value/255 + (1.0-value)*qRed(data[i]));
00369 gval = static_cast<int>( ((255-v)*gb + v*gw)*value/255 + (1.0-value)*qGreen(data[i]));
00370 bval = static_cast<int>( ((255-v)*bb + v*bw)*value/255 + (1.0-value)*qBlue(data[i]));
00371
00372 alpha = qAlpha(data[i]);
00373 data[i] = qRgba(rval, gval, bval, alpha);
00374 }
00375 }
00376
else {
00377
for (i=0; i<pixels; i++) {
00378
if (qGray(data[i]) <= medium) {
00379 rval = static_cast<int>(value*rb+(1.0-value)*qRed(data[i]));
00380 gval = static_cast<int>(value*gb+(1.0-value)*qGreen(data[i]));
00381 bval = static_cast<int>(value*bb+(1.0-value)*qBlue(data[i]));
00382 }
00383
else {
00384 rval = static_cast<int>(value*rw+(1.0-value)*qRed(data[i]));
00385 gval = static_cast<int>(value*gw+(1.0-value)*qGreen(data[i]));
00386 bval = static_cast<int>(value*bw+(1.0-value)*qBlue(data[i]));
00387 }
00388
00389 alpha = qAlpha(data[i]);
00390 data[i] = qRgba(rval, gval, bval, alpha);
00391 }
00392 }
00393 }
00394
00395 void KIconEffect::deSaturate(
QImage &img,
float value)
00396 {
00397
int pixels = (img.depth() > 8) ? img.width()*img.height()
00398 : img.numColors();
00399
unsigned int *data = (img.depth() > 8) ? (
unsigned int *) img.bits()
00400 : (
unsigned int *) img.colorTable();
00401
QColor color;
00402
int h, s, v, i;
00403
for (i=0; i<pixels; i++)
00404 {
00405 color.setRgb(data[i]);
00406 color.hsv(&h, &s, &v);
00407 color.setHsv(h, (
int) (s * (1.0 - value) + 0.5), v);
00408 data[i] = qRgba(color.red(), color.green(), color.blue(),
00409 qAlpha(data[i]));
00410 }
00411 }
00412
00413 void KIconEffect::toGamma(
QImage &img,
float value)
00414 {
00415
int pixels = (img.depth() > 8) ? img.width()*img.height()
00416 : img.numColors();
00417
unsigned int *data = (img.depth() > 8) ? (
unsigned int *) img.bits()
00418 : (
unsigned int *) img.colorTable();
00419
QColor color;
00420
int i, rval, gval, bval;
00421
float gamma;
00422 gamma = 1/(2*value+0.5);
00423
00424
for (i=0; i<pixels; i++)
00425 {
00426 color.setRgb(data[i]);
00427 color.rgb(&rval, &gval, &bval);
00428 rval = static_cast<int>(pow(static_cast<float>(rval)/255 , gamma)*255);
00429 gval = static_cast<int>(pow(static_cast<float>(gval)/255 , gamma)*255);
00430 bval = static_cast<int>(pow(static_cast<float>(bval)/255 , gamma)*255);
00431 data[i] = qRgba(rval, gval, bval, qAlpha(data[i]));
00432 }
00433 }
00434
00435 void KIconEffect::semiTransparent(
QImage &img)
00436 {
00437 img.setAlphaBuffer(
true);
00438
00439
int x, y;
00440
if (img.depth() == 32)
00441 {
00442
int width = img.width();
00443
int height = img.height();
00444
00445
if (qt_use_xrender && qt_has_xft )
00446
for (y=0; y<height; y++)
00447 {
00448
#ifdef WORDS_BIGENDIAN
00449
uchar *line = (uchar*) img.scanLine(y);
00450
#else
00451
uchar *line = (uchar*) img.scanLine(y) + 3;
00452
#endif
00453
for (x=0; x<width; x++)
00454 {
00455 *line >>= 1;
00456 line += 4;
00457 }
00458 }
00459
else
00460
for (y=0; y<height; y++)
00461 {
00462 QRgb *line = (QRgb *) img.scanLine(y);
00463
for (x=(y%2); x<width; x+=2)
00464 line[x] &= 0x00ffffff;
00465 }
00466
00467 }
else
00468 {
00469
00470
int transColor = -1;
00471
00472
00473
for (x=0; x<img.numColors(); x++)
00474 {
00475
00476
if (qAlpha(img.color(x)) < 127)
00477 {
00478 transColor = x;
00479
break;
00480 }
00481 }
00482
00483
00484
00485
if(transColor < 0 || transColor >= img.numColors())
00486
return;
00487
00488 img.setColor(transColor, 0);
00489
if(img.depth() == 8)
00490 {
00491
for (y=0; y<img.height(); y++)
00492 {
00493
unsigned char *line = img.scanLine(y);
00494
for (x=(y%2); x<img.width(); x+=2)
00495 line[x] = transColor;
00496 }
00497 }
00498
else
00499 {
00500
00501
00502
for (y=0; y<img.height(); y++)
00503
for (x=(y%2); x<img.width(); x+=2)
00504 img.setPixel(x, y, transColor);
00505 }
00506 }
00507 }
00508
00509 void KIconEffect::semiTransparent(
QPixmap &pix)
00510 {
00511
if ( qt_use_xrender && qt_has_xft )
00512 {
00513
QImage img=pix.convertToImage();
00514
semiTransparent(img);
00515 pix.convertFromImage(img);
00516
return;
00517 }
00518
00519
QImage img;
00520
if (pix.mask() != 0L)
00521 img = pix.mask()->convertToImage();
00522
else
00523 {
00524 img.create(pix.size(), 1, 2, QImage::BigEndian);
00525 img.fill(1);
00526 }
00527
00528
for (
int y=0; y<img.height(); y++)
00529 {
00530 QRgb *line = (QRgb *) img.scanLine(y);
00531 QRgb pattern = (y % 2) ? 0x55555555 : 0xaaaaaaaa;
00532
for (
int x=0; x<(img.width()+31)/32; x++)
00533 line[x] &= pattern;
00534 }
00535
QBitmap mask;
00536 mask.convertFromImage(img);
00537 pix.setMask(mask);
00538 }
00539
00540 QImage KIconEffect::doublePixels(
QImage src)
const
00541
{
00542
QImage dst;
00543
if (src.depth() == 1)
00544 {
00545 kdDebug(265) <<
"image depth 1 not supported\n";
00546
return dst;
00547 }
00548
00549
int w = src.width();
00550
int h = src.height();
00551 dst.create(w*2, h*2, src.depth());
00552 dst.setAlphaBuffer(src.hasAlphaBuffer());
00553
00554
int x, y;
00555
if (src.depth() == 32)
00556 {
00557 QRgb *l1, *l2;
00558
for (y=0; y<h; y++)
00559 {
00560 l1 = (QRgb *) src.scanLine(y);
00561 l2 = (QRgb *) dst.scanLine(y*2);
00562
for (x=0; x<w; x++)
00563 {
00564 l2[x*2] = l2[x*2+1] = l1[x];
00565 }
00566 memcpy(dst.scanLine(y*2+1), l2, dst.bytesPerLine());
00567 }
00568 }
else
00569 {
00570
for (x=0; x<src.numColors(); x++)
00571 dst.setColor(x, src.color(x));
00572
00573
unsigned char *l1, *l2;
00574
for (y=0; y<h; y++)
00575 {
00576 l1 = src.scanLine(y);
00577 l2 = dst.scanLine(y*2);
00578
for (x=0; x<w; x++)
00579 {
00580 l2[x*2] = l1[x];
00581 l2[x*2+1] = l1[x];
00582 }
00583 memcpy(dst.scanLine(y*2+1), l2, dst.bytesPerLine());
00584 }
00585 }
00586
return dst;
00587 }
00588
00589 void KIconEffect::overlay(
QImage &src,
QImage &overlay)
00590 {
00591
if (src.depth() != overlay.depth())
00592 {
00593 kdDebug(265) <<
"Image depth src != overlay!\n";
00594
return;
00595 }
00596
if (src.size() != overlay.size())
00597 {
00598 kdDebug(265) <<
"Image size src != overlay\n";
00599
return;
00600 }
00601
if (!overlay.hasAlphaBuffer())
00602 {
00603 kdDebug(265) <<
"Overlay doesn't have alpha buffer!\n";
00604
return;
00605 }
00606
00607
int i, j;
00608
00609
00610
00611
if (src.depth() == 1)
00612 {
00613 kdDebug(265) <<
"1bpp not supported!\n";
00614
return;
00615 }
00616
00617
00618
00619
if (src.depth() == 8)
00620 {
00621
if (src.numColors() + overlay.numColors() > 255)
00622 {
00623 kdDebug(265) <<
"Too many colors in src + overlay!\n";
00624
return;
00625 }
00626
00627
00628
int trans;
00629
for (trans=0; trans<overlay.numColors(); trans++)
00630 {
00631
if (qAlpha(overlay.color(trans)) == 0)
00632 {
00633 kdDebug(265) <<
"transparent pixel found at " << trans <<
"\n";
00634
break;
00635 }
00636 }
00637
if (trans == overlay.numColors())
00638 {
00639 kdDebug(265) <<
"transparent pixel not found!\n";
00640
return;
00641 }
00642
00643
00644
int nc = src.numColors();
00645 src.setNumColors(nc + overlay.numColors());
00646
for (i=0; i<overlay.numColors(); i++)
00647 {
00648 src.setColor(nc+i, overlay.color(i));
00649 }
00650
00651
00652
unsigned char *oline, *sline;
00653
for (i=0; i<src.height(); i++)
00654 {
00655 oline = overlay.scanLine(i);
00656 sline = src.scanLine(i);
00657
for (j=0; j<src.width(); j++)
00658 {
00659
if (oline[j] != trans)
00660 sline[j] = oline[j]+nc;
00661 }
00662 }
00663 }
00664
00665
00666
00667
if (src.depth() == 32)
00668 {
00669 QRgb *oline, *sline;
00670
int r1, g1, b1, a1;
00671
int r2, g2, b2, a2;
00672
00673
for (i=0; i<src.height(); i++)
00674 {
00675 oline = (QRgb *) overlay.scanLine(i);
00676 sline = (QRgb *) src.scanLine(i);
00677
00678
for (j=0; j<src.width(); j++)
00679 {
00680 r1 = qRed(oline[j]);
00681 g1 = qGreen(oline[j]);
00682 b1 = qBlue(oline[j]);
00683 a1 = qAlpha(oline[j]);
00684
00685 r2 = qRed(sline[j]);
00686 g2 = qGreen(sline[j]);
00687 b2 = qBlue(sline[j]);
00688 a2 = qAlpha(sline[j]);
00689
00690 r2 = (a1 * r1 + (0xff - a1) * r2) >> 8;
00691 g2 = (a1 * g1 + (0xff - a1) * g2) >> 8;
00692 b2 = (a1 * b1 + (0xff - a1) * b2) >> 8;
00693 a2 = QMAX(a1, a2);
00694
00695 sline[j] = qRgba(r2, g2, b2, a2);
00696 }
00697 }
00698 }
00699
00700
return;
00701 }
00702
00703
void
00704 KIconEffect::visualActivate(
QWidget * widget,
QRect rect)
00705 {
00706
if (!
KGlobalSettings::visualActivate())
00707
return;
00708
00709 uint actSpeed =
KGlobalSettings::visualActivateSpeed();
00710
00711 uint actCount = QMIN(rect.width(), rect.height()) / 2;
00712
00713
00714
00715
if (actCount < 1)
00716 actCount = 1;
00717
00718
else if (actCount > 10)
00719 actCount = 10;
00720
00721
00722
00723
if (actSpeed < 1)
00724 actSpeed = 1;
00725
00726
else if (actSpeed > 100)
00727 actSpeed = 100;
00728
00729
00730
00731
00732
00733
00734
unsigned int actDelay = (1000 * (100 - actSpeed)) / actCount;
00735
00736
00737
00738
QPoint c = rect.center();
00739
00740
QPainter p(widget);
00741
00742
00743 p.setPen(
QPen(Qt::black, 2, Qt::DotLine));
00744 p.setRasterOp(Qt::NotROP);
00745
00746
00747
00748
00749
00750
00751
00752
unsigned int deltaX = rect.width() / actCount;
00753
unsigned int deltaY = rect.height() / actCount;
00754
00755
for (
unsigned int i = 1; i < actCount; i++) {
00756
00757
int w = i * deltaX;
00758
int h = i * deltaY;
00759
00760 rect.setRect(c.x() - w / 2, c.y() - h / 2, w, h);
00761
00762 p.drawRect(rect);
00763 p.flush();
00764
00765 usleep(actDelay);
00766
00767 p.drawRect(rect);
00768 }
00769 }
00770