Differential D15735 Diff 42832 effects/wobblywindows/wobblywindows.cpp

Changeset View

Standalone View

View Options

effects/wobblywindows/wobblywindows.cpp

Context not available.
57 bool closeEffectEnabled; 57​ bool closeEffectEnabled;
58}; 58​};
59 59​
60static const ParameterSet set_0 = { 60​static const ParameterSet pset[] = {
romanggUnsubmitted
Not Done

I don't think it particularly helps the code readability to merge all that. What would help more is adding comments what this stuff does.

romangg: I don't think it particularly helps the code readability to merge all that. What would help…
anthonyfieroniAuthorUnsubmitted
Not Done

So we have copies of all 4 arrays, that's optimization. Even we have 4 unused arrays, then one of copies and it's used

anthonyfieroni: So we have copies of all 4 arrays, that's optimization. Even we have 4 unused arrays, then one…
61 0.15, 61​ {
62 0.80, 62​ 0.15,
63 0.10, 63​ 0.80,
64 20.0, 64​ 0.10,
65 20.0, 65​ 20.0,
66 0.0, 66​ 20.0,
67 1000.0, 67​ 0.0,
68 0.5, 68​ 1000.0,
69 0.0, 69​ 0.5,
70 1000.0, 70​ 0.0,
71 0.5, 71​ 1000.0,
72 true, 72​ 0.5,
73 false, 73​ true,
74 false 74​ false,
75}; 75​ false
76 76​}, {
77static const ParameterSet set_1 = { 77​ 0.10,
78 0.10, 78​ 0.85,
79 0.85, 79​ 0.10,
80 0.10, 80​ 20.0,
81 20.0, 81​ 20.0,
82 20.0, 82​ 0.0,
83 0.0, 83​ 1000.0,
84 1000.0, 84​ 0.5,
85 0.5, 85​ 0.0,
86 0.0, 86​ 1000.0,
87 1000.0, 87​ 0.5,
88 0.5, 88​ true,
89 true, 89​ false,
90 false, 90​ false
91 false 91​}, {
92}; 92​ 0.06,
93 93​ 0.90,
94static const ParameterSet set_2 = { 94​ 0.10,
95 0.06, 95​ 20.0,
96 0.90, 96​ 20.0,
97 0.10, 97​ 0.0,
98 20.0, 98​ 1000.0,
99 20.0, 99​ 0.5,
100 0.0, 100​ 0.0,
101 1000.0, 101​ 1000.0,
102 0.5, 102​ 0.5,
103 0.0, 103​ true,
104 1000.0, 104​ false,
105 0.5, 105​ false
106 true, 106​}, {
107 false, 107​ 0.03,
108 false 108​ 0.92,
109}; 109​ 0.20,
110 110​ 20.0,
111static const ParameterSet set_3 = { 111​ 20.0,
112 0.03, 112​ 0.0,
113 0.92, 113​ 1000.0,
114 0.20, 114​ 0.5,
115 20.0, 115​ 0.0,
116 20.0, 116​ 1000.0,
117 0.0, 117​ 0.5,
118 1000.0, 118​ true,
119 0.5, 119​ false,
120 0.0, 120​ false
121 1000.0, 121​}, {
122 0.5, 122​ 0.01,
123 true, 123​ 0.97,
124 false, 124​ 0.25,
125 false 125​ 20.0,
126}; 126​ 20.0,
127 127​ 0.0,
128static const ParameterSet set_4 = { 128​ 1000.0,
129 0.01, 129​ 0.5,
130 0.97, 130​ 0.0,
131 0.25, 131​ 1000.0,
132 20.0, 132​ 0.5,
133 20.0, 133​ true,
134 0.0, 134​ false,
135 1000.0, 135​ false
136 0.5, 136​}
zzagUnsubmitted
Not Done

Please revert this change.

zzag: Please revert this change.
anthonyfieroniAuthorUnsubmitted
Not Done

Why that's optimization.

anthonyfieroni: Why that's optimization.
zzagUnsubmitted
Not Done

This should go in another patch.

zzag: This should go in another patch.
anthonyfieroniAuthorUnsubmitted
Not Done

I don't see why, it's pretty safe and does not need go in another one, after all we waste a time since doing some work.

anthonyfieroni: I don't see why, it's pretty safe and does not need go in another one, after all we waste a…
137 0.0, ​
138 1000.0, ​
139 0.5, ​
140 true, ​
141 false, ​
142 false ​
143}; 137​};
144 138​
145static const ParameterSet pset[5] = { set_0, set_1, set_2, set_3, set_4 }; ​
146 ​
147WobblyWindowsEffect::WobblyWindowsEffect() 139​WobblyWindowsEffect::WobblyWindowsEffect()
148{ 140​{
149 initConfig<WobblyWindowsConfig>(); 141​ initConfig<WobblyWindowsConfig>();
Context not available.
274 // We need to mark the screen windows as transformed. Otherwise the whole 266​ // We need to mark the screen windows as transformed. Otherwise the whole
275 // screen won't be repainted, resulting in artefacts. 267​ // screen won't be repainted, resulting in artefacts.
276 // Could we just set a subset of the screen to be repainted ? 268​ // Could we just set a subset of the screen to be repainted ?
277 if (windows.count() != 0) { 269​ m_updateRegion = QRegion();
zzagUnsubmitted
Not Done

We don't need this check. Please delete it.

(if windows.isEmpty() is equal to true, then prePaintScreen, prePaintWindow, etc won't be called)

zzag: We don't need this check. Please delete it. (if windows.isEmpty() is equal to true, then…
278 m_updateRegion = QRegion(); ​
279 } ​
280 ​
281 effects->prePaintScreen(data, time); 270​ effects->prePaintScreen(data, time);
282} 271​}
283const qreal maxTime = 10.0; 272​const qreal maxTime = 10.0;
zzagUnsubmitted
Not Done

Please revert this change.

zzag: Please revert this change.
284void WobblyWindowsEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) 273​void WobblyWindowsEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
285{ 274​{
286 if (windows.contains(w)) { 275​ auto it = windows.find(w);
276​ if (it != windows.end()) {
287 data.setTransformed(); 277​ data.setTransformed();
288 data.quads = data.quads.makeRegularGrid(m_xTesselation, m_yTesselation); 278​ data.quads = data.quads.makeRegularGrid(m_xTesselation, m_yTesselation);
289 bool stop = false; 279​ bool stop = false;
290 qreal updateTime = time; 280​ qreal updateTime = time;
281​ const QRectF rect = w->geometry();
282​ WindowWobblyInfos& wwi = it.value();
291 283​
292 while (!stop && (updateTime > maxTime)) { 284​ while (!stop && updateTime > 0) {
293#if defined VERBOSE_MODE 285​#if defined VERBOSE_MODE
294 qCDebug(KWINEFFECTS) << "loop time " << updateTime << " / " << time; 286​ qCDebug(KWINEFFECTS) << "loop time " << updateTime << " / " << time;
295#endif 287​#endif
296 stop = !updateWindowWobblyDatas(w, maxTime); 288​ stop = !updateWindowWobblyDatas(wwi, rect, maxTime);
297 updateTime -= maxTime; 289​ updateTime -= maxTime;
298 } 290​ }
299 if (!stop && updateTime > 0) { 291​ if (stop) {
300 updateWindowWobblyDatas(w, updateTime); 292​ if (wwi.status == Closing) {
293​ w->unrefWindow();
294​ }
295​ freeWobblyInfo(wwi);
296​ windows.erase(it);
301 } 297​ }
302 } 298​ }
303 299​
zzagUnsubmitted
Not Done

windows.erase(it);

zzag: windows.erase(it);
Context not available.
306 302​
307void WobblyWindowsEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) 303​void WobblyWindowsEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
308{ 304​{
309 if (!(mask & PAINT_SCREEN_TRANSFORMED) && windows.contains(w)) { 305​ QHash< const EffectWindow*, WindowWobblyInfos >::const_iterator it;
310 WindowWobblyInfos& wwi = windows[w]; 306​ if (!(mask & PAINT_SCREEN_TRANSFORMED) && (it = windows.find(w)) != windows.end()) {
zzagUnsubmitted
Not Done

Please use constFind/constEnd.

zzag: Please use constFind/constEnd.
307​ const WindowWobblyInfos& wwi = it.value();
311 int tx = w->geometry().x(); 308​ int tx = w->geometry().x();
312 int ty = w->geometry().y(); 309​ int ty = w->geometry().y();
zzagUnsubmitted
Not Done

Please use const_iterator.

zzag: Please use const_iterator.
313 double left = 0.0; 310​ double left = 0.0;
Context not available.
336 333​
337void WobblyWindowsEffect::postPaintScreen() 334​void WobblyWindowsEffect::postPaintScreen()
338{ 335​{
339 if (!windows.isEmpty()) { 336​ effects->addRepaint(m_updateRegion);
340 effects->addRepaint(m_updateRegion); ​
341 } ​
342 ​
343 // Call the next effect. 337​ // Call the next effect.
344 effects->postPaintScreen(); 338​ effects->postPaintScreen();
345} 339​}
Context not available.
357void WobblyWindowsEffect::slotWindowStepUserMovedResized(EffectWindow *w, const QRect &geometry) 351​void WobblyWindowsEffect::slotWindowStepUserMovedResized(EffectWindow *w, const QRect &geometry)
358{ 352​{
359 Q_UNUSED(geometry) 353​ Q_UNUSED(geometry)
360 if (windows.contains(w)) { 354​ auto it = windows.find(w);
361 WindowWobblyInfos& wwi = windows[w]; 355​ if (it != windows.end()) {
356​ WindowWobblyInfos& wwi = it.value();
362 QRect rect = w->geometry(); 357​ QRect rect = w->geometry();
363 if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true; 358​ if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true;
364 if (rect.x() != wwi.resize_original_rect.x()) wwi.can_wobble_left = true; 359​ if (rect.x() != wwi.resize_original_rect.x()) wwi.can_wobble_left = true;
Context not available.
369 364​
370void WobblyWindowsEffect::slotWindowFinishUserMovedResized(EffectWindow *w) 365​void WobblyWindowsEffect::slotWindowFinishUserMovedResized(EffectWindow *w)
371{ 366​{
372 if (windows.contains(w)) { 367​ auto it = windows.find(w);
373 WindowWobblyInfos& wwi = windows[w]; 368​ if (it != windows.end()) {
369​ WindowWobblyInfos& wwi = it.value();
374 wwi.status = Free; 370​ wwi.status = Free;
375 QRect rect = w->geometry(); 371​ QRect rect = w->geometry();
376 if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true; 372​ if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true;
Context not available.
391 stepMovedResized(w); 387​ stepMovedResized(w);
392 } 388​ }
393 389​
394 if (windows.contains(w)) { 390​ auto it = windows.find(w);
395 WindowWobblyInfos& wwi = windows[w]; 391​ if (it != windows.end()) {
392​ WindowWobblyInfos& wwi = it.value();
396 QRect rect = w->geometry(); 393​ QRect rect = w->geometry();
397 if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true; 394​ if (rect.y() != wwi.resize_original_rect.y()) wwi.can_wobble_top = true;
398 if (rect.x() != wwi.resize_original_rect.x()) wwi.can_wobble_left = true; 395​ if (rect.x() != wwi.resize_original_rect.x()) wwi.can_wobble_left = true;
Context not available.
403 400​
404void WobblyWindowsEffect::startMovedResized(EffectWindow* w) 401​void WobblyWindowsEffect::startMovedResized(EffectWindow* w)
405{ 402​{
406 if (!windows.contains(w)) { 403​ auto it = windows.find(w);
404​ if (it == windows.end()) {
407 WindowWobblyInfos new_wwi; 405​ WindowWobblyInfos new_wwi;
408 initWobblyInfo(new_wwi, w->geometry()); 406​ initWobblyInfo(new_wwi, w->geometry());
409 windows[w] = new_wwi; 407​ it = windows.insert(w, new_wwi);
410 } 408​ }
411 409​
412 WindowWobblyInfos& wwi = windows[w]; 410​ WindowWobblyInfos& wwi = it.value();
413 wwi.status = Moving; 411​ wwi.status = Moving;
414 const QRectF& rect = w->geometry(); 412​ const QRectF& rect = w->geometry();
415 413​
Context not available.
445void WobblyWindowsEffect::stepMovedResized(EffectWindow* w) 443​void WobblyWindowsEffect::stepMovedResized(EffectWindow* w)
446{ 444​{
447 QRect new_geometry = w->geometry(); 445​ QRect new_geometry = w->geometry();
448 if (!windows.contains(w)) { 446​ auto it = windows.find(w);
447​ if (it == windows.end()) {
449 WindowWobblyInfos new_wwi; 448​ WindowWobblyInfos new_wwi;
450 initWobblyInfo(new_wwi, new_geometry); 449​ initWobblyInfo(new_wwi, new_geometry);
451 windows[w] = new_wwi; 450​ it = windows.insert(w, new_wwi);
452 } 451​ }
453 452​
454 WindowWobblyInfos& wwi = windows[w]; 453​ WindowWobblyInfos& wwi = it.value();
455 wwi.status = Free; 454​ wwi.status = Free;
456 455​
457 QRect maximized_area = effects->clientArea(MaximizeArea, w); 456​ QRect maximized_area = effects->clientArea(MaximizeArea, w);
Context not available.
476void WobblyWindowsEffect::slotWindowAdded(EffectWindow* w) 475​void WobblyWindowsEffect::slotWindowAdded(EffectWindow* w)
477{ 476​{
478 if (m_openEffectEnabled && w->data(WindowAddedGrabRole).value<void*>() == nullptr) { 477​ if (m_openEffectEnabled && w->data(WindowAddedGrabRole).value<void*>() == nullptr) {
479 if (windows.contains(w)) { 478​ auto it = windows.find(w);
479​ if (it != windows.end()) {
480 // could this happen ?? 480​ // could this happen ??
481 WindowWobblyInfos& wwi = windows[w]; 481​ WindowWobblyInfos& wwi = it.value();
482 wobblyOpenInit(wwi); 482​ wobblyOpenInit(wwi);
483 } else { 483​ } else {
484 WindowWobblyInfos new_wwi; 484​ WindowWobblyInfos new_wwi;
485 initWobblyInfo(new_wwi, w->geometry()); 485​ initWobblyInfo(new_wwi, w->geometry());
486 wobblyOpenInit(new_wwi); 486​ wobblyOpenInit(new_wwi);
487 windows[w] = new_wwi; 487​ windows.insert(w, new_wwi);
488 } 488​ }
489 } 489​ }
490} 490​}
zzagUnsubmitted
Not Done

FWIW, we do not connect to windowShown, so this can never happen, at least right now.

zzag: FWIW, we do not connect to windowShown, so this can never happen, at least right now.
491 491​
492void WobblyWindowsEffect::slotWindowClosed(EffectWindow* w) 492​void WobblyWindowsEffect::slotWindowClosed(EffectWindow* w)
493{ 493​{
494 if (windows.contains(w)) { 494​ auto it = windows.find(w);
495 WindowWobblyInfos& wwi = windows[w]; 495​ if (it != windows.end()) {
496​ WindowWobblyInfos& wwi = it.value();
496 if (m_closeEffectEnabled) { 497​ if (m_closeEffectEnabled) {
497 wobblyCloseInit(wwi, w); 498​ wobblyCloseInit(wwi, w);
498 w->refWindow(); 499​ w->refWindow();
499 } else { 500​ } else {
500 freeWobblyInfo(wwi); 501​ freeWobblyInfo(wwi);
501 windows.remove(w); 502​ windows.erase(it);
502 if (windows.isEmpty()) 503​ w->unrefWindow();
zzagUnsubmitted
Not Done

That's not possible to have ref'ed window at this point.

zzag: That's not possible to have ref'ed window at this point.
503 effects->addRepaintFull(); ​
504 } 504​ }
505 } else if (m_closeEffectEnabled && w->data(WindowClosedGrabRole).value<void*>() == nullptr) { 505​ } else if (m_closeEffectEnabled && w->data(WindowClosedGrabRole).value<void*>() == nullptr) {
506 WindowWobblyInfos new_wwi; 506​ WindowWobblyInfos new_wwi;
507 initWobblyInfo(new_wwi, w->geometry()); 507​ initWobblyInfo(new_wwi, w->geometry());
508 wobblyCloseInit(new_wwi, w); 508​ wobblyCloseInit(new_wwi, w);
509 windows[w] = new_wwi; 509​ windows.insert(w, new_wwi);
510 w->refWindow(); 510​ w->refWindow();
511 } 511​ }
512} 512​}
Context not available.
547 wwi.status = Closing; 547​ wwi.status = Closing;
548} 548​}
549 549​
550void WobblyWindowsEffect::initWobblyInfo(WindowWobblyInfos& wwi, QRect geometry) const 550​void WobblyWindowsEffect::initWobblyInfo(WindowWobblyInfos& wwi, const QRectF& geometry) const
551{ 551​{
552 wwi.count = 4 * 4; 552​ wwi.count = 4 * 4;
553 wwi.width = 4; 553​ wwi.width = 4;
Context not available.
614 delete[] wwi.bezierSurface; 614​ delete[] wwi.bezierSurface;
615} 615​}
616 616​
617WobblyWindowsEffect::Pair WobblyWindowsEffect::computeBezierPoint(const WindowWobblyInfos& wwi, Pair point) const 617​WobblyWindowsEffect::Pair WobblyWindowsEffect::computeBezierPoint(const WindowWobblyInfos& wwi, const Pair& point) const
618{ 618​{
619 // compute the input value 619​ // compute the input value
620 Pair topleft = wwi.origin[0]; 620​ const Pair& topleft = wwi.origin[0];
621 Pair bottomright = wwi.origin[wwi.count-1]; 621​ const Pair& bottomright = wwi.origin[wwi.count-1];
622 622​
623// ASSERT1(point.x >= topleft.x); 623​// ASSERT1(point.x >= topleft.x);
624// ASSERT1(point.y >= topleft.y); 624​// ASSERT1(point.y >= topleft.y);
Context not available.
704 704​
705} // close the anonymous namespace 705​} // close the anonymous namespace
706 706​
707bool WobblyWindowsEffect::updateWindowWobblyDatas(EffectWindow* w, qreal time) 707​bool WobblyWindowsEffect::updateWindowWobblyDatas(WindowWobblyInfos& wwi, const QRectF& rect, qreal time)
708{ 708​{
709 QRectF rect = w->geometry(); ​
710 WindowWobblyInfos& wwi = windows[w]; ​
711 ​
712 if (wwi.status == Closing) { ​
713 rect = wwi.closeRect; ​
714 } ​
zzagUnsubmitted
Not Done

Can you please clarify why you deleted this one? Shouldn't we pass closeRect as rect in paintWindow, e.g.:

const QRectF rect = wwi.status == Closing ? wwi.closeRect : w->geometry();

?

zzag: Can you please clarify why you deleted this one? Shouldn't we pass closeRect as rect in…
anthonyfieroniAuthorUnsubmitted
Not Done

It does not make sense to me, why we want to use closeRect?

anthonyfieroni: It does not make sense to me, why we want to use closeRect?
715 ​
716 qreal x_length = rect.width() / (wwi.width - 1.0); 709​ qreal x_length = rect.width() / (wwi.width - 1.0);
717 qreal y_length = rect.height() / (wwi.height - 1.0); 710​ qreal y_length = rect.height() / (wwi.height - 1.0);
718 711​
Context not available.
753 // top-left 746​ // top-left
754 747​
755 if (wwi.constraint[0]) { 748​ if (wwi.constraint[0]) {
756 Pair window_pos = wwi.origin[0]; 749​ const Pair& window_pos = wwi.origin[0];
757 Pair current_pos = wwi.position[0]; 750​ const Pair& current_pos = wwi.position[0];
758 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 751​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
759 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 752​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
760 wwi.acceleration[0] = accel; 753​ wwi.acceleration[0] = accel;
761 } else { 754​ } else {
762 Pair& pos = wwi.position[0]; 755​ const Pair& pos = wwi.position[0];
763 neibourgs[0] = wwi.position[1]; 756​ neibourgs[0] = wwi.position[1];
764 neibourgs[1] = wwi.position[wwi.width]; 757​ neibourgs[1] = wwi.position[wwi.width];
765 758​
Context not available.
775 // top-right 768​ // top-right
776 769​
777 if (wwi.constraint[wwi.width-1]) { 770​ if (wwi.constraint[wwi.width-1]) {
778 Pair window_pos = wwi.origin[wwi.width-1]; 771​ const Pair& window_pos = wwi.origin[wwi.width-1];
779 Pair current_pos = wwi.position[wwi.width-1]; 772​ const Pair& current_pos = wwi.position[wwi.width-1];
780 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 773​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
781 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 774​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
782 wwi.acceleration[wwi.width-1] = accel; 775​ wwi.acceleration[wwi.width-1] = accel;
783 } else { 776​ } else {
784 Pair& pos = wwi.position[wwi.width-1]; 777​ const Pair& pos = wwi.position[wwi.width-1];
785 neibourgs[0] = wwi.position[wwi.width-2]; 778​ neibourgs[0] = wwi.position[wwi.width-2];
786 neibourgs[1] = wwi.position[2*wwi.width-1]; 779​ neibourgs[1] = wwi.position[2*wwi.width-1];
787 780​
Context not available.
797 // bottom-left 790​ // bottom-left
798 791​
799 if (wwi.constraint[wwi.width*(wwi.height-1)]) { 792​ if (wwi.constraint[wwi.width*(wwi.height-1)]) {
800 Pair window_pos = wwi.origin[wwi.width*(wwi.height-1)]; 793​ const Pair& window_pos = wwi.origin[wwi.width*(wwi.height-1)];
801 Pair current_pos = wwi.position[wwi.width*(wwi.height-1)]; 794​ const Pair& current_pos = wwi.position[wwi.width*(wwi.height-1)];
802 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 795​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
803 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 796​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
804 wwi.acceleration[wwi.width*(wwi.height-1)] = accel; 797​ wwi.acceleration[wwi.width*(wwi.height-1)] = accel;
805 } else { 798​ } else {
806 Pair& pos = wwi.position[wwi.width*(wwi.height-1)]; 799​ const Pair& pos = wwi.position[wwi.width*(wwi.height-1)];
807 neibourgs[0] = wwi.position[wwi.width*(wwi.height-1)+1]; 800​ neibourgs[0] = wwi.position[wwi.width*(wwi.height-1)+1];
808 neibourgs[1] = wwi.position[wwi.width*(wwi.height-2)]; 801​ neibourgs[1] = wwi.position[wwi.width*(wwi.height-2)];
809 802​
Context not available.
819 // bottom-right 812​ // bottom-right
820 813​
821 if (wwi.constraint[wwi.count-1]) { 814​ if (wwi.constraint[wwi.count-1]) {
822 Pair window_pos = wwi.origin[wwi.count-1]; 815​ const Pair& window_pos = wwi.origin[wwi.count-1];
823 Pair current_pos = wwi.position[wwi.count-1]; 816​ const Pair& current_pos = wwi.position[wwi.count-1];
824 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 817​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
825 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 818​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
826 wwi.acceleration[wwi.count-1] = accel; 819​ wwi.acceleration[wwi.count-1] = accel;
827 } else { 820​ } else {
828 Pair& pos = wwi.position[wwi.count-1]; 821​ const Pair& pos = wwi.position[wwi.count-1];
829 neibourgs[0] = wwi.position[wwi.count-2]; 822​ neibourgs[0] = wwi.position[wwi.count-2];
830 neibourgs[1] = wwi.position[wwi.width*(wwi.height-1)-1]; 823​ neibourgs[1] = wwi.position[wwi.width*(wwi.height-1)-1];
831 824​
Context not available.
844 // top border 837​ // top border
845 for (unsigned int i = 1; i < wwi.width - 1; ++i) { 838​ for (unsigned int i = 1; i < wwi.width - 1; ++i) {
846 if (wwi.constraint[i]) { 839​ if (wwi.constraint[i]) {
847 Pair window_pos = wwi.origin[i]; 840​ const Pair& window_pos = wwi.origin[i];
848 Pair current_pos = wwi.position[i]; 841​ const Pair& current_pos = wwi.position[i];
849 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 842​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
850 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 843​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
851 wwi.acceleration[i] = accel; 844​ wwi.acceleration[i] = accel;
852 } else { 845​ } else {
853 Pair& pos = wwi.position[i]; 846​ const Pair& pos = wwi.position[i];
854 neibourgs[0] = wwi.position[i-1]; 847​ neibourgs[0] = wwi.position[i-1];
855 neibourgs[1] = wwi.position[i+1]; 848​ neibourgs[1] = wwi.position[i+1];
856 neibourgs[2] = wwi.position[i+wwi.width]; 849​ neibourgs[2] = wwi.position[i+wwi.width];
Context not available.
868 // bottom border 861​ // bottom border
869 for (unsigned int i = wwi.width * (wwi.height - 1) + 1; i < wwi.count - 1; ++i) { 862​ for (unsigned int i = wwi.width * (wwi.height - 1) + 1; i < wwi.count - 1; ++i) {
870 if (wwi.constraint[i]) { 863​ if (wwi.constraint[i]) {
871 Pair window_pos = wwi.origin[i]; 864​ const Pair& window_pos = wwi.origin[i];
872 Pair current_pos = wwi.position[i]; 865​ const Pair& current_pos = wwi.position[i];
873 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 866​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
874 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 867​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
875 wwi.acceleration[i] = accel; 868​ wwi.acceleration[i] = accel;
876 } else { 869​ } else {
877 Pair& pos = wwi.position[i]; 870​ const Pair& pos = wwi.position[i];
878 neibourgs[0] = wwi.position[i-1]; 871​ neibourgs[0] = wwi.position[i-1];
879 neibourgs[1] = wwi.position[i+1]; 872​ neibourgs[1] = wwi.position[i+1];
880 neibourgs[2] = wwi.position[i-wwi.width]; 873​ neibourgs[2] = wwi.position[i-wwi.width];
Context not available.
892 // left border 885​ // left border
893 for (unsigned int i = wwi.width; i < wwi.width*(wwi.height - 1); i += wwi.width) { 886​ for (unsigned int i = wwi.width; i < wwi.width*(wwi.height - 1); i += wwi.width) {
894 if (wwi.constraint[i]) { 887​ if (wwi.constraint[i]) {
895 Pair window_pos = wwi.origin[i]; 888​ const Pair& window_pos = wwi.origin[i];
896 Pair current_pos = wwi.position[i]; 889​ const Pair& current_pos = wwi.position[i];
897 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 890​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
898 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 891​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
899 wwi.acceleration[i] = accel; 892​ wwi.acceleration[i] = accel;
900 } else { 893​ } else {
901 Pair& pos = wwi.position[i]; 894​ const Pair& pos = wwi.position[i];
902 neibourgs[0] = wwi.position[i+1]; 895​ neibourgs[0] = wwi.position[i+1];
903 neibourgs[1] = wwi.position[i-wwi.width]; 896​ neibourgs[1] = wwi.position[i-wwi.width];
904 neibourgs[2] = wwi.position[i+wwi.width]; 897​ neibourgs[2] = wwi.position[i+wwi.width];
Context not available.
916 // right border 909​ // right border
917 for (unsigned int i = 2 * wwi.width - 1; i < wwi.count - 1; i += wwi.width) { 910​ for (unsigned int i = 2 * wwi.width - 1; i < wwi.count - 1; i += wwi.width) {
918 if (wwi.constraint[i]) { 911​ if (wwi.constraint[i]) {
919 Pair window_pos = wwi.origin[i]; 912​ const Pair& window_pos = wwi.origin[i];
920 Pair current_pos = wwi.position[i]; 913​ const Pair& current_pos = wwi.position[i];
921 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 914​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
922 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 915​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
923 wwi.acceleration[i] = accel; 916​ wwi.acceleration[i] = accel;
924 } else { 917​ } else {
925 Pair& pos = wwi.position[i]; 918​ const Pair& pos = wwi.position[i];
926 neibourgs[0] = wwi.position[i-1]; 919​ neibourgs[0] = wwi.position[i-1];
927 neibourgs[1] = wwi.position[i-wwi.width]; 920​ neibourgs[1] = wwi.position[i-wwi.width];
928 neibourgs[2] = wwi.position[i+wwi.width]; 921​ neibourgs[2] = wwi.position[i+wwi.width];
Context not available.
943 unsigned int index = i + j * wwi.width; 936​ unsigned int index = i + j * wwi.width;
944 937​
945 if (wwi.constraint[index]) { 938​ if (wwi.constraint[index]) {
946 Pair window_pos = wwi.origin[index]; 939​ const Pair& window_pos = wwi.origin[index];
947 Pair current_pos = wwi.position[index]; 940​ const Pair& current_pos = wwi.position[index];
948 Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y}; 941​ Pair move = {window_pos.x - current_pos.x, window_pos.y - current_pos.y};
949 Pair accel = {move.x*m_stiffness, move.y*m_stiffness}; 942​ Pair accel = {move.x*m_stiffness, move.y*m_stiffness};
950 wwi.acceleration[index] = accel; 943​ wwi.acceleration[index] = accel;
951 } else { 944​ } else {
952 Pair& pos = wwi.position[index]; 945​ const Pair& pos = wwi.position[index];
953 neibourgs[0] = wwi.position[index-1]; 946​ neibourgs[0] = wwi.position[index-1];
954 neibourgs[1] = wwi.position[index+1]; 947​ neibourgs[1] = wwi.position[index+1];
955 neibourgs[2] = wwi.position[index-wwi.width]; 948​ neibourgs[2] = wwi.position[index-wwi.width];
Context not available.
1049#endif 1042​#endif
1050 1043​
1051 if (wwi.status != Moving && acc_sum < m_stopAcceleration && vel_sum < m_stopVelocity) { 1044​ if (wwi.status != Moving && acc_sum < m_stopAcceleration && vel_sum < m_stopVelocity) {
1052 if (wwi.status == Closing) { ​
1053 w->unrefWindow(); ​
1054 } ​
1055 freeWobblyInfo(wwi); ​
1056 windows.remove(w); ​
1057 if (windows.isEmpty()) ​
1058 effects->addRepaintFull(); ​
1059 return false; 1045​ return false;
1060 } 1046​ }
1061 1047​
Context not available.
1072 // top-left 1058​ // top-left
1073 { 1059​ {
1074 Pair& res = wwi.buffer[0]; 1060​ Pair& res = wwi.buffer[0];
1075 Pair vit = data[0]; 1061​ const Pair& vit = data[0];
1076 neibourgs[0] = data[1]; 1062​ neibourgs[0] = data[1];
1077 neibourgs[1] = data[wwi.width]; 1063​ neibourgs[1] = data[wwi.width];
1078 neibourgs[2] = data[wwi.width+1]; 1064​ neibourgs[2] = data[wwi.width+1];
Context not available.
1085 // top-right 1071​ // top-right
1086 { 1072​ {
1087 Pair& res = wwi.buffer[wwi.width-1]; 1073​ Pair& res = wwi.buffer[wwi.width-1];
1088 Pair vit = data[wwi.width-1]; 1074​ const Pair& vit = data[wwi.width-1];
1089 neibourgs[0] = data[wwi.width-2]; 1075​ neibourgs[0] = data[wwi.width-2];
1090 neibourgs[1] = data[2*wwi.width-1]; 1076​ neibourgs[1] = data[2*wwi.width-1];
1091 neibourgs[2] = data[2*wwi.width-2]; 1077​ neibourgs[2] = data[2*wwi.width-2];
Context not available.
1098 // bottom-left 1084​ // bottom-left
1099 { 1085​ {
1100 Pair& res = wwi.buffer[wwi.width*(wwi.height-1)]; 1086​ Pair& res = wwi.buffer[wwi.width*(wwi.height-1)];
1101 Pair vit = data[wwi.width*(wwi.height-1)]; 1087​ const Pair& vit = data[wwi.width*(wwi.height-1)];
1102 neibourgs[0] = data[wwi.width*(wwi.height-1)+1]; 1088​ neibourgs[0] = data[wwi.width*(wwi.height-1)+1];
1103 neibourgs[1] = data[wwi.width*(wwi.height-2)]; 1089​ neibourgs[1] = data[wwi.width*(wwi.height-2)];
1104 neibourgs[2] = data[wwi.width*(wwi.height-2)+1]; 1090​ neibourgs[2] = data[wwi.width*(wwi.height-2)+1];
Context not available.
1111 // bottom-right 1097​ // bottom-right
1112 { 1098​ {
1113 Pair& res = wwi.buffer[wwi.count-1]; 1099​ Pair& res = wwi.buffer[wwi.count-1];
1114 Pair vit = data[wwi.count-1]; 1100​ const Pair& vit = data[wwi.count-1];
1115 neibourgs[0] = data[wwi.count-2]; 1101​ neibourgs[0] = data[wwi.count-2];
1116 neibourgs[1] = data[wwi.width*(wwi.height-1)-1]; 1102​ neibourgs[1] = data[wwi.width*(wwi.height-1)-1];
1117 neibourgs[2] = data[wwi.width*(wwi.height-1)-2]; 1103​ neibourgs[2] = data[wwi.width*(wwi.height-1)-2];
Context not available.
1126 // top border 1112​ // top border
1127 for (unsigned int i = 1; i < wwi.width - 1; ++i) { 1113​ for (unsigned int i = 1; i < wwi.width - 1; ++i) {
1128 Pair& res = wwi.buffer[i]; 1114​ Pair& res = wwi.buffer[i];
1129 Pair vit = data[i]; 1115​ const Pair& vit = data[i];
1130 neibourgs[0] = data[i-1]; 1116​ neibourgs[0] = data[i-1];
1131 neibourgs[1] = data[i+1]; 1117​ neibourgs[1] = data[i+1];
1132 neibourgs[2] = data[i+wwi.width]; 1118​ neibourgs[2] = data[i+wwi.width];
Context not available.
1140 // bottom border 1126​ // bottom border
1141 for (unsigned int i = wwi.width * (wwi.height - 1) + 1; i < wwi.count - 1; ++i) { 1127​ for (unsigned int i = wwi.width * (wwi.height - 1) + 1; i < wwi.count - 1; ++i) {
1142 Pair& res = wwi.buffer[i]; 1128​ Pair& res = wwi.buffer[i];
1143 Pair vit = data[i]; 1129​ const Pair& vit = data[i];
1144 neibourgs[0] = data[i-1]; 1130​ neibourgs[0] = data[i-1];
1145 neibourgs[1] = data[i+1]; 1131​ neibourgs[1] = data[i+1];
1146 neibourgs[2] = data[i-wwi.width]; 1132​ neibourgs[2] = data[i-wwi.width];
Context not available.
1154 // left border 1140​ // left border
1155 for (unsigned int i = wwi.width; i < wwi.width*(wwi.height - 1); i += wwi.width) { 1141​ for (unsigned int i = wwi.width; i < wwi.width*(wwi.height - 1); i += wwi.width) {
1156 Pair& res = wwi.buffer[i]; 1142​ Pair& res = wwi.buffer[i];
1157 Pair vit = data[i]; 1143​ const Pair& vit = data[i];
1158 neibourgs[0] = data[i+1]; 1144​ neibourgs[0] = data[i+1];
1159 neibourgs[1] = data[i-wwi.width]; 1145​ neibourgs[1] = data[i-wwi.width];
1160 neibourgs[2] = data[i+wwi.width]; 1146​ neibourgs[2] = data[i+wwi.width];
Context not available.
1168 // right border 1154​ // right border
1169 for (unsigned int i = 2 * wwi.width - 1; i < wwi.count - 1; i += wwi.width) { 1155​ for (unsigned int i = 2 * wwi.width - 1; i < wwi.count - 1; i += wwi.width) {
1170 Pair& res = wwi.buffer[i]; 1156​ Pair& res = wwi.buffer[i];
1171 Pair vit = data[i]; 1157​ const Pair& vit = data[i];
1172 neibourgs[0] = data[i-1]; 1158​ neibourgs[0] = data[i-1];
1173 neibourgs[1] = data[i-wwi.width]; 1159​ neibourgs[1] = data[i-wwi.width];
1174 neibourgs[2] = data[i+wwi.width]; 1160​ neibourgs[2] = data[i+wwi.width];
Context not available.
1185 unsigned int index = i + j * wwi.width; 1171​ unsigned int index = i + j * wwi.width;
1186 1172​
1187 Pair& res = wwi.buffer[index]; 1173​ Pair& res = wwi.buffer[index];
1188 Pair& vit = data[index]; 1174​ const Pair& vit = data[index];
1189 neibourgs[0] = data[index-1]; 1175​ neibourgs[0] = data[index-1];
1190 neibourgs[1] = data[index+1]; 1176​ neibourgs[1] = data[index+1];
1191 neibourgs[2] = data[index-wwi.width]; 1177​ neibourgs[2] = data[index-wwi.width];
Context not available.