← Back to branch summary

~ubuntu-branches/ubuntu/lucid/kdebase/lucid

« back to all changes in this revision

Viewing changes to kicker/applets/minipager/pagerbutton.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Ana Beatriz Guerrero Lopez
  • Date: 2009-04-05 05:22:13 UTC
  • mfrom: (0.4.2 experimental) (0.2.2 upstream)
  • mto: This revision was merged to the branch mainline in revision 235.
  • Revision ID: james.westby@ubuntu.com-20090405052213-39thr4l6p2ss07uj
Tags: 4:4.2.2-1
http://bugs.debian.org/290285
http://bugs.debian.org/359680
http://bugs.debian.org/286342
http://bugs.debian.org/444800
* New upstream release:
  - khtml fixes. (Closes: #290285, #359680)
  - Default konsole sessions can be deleted. (Closes: #286342)
  - Tag widget uses standard application palette. (Closes: #444800)
  - ... and surely many more but we have lost track...

Show diffs side-by-side

added added

removed removed

Lines of Context:
kicker/applets/minipager/pagerbutton.cpp
1
 
/*****************************************************************
2
 
 
3
 
Copyright (c) 1996-2000 the kicker authors. See file AUTHORS.
4
 
 
5
 
Permission is hereby granted, free of charge, to any person obtaining a copy
6
 
of this software and associated documentation files (the "Software"), to deal
7
 
in the Software without restriction, including without limitation the rights
8
 
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
 
copies of the Software, and to permit persons to whom the Software is
10
 
furnished to do so, subject to the following conditions:
11
 
 
12
 
The above copyright notice and this permission notice shall be included in
13
 
all copies or substantial portions of the Software.
14
 
 
15
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
18
 
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
19
 
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20
 
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21
 
 
22
 
******************************************************************/
23
 
 
24
 
#include <stdlib.h>
25
 
 
26
 
#include <qcursor.h>
27
 
#include <qdrawutil.h>
28
 
#include <qlineedit.h>
29
 
#include <qpainter.h>
30
 
#include <qpopupmenu.h>
31
 
#include <qstylesheet.h>
32
 
 
33
 
#include <netwm.h>
34
 
#include <dcopclient.h>
35
 
 
36
 
#include <kwinmodule.h>
37
 
#include <ksharedpixmap.h>
38
 
#include <kpixmapio.h>
39
 
#include <kpixmapeffect.h>
40
 
#include <kstringhandler.h>
41
 
#include <kiconloader.h>
42
 
 
43
 
#include "global.h"
44
 
#include "kickertip.h"
45
 
#include "kickerSettings.h"
46
 
#include "kshadowengine.h"
47
 
#include "paneldrag.h"
48
 
 
49
 
#include "pagerapplet.h"
50
 
#include "pagerbutton.h"
51
 
#include "pagerbutton.moc"
52
 
#include "pagersettings.h"
53
 
 
54
 
#ifdef FocusOut
55
 
#undef FocusOut
56
 
#endif
57
 
 
58
 
KSharedPixmap* KMiniPagerButton::s_commonSharedPixmap;
59
 
KPixmap* KMiniPagerButton::s_commonBgPixmap;
60
 
 
61
 
KMiniPagerButton::KMiniPagerButton(int desk, bool useViewPorts, const QPoint& viewport,
62
 
        KMiniPager *parent, const char *name)
63
 
    : QButton(parent, name),
64
 
      m_pager(parent),
65
 
      m_desktop(desk),
66
 
      m_useViewports(useViewPorts),
67
 
      m_viewport(viewport),
68
 
      m_lineEdit(0),
69
 
      m_sharedPixmap(0),
70
 
      m_bgPixmap(0),
71
 
      m_isCommon(false),
72
 
      m_currentWindow(0),
73
 
      m_inside(false)
74
 
{
75
 
    setToggleButton(true);
76
 
    setAcceptDrops(true);
77
 
    setWFlags(WNoAutoErase);
78
 
 
79
 
    setBackgroundOrigin(AncestorOrigin);
80
 
    installEventFilter(KickerTip::the());
81
 
 
82
 
    m_desktopName = m_pager->kwin()->desktopName(m_desktop);
83
 
 
84
 
    connect(this, SIGNAL(clicked()), SLOT(slotClicked()));
85
 
    connect(this, SIGNAL(toggled(bool)), SLOT(slotToggled(bool)));
86
 
    connect(&m_dragSwitchTimer, SIGNAL(timeout()), this, SLOT(slotDragSwitch()));
87
 
    connect(&m_updateCompressor, SIGNAL(timeout()), this, SLOT(update()));
88
 
 
89
 
    if (m_pager->desktopPreview())
90
 
    {
91
 
        setMouseTracking(true);
92
 
    }
93
 
    loadBgPixmap();
94
 
}
95
 
 
96
 
KMiniPagerButton::~KMiniPagerButton()
97
 
{
98
 
    delete m_sharedPixmap;
99
 
    delete m_bgPixmap;
100
 
}
101
 
 
102
 
QRect KMiniPagerButton::mapGeometryToViewport(const KWin::WindowInfo& info) const
103
 
{
104
 
    if (!m_useViewports)
105
 
        return info.frameGeometry();
106
 
 
107
 
    // ### fix vertically layouted viewports
108
 
    QRect _r(info.frameGeometry());
109
 
    QPoint vx(m_pager->kwin()->currentViewport(m_pager->kwin()->currentDesktop()));
110
 
 
111
 
    _r.moveBy( - (m_desktop - vx.x()) * QApplication::desktop()->width(),
112
 
               0);
113
 
 
114
 
    if ((info.state() & NET::Sticky))
115
 
    {
116
 
        _r.moveTopLeft(QPoint(_r.x() % QApplication::desktop()->width(),
117
 
                    _r.y() % QApplication::desktop()->height()));
118
 
 
119
 
    }
120
 
 
121
 
    return _r;
122
 
}
123
 
 
124
 
QPoint KMiniPagerButton::mapPointToViewport(const QPoint& _p) const
125
 
{
126
 
    if (!m_useViewports) return _p;
127
 
 
128
 
    QPoint vx(m_pager->kwin()->currentViewport(m_pager->kwin()->currentDesktop()));
129
 
 
130
 
    // ### fix vertically layouted viewports
131
 
    QPoint p(_p);
132
 
    p.setX(p.x() + (m_desktop - vx.x()) * QApplication::desktop()->width());
133
 
    return p;
134
 
}
135
 
 
136
 
bool KMiniPagerButton::shouldPaintWindow( KWin::WindowInfo *info ) const
137
 
{
138
 
    if (!info)
139
 
      return false;
140
 
 
141
 
//  if (info->mappingState != NET::Visible)
142
 
//    return false;
143
 
 
144
 
    NET::WindowType type = info->windowType( NET::NormalMask | NET::DesktopMask
145
 
        | NET::DockMask | NET::ToolbarMask | NET::MenuMask | NET::DialogMask
146
 
        | NET::OverrideMask | NET::TopMenuMask | NET::UtilityMask | NET::SplashMask );
147
 
 
148
 
    if (type == NET::Desktop || type == NET::Dock || type == NET::TopMenu)
149
 
      return false;
150
 
 
151
 
    if (!m_useViewports && !info->isOnDesktop(m_desktop))
152
 
      return false;
153
 
 
154
 
    if (m_useViewports) {
155
 
        QRect r = mapGeometryToViewport(*info);
156
 
 
157
 
        if (!info->hasState(NET::Sticky) &&
158
 
            !QApplication::desktop()->geometry().contains(r.topLeft()) &&
159
 
            !QApplication::desktop()->geometry().contains(r.topRight()))
160
 
            return false;
161
 
    }
162
 
 
163
 
    if (info->state() & NET::SkipPager || info->state() & NET::Shaded )
164
 
      return false;
165
 
 
166
 
    if (info->win() == m_pager->winId())
167
 
      return false;
168
 
 
169
 
    if ( info->isMinimized() )
170
 
      return false;
171
 
 
172
 
    return true;
173
 
}
174
 
 
175
 
void KMiniPagerButton::resizeEvent(QResizeEvent *ev)
176
 
{
177
 
    if (m_lineEdit)
178
 
    {
179
 
        m_lineEdit->setGeometry(rect());
180
 
    }
181
 
 
182
 
    delete m_bgPixmap;
183
 
    m_bgPixmap = 0;
184
 
 
185
 
    QButton::resizeEvent(ev);
186
 
}
187
 
 
188
 
void KMiniPagerButton::windowsChanged()
189
 
{
190
 
    m_currentWindow = 0;
191
 
 
192
 
    if (!m_updateCompressor.isActive())
193
 
    {
194
 
        m_updateCompressor.start(50, true);
195
 
    }
196
 
}
197
 
 
198
 
void KMiniPagerButton::backgroundChanged()
199
 
{
200
 
    delete s_commonSharedPixmap;
201
 
    s_commonSharedPixmap = 0;
202
 
    delete s_commonBgPixmap;
203
 
    s_commonBgPixmap = 0;
204
 
    loadBgPixmap();
205
 
}
206
 
 
207
 
void KMiniPagerButton::loadBgPixmap()
208
 
{
209
 
    if (m_pager->bgType() != PagerSettings::EnumBackgroundType::BgLive)
210
 
        return; // not needed
211
 
 
212
 
    DCOPClient *client = kapp->dcopClient();
213
 
    if (!client->isAttached())
214
 
    {
215
 
        client->attach();
216
 
    }
217
 
 
218
 
    QCString kdesktop_name;
219
 
    int screen_number = DefaultScreen(qt_xdisplay());
220
 
    if (screen_number == 0)
221
 
        kdesktop_name = "kdesktop";
222
 
    else
223
 
        kdesktop_name.sprintf("kdesktop-screen-%d", screen_number);
224
 
 
225
 
    QByteArray data, replyData;
226
 
    QCString replyType;
227
 
    if (client->call(kdesktop_name, "KBackgroundIface", "isCommon()",
228
 
                     data, replyType, replyData))
229
 
    {
230
 
        if (replyType == "bool")
231
 
        {
232
 
            QDataStream reply(replyData, IO_ReadOnly);
233
 
            reply >> m_isCommon;
234
 
        }
235
 
    }
236
 
 
237
 
    if (m_isCommon)
238
 
    {
239
 
        if (s_commonBgPixmap)
240
 
        { // pixmap is already ready, just use it
241
 
            backgroundLoaded( true );
242
 
            return;
243
 
        }
244
 
        else if (s_commonSharedPixmap)
245
 
        { // other button is already fetching the pixmap
246
 
            connect(s_commonSharedPixmap, SIGNAL(done(bool)),
247
 
                    SLOT(backgroundLoaded(bool)));
248
 
            return;
249
 
        }
250
 
    }
251
 
 
252
 
    QDataStream args( data, IO_WriteOnly );
253
 
    args << 1;
254
 
    client->send(kdesktop_name, "KBackgroundIface", "setExport(int)", data);
255
 
 
256
 
    if (m_isCommon)
257
 
    {
258
 
        if (!s_commonSharedPixmap)
259
 
        {
260
 
            s_commonSharedPixmap = new KSharedPixmap;
261
 
            connect(s_commonSharedPixmap, SIGNAL(done(bool)),
262
 
                    SLOT(backgroundLoaded(bool)));
263
 
        }
264
 
        s_commonSharedPixmap->loadFromShared(QString("DESKTOP1"));
265
 
    }
266
 
    else
267
 
    {
268
 
        if (!m_sharedPixmap)
269
 
        {
270
 
            m_sharedPixmap = new KSharedPixmap;
271
 
            connect(m_sharedPixmap, SIGNAL(done(bool)),
272
 
                    SLOT(backgroundLoaded(bool)));
273
 
        }
274
 
        m_sharedPixmap->loadFromShared(QString("DESKTOP%1").arg(m_desktop));
275
 
    }
276
 
}
277
 
 
278
 
static QPixmap scalePixmap(const QPixmap &pixmap, int width, int height)
279
 
{
280
 
    if (pixmap.width()>100)
281
 
    {
282
 
        KPixmapIO io;
283
 
        QImage img( io.convertToImage( pixmap ) );
284
 
        return io.convertToPixmap( img.smoothScale( width, height ) );
285
 
    }
286
 
 
287
 
    QImage img( pixmap.convertToImage().smoothScale( width, height ) );
288
 
    QPixmap pix;
289
 
    pix.convertFromImage( img );
290
 
 
291
 
    return pix;
292
 
}
293
 
 
294
 
void KMiniPagerButton::backgroundLoaded( bool loaded )
295
 
{
296
 
    if (loaded)
297
 
    {
298
 
        if (!m_bgPixmap)
299
 
        {
300
 
            m_bgPixmap = new KPixmap;
301
 
        }
302
 
        if (m_isCommon)
303
 
        {
304
 
            if (!s_commonBgPixmap)
305
 
            {
306
 
                s_commonBgPixmap = new KPixmap;
307
 
                *s_commonBgPixmap = scalePixmap(*s_commonSharedPixmap, width(), height());
308
 
                s_commonSharedPixmap->deleteLater(); // let others get the signal too
309
 
                s_commonSharedPixmap = 0;
310
 
            }
311
 
            *m_bgPixmap = *s_commonBgPixmap;
312
 
        }
313
 
        else
314
 
        {
315
 
            *m_bgPixmap = scalePixmap(*m_sharedPixmap, width(), height());
316
 
            delete m_sharedPixmap;
317
 
            m_sharedPixmap = 0L;
318
 
        }
319
 
 
320
 
        update();
321
 
    }
322
 
    else
323
 
    {
324
 
        kdWarning() << "Error getting the background\n";
325
 
    }
326
 
}
327
 
 
328
 
void KMiniPagerButton::enterEvent(QEvent *)
329
 
{
330
 
    m_inside = true;
331
 
    update();
332
 
}
333
 
 
334
 
void KMiniPagerButton::leaveEvent(QEvent *)
335
 
{
336
 
    m_inside = false;
337
 
    update();
338
 
}
339
 
 
340
 
void KMiniPagerButton::drawButton(QPainter *bp)
341
 
{
342
 
    int w = width();
343
 
    int h = height();
344
 
    bool on = isOn();
345
 
    bool down = isDown();
346
 
 
347
 
    QBrush background;
348
 
 
349
 
    bool liveBkgnd = m_pager->bgType() == PagerSettings::EnumBackgroundType::BgLive;
350
 
    bool transparent = m_pager->bgType() == PagerSettings::EnumBackgroundType::BgTransparent;
351
 
 
352
 
    // background
353
 
 
354
 
    if (backgroundPixmap())
355
 
    {
356
 
        QPoint pt = backgroundOffset();
357
 
        bp->drawTiledPixmap(0, 0, width(), height(), *backgroundPixmap(), pt.x(), pt.y());
358
 
    }
359
 
    else
360
 
    {
361
 
        bp->fillRect(0, 0, width(), height(), paletteBackgroundColor());
362
 
    }
363
 
    
364
 
 
365
 
    // desktop background
366
 
    
367
 
    if (liveBkgnd)
368
 
    {
369
 
        if (m_bgPixmap && !m_bgPixmap->isNull())
370
 
        {
371
 
            if (on)
372
 
            {
373
 
                KPixmap tmp = *m_bgPixmap;
374
 
                KPixmapEffect::intensity(tmp, 0.33);
375
 
                bp->drawPixmap(0, 0, tmp);
376
 
            }
377
 
            else
378
 
            {
379
 
                bp->drawPixmap(0, 0, *m_bgPixmap);
380
 
            }
381
 
        }
382
 
        else
383
 
        {
384
 
            liveBkgnd = false;
385
 
        }
386
 
    }
387
 
 
388
 
    if (!liveBkgnd)
389
 
    {
390
 
        if (transparent)
391
 
        {
392
 
            // transparent windows get an 1 pixel frame...
393
 
            if (on)
394
 
            {
395
 
                bp->setPen(colorGroup().midlight());
396
 
            }
397
 
            else if (down)
398
 
            {
399
 
                bp->setPen(KickerLib::blendColors(colorGroup().mid(),
400
 
                                                 colorGroup().midlight()));
401
 
            }
402
 
            else
403
 
            {
404
 
                bp->setPen(colorGroup().dark());
405
 
            }
406
 
 
407
 
            bp->drawRect(0, 0, w, h);
408
 
        }
409
 
        else
410
 
        {
411
 
            QBrush background;
412
 
 
413
 
            if (on)
414
 
            {
415
 
                background = colorGroup().brush(QColorGroup::Midlight);
416
 
            }
417
 
            else if (down)
418
 
            {
419
 
                background = KickerLib::blendColors(colorGroup().mid(),
420
 
                                                    colorGroup().midlight());
421
 
            }
422
 
            else
423
 
            {
424
 
                background = colorGroup().brush(QColorGroup::Mid);
425
 
            }
426
 
 
427
 
            bp->fillRect(0, 0, w, h, background);
428
 
        }
429
 
    }
430
 
 
431
 
    // window preview...
432
 
    if (m_pager->desktopPreview())
433
 
    {
434
 
        KWinModule* kwin = m_pager->kwin();
435
 
        KWin::WindowInfo *info = 0;
436
 
        int dw = QApplication::desktop()->width();
437
 
        int dh = QApplication::desktop()->height();
438
 
 
439
 
        QValueList<WId> windows = kwin->stackingOrder();
440
 
        QValueList<WId>::const_iterator itEnd = windows.constEnd();
441
 
        for (QValueList<WId>::ConstIterator it = windows.constBegin(); it != itEnd; ++it)
442
 
        {
443
 
            info = m_pager->info(*it);
444
 
 
445
 
            if (shouldPaintWindow(info))
446
 
            {
447
 
                QRect r = mapGeometryToViewport(*info);
448
 
                r = QRect(r.x() * width() / dw, 2 + r.y() * height() / dh,
449
 
                          r.width() * width() / dw, r.height() * height() / dh);
450
 
 
451
 
                if (kwin->activeWindow() == info->win())
452
 
                {
453
 
                    QBrush brush = colorGroup().brush(QColorGroup::Highlight);
454
 
                    qDrawShadeRect(bp, r, colorGroup(), false, 1, 0, &brush);
455
 
                }
456
 
                else
457
 
                {
458
 
                    QBrush brush = colorGroup().brush(QColorGroup::Button);
459
 
 
460
 
                    if (on)
461
 
                    {
462
 
                        brush.setColor(brush.color().light(120));
463
 
                    }
464
 
 
465
 
                    bp->fillRect(r, brush);
466
 
                    qDrawShadeRect(bp, r, colorGroup(), true, 1, 0);
467
 
                }
468
 
 
469
 
                if (m_pager->windowIcons() && r.width() > 15 && r.height() > 15)
470
 
                {
471
 
                    QPixmap icon = KWin::icon(*it, 16, 16, true);
472
 
                    if (!icon.isNull())
473
 
                    {
474
 
                        bp->drawPixmap(r.left() + ((r.width() - 16) / 2),
475
 
                                      r.top() + ((r.height() - 16) / 2),
476
 
                                      icon);
477
 
                    }
478
 
                }
479
 
            }
480
 
        }
481
 
    }
482
 
 
483
 
    if (liveBkgnd)
484
 
    {
485
 
        // draw a little border around the individual buttons
486
 
        // makes it look a bit more finished.
487
 
        if (on)
488
 
        {
489
 
            bp->setPen(colorGroup().midlight());
490
 
        }
491
 
        else
492
 
        {
493
 
            bp->setPen(colorGroup().mid());
494
 
        }
495
 
 
496
 
        bp->drawRect(0, 0, w, h);
497
 
    }
498
 
 
499
 
    if (m_pager->labelType() != PagerSettings::EnumLabelType::LabelNone)
500
 
    {
501
 
        QString label = (m_pager->labelType() == PagerSettings::EnumLabelType::LabelNumber) ?
502
 
                            QString::number(m_desktop) : m_desktopName;
503
 
        
504
 
        if (transparent || liveBkgnd)
505
 
        {
506
 
            bp->setPen(on ? colorGroup().midlight() : colorGroup().buttonText());
507
 
            m_pager->shadowEngine()->drawText(*bp, QRect(0, 0, w, h), AlignCenter, label, size());
508
 
        }
509
 
        else
510
 
            bp->drawText(0, 0, w, h, AlignCenter, label);
511
 
    }
512
 
    
513
 
    if (m_inside)
514
 
        KickerLib::drawBlendedRect(bp, QRect(1, 1, width() - 2, height() - 2), colorGroup().foreground());
515
 
}
516
 
 
517
 
void KMiniPagerButton::mousePressEvent(QMouseEvent * e)
518
 
{
519
 
    if (e->button() == RightButton)
520
 
    {
521
 
        // prevent LMB down -> RMB down -> LMB up sequence
522
 
        if ((e->state() & MouseButtonMask ) == NoButton)
523
 
        {
524
 
            emit showMenu(e->globalPos(), m_desktop);
525
 
            return;
526
 
        }
527
 
    }
528
 
 
529
 
    if (m_pager->desktopPreview())
530
 
    {
531
 
        m_pager->clickPos = e->pos();
532
 
    }
533
 
 
534
 
    QButton::mousePressEvent(e);
535
 
}
536
 
 
537
 
void KMiniPagerButton::mouseReleaseEvent(QMouseEvent* e)
538
 
{
539
 
    m_pager->clickPos = QPoint();
540
 
    QButton::mouseReleaseEvent(e);
541
 
}
542
 
 
543
 
void KMiniPagerButton::mouseMoveEvent(QMouseEvent* e)
544
 
{
545
 
    if (!m_pager->desktopPreview())
546
 
    {
547
 
        return;
548
 
    }
549
 
 
550
 
    int dw = QApplication::desktop()->width();
551
 
    int dh = QApplication::desktop()->height();
552
 
    int w = width();
553
 
    int h = height();
554
 
 
555
 
    QPoint pos(m_pager->clickPos.isNull() ? mapFromGlobal(QCursor::pos()) : m_pager->clickPos);
556
 
    QPoint p = mapPointToViewport(QPoint(pos.x() * dw / w, pos.y() * dh / h));
557
 
 
558
 
    Task::Ptr wasWindow = m_currentWindow;
559
 
    m_currentWindow = TaskManager::the()->findTask(m_useViewports ? 1 : m_desktop, p);
560
 
 
561
 
    if (wasWindow != m_currentWindow)
562
 
    {
563
 
        KickerTip::Client::updateKickerTip();
564
 
    }
565
 
 
566
 
    if (m_currentWindow && !m_pager->clickPos.isNull() &&
567
 
        (m_pager->clickPos - e->pos()).manhattanLength() > KGlobalSettings::dndEventDelay())
568
 
    {
569
 
        QRect r = m_currentWindow->geometry();
570
 
 
571
 
        // preview window height, window width
572
 
        int ww = r.width() * w / dw;
573
 
        int wh = r.height() * h / dh;
574
 
        QPixmap windowImage(ww, wh);
575
 
        QPainter bp(&windowImage, this);
576
 
 
577
 
        bp.setPen(colorGroup().foreground());
578
 
        bp.drawRect(0, 0, ww, wh);
579
 
        bp.fillRect(1, 1, ww - 2, wh - 2, colorGroup().background());
580
 
 
581
 
        Task::List tasklist;
582
 
        tasklist.append(m_currentWindow);
583
 
        TaskDrag* drag = new TaskDrag(tasklist, this);
584
 
        QPoint offset(m_pager->clickPos.x() - (r.x() * w / dw),
585
 
                m_pager->clickPos.y() - (r.y() * h / dh));
586
 
        drag->setPixmap(windowImage, offset);
587
 
        drag->dragMove();
588
 
 
589
 
        if (isDown())
590
 
        {
591
 
            setDown(false);
592
 
        }
593
 
 
594
 
        m_pager->clickPos = QPoint();
595
 
    }
596
 
}
597
 
 
598
 
void KMiniPagerButton::dragEnterEvent(QDragEnterEvent* e)
599
 
{
600
 
    if (PanelDrag::canDecode(e))
601
 
    {
602
 
        // ignore container drags
603
 
        return;
604
 
    }
605
 
    else if (TaskDrag::canDecode(e))
606
 
    {
607
 
        // if it's a task drag don't switch the desktop, just accept it
608
 
        e->accept();
609
 
        setDown(true);
610
 
    }
611
 
    else
612
 
    {
613
 
        // if a dragitem is held for over a pager button for two seconds,
614
 
        // activate corresponding desktop
615
 
        m_dragSwitchTimer.start(1000, true);
616
 
        QButton::dragEnterEvent(e);
617
 
    }
618
 
}
619
 
 
620
 
void KMiniPagerButton::dropEvent(QDropEvent* e)
621
 
{
622
 
    if (TaskDrag::canDecode(e))
623
 
    {
624
 
        e->accept();
625
 
        Task::List tasks(TaskDrag::decode(e));
626
 
 
627
 
        if ((m_useViewports || e->source() == this) && tasks.count() == 1)
628
 
        {
629
 
            Task::Ptr task = tasks[0];
630
 
            int dw = QApplication::desktop()->width();
631
 
            int dh = QApplication::desktop()->height();
632
 
            int w = width();
633
 
            int h = height();
634
 
            QRect location = mapGeometryToViewport(task->info());
635
 
            QPoint pos = mapPointToViewport(e->pos());
636
 
            int deltaX = pos.x() - m_pager->clickPos.x();
637
 
            int deltaY = pos.y() - m_pager->clickPos.y();
638
 
 
639
 
            if (abs(deltaX) < 3)
640
 
            {
641
 
                deltaX = 0;
642
 
            }
643
 
            else
644
 
            {
645
 
                deltaX = deltaX * dw / w;
646
 
            }
647
 
 
648
 
            if (abs(deltaY) < 3)
649
 
            {
650
 
                deltaY = 0;
651
 
            }
652
 
            else
653
 
            {
654
 
                deltaY = deltaY * dh / h;
655
 
            }
656
 
 
657
 
            location.moveBy(deltaX, deltaY);
658
 
 
659
 
            XMoveWindow(x11Display(), task->window(), location.x(), location.y());
660
 
            if ((e->source() != this || !task->isOnAllDesktops()) &&
661
 
                task->desktop() != m_desktop)
662
 
            {
663
 
                task->toDesktop(m_desktop);
664
 
            }
665
 
        }
666
 
        else
667
 
        {
668
 
            Task::List::iterator itEnd = tasks.end();
669
 
            for (Task::List::iterator it = tasks.begin(); it != itEnd; ++it)
670
 
            {
671
 
                (*it)->toDesktop(m_desktop);
672
 
            }
673
 
        }
674
 
 
675
 
        setDown(false);
676
 
    }
677
 
 
678
 
    QButton::dropEvent( e );
679
 
}
680
 
 
681
 
void KMiniPagerButton::enabledChange( bool oldEnabled )
682
 
{
683
 
    if (m_pager->bgType() == PagerSettings::EnumBackgroundType::BgLive)
684
 
    {
685
 
        m_pager->refresh();
686
 
    }
687
 
 
688
 
    QButton::enabledChange(oldEnabled);
689
 
}
690
 
 
691
 
void KMiniPagerButton::dragLeaveEvent( QDragLeaveEvent* e )
692
 
{
693
 
    m_dragSwitchTimer.stop();
694
 
 
695
 
    if (m_pager->kwin()->currentDesktop() != m_desktop)
696
 
    {
697
 
        setDown(false);
698
 
    }
699
 
 
700
 
    QButton::dragLeaveEvent( e );
701
 
}
702
 
 
703
 
void KMiniPagerButton::slotDragSwitch()
704
 
{
705
 
    emit buttonSelected(m_desktop);
706
 
}
707
 
 
708
 
void KMiniPagerButton::slotClicked()
709
 
{
710
 
    emit buttonSelected(m_desktop);
711
 
}
712
 
 
713
 
void KMiniPagerButton::rename()
714
 
{
715
 
  if ( !m_lineEdit ) {
716
 
    m_lineEdit = new QLineEdit( this );
717
 
    connect( m_lineEdit, SIGNAL( returnPressed() ), m_lineEdit, SLOT( hide() ) );
718
 
    m_lineEdit->installEventFilter( this );
719
 
  }
720
 
  m_lineEdit->setGeometry( rect() );
721
 
  m_lineEdit->setText(m_desktopName);
722
 
  m_lineEdit->show();
723
 
  m_lineEdit->setFocus();
724
 
  m_lineEdit->selectAll();
725
 
  m_pager->emitRequestFocus();
726
 
}
727
 
 
728
 
void KMiniPagerButton::slotToggled( bool b )
729
 
{
730
 
    if ( !b && m_lineEdit )
731
 
    {
732
 
        m_lineEdit->hide();
733
 
    }
734
 
}
735
 
 
736
 
bool KMiniPagerButton::eventFilter( QObject *o, QEvent * e)
737
 
{
738
 
    if (o && o == m_lineEdit &&
739
 
        (e->type() == QEvent::FocusOut || e->type() == QEvent::Hide))
740
 
    {
741
 
        m_pager->kwin()->setDesktopName( m_desktop, m_lineEdit->text() );
742
 
        m_desktopName = m_lineEdit->text();
743
 
        QTimer::singleShot( 0, m_lineEdit, SLOT( deleteLater() ) );
744
 
        m_lineEdit = 0;
745
 
        return true;
746
 
    }
747
 
 
748
 
    return QButton::eventFilter(o, e);
749
 
}
750
 
 
751
 
void KMiniPagerButton::updateKickerTip(KickerTip::Data &data)
752
 
{
753
 
    Task::Dict tasks = TaskManager::the()->tasks();
754
 
    Task::Dict::iterator taskEnd = tasks.end();
755
 
    uint taskCounter = 0;
756
 
    uint taskLimiter = 4;
757
 
    QString lastWindow;
758
 
 
759
 
    for (Task::Dict::iterator it = tasks.begin(); it != taskEnd; ++it)
760
 
    {
761
 
        if (it.data()->desktop() == m_desktop || it.data()->isOnAllDesktops())
762
 
        {
763
 
            taskCounter++;
764
 
            if (taskCounter > taskLimiter)
765
 
            {
766
 
                lastWindow = it.data()->visibleName();
767
 
                continue;
768
 
            }
769
 
 
770
 
            QPixmap winIcon = it.data()->pixmap();
771
 
            QString bullet;
772
 
 
773
 
            if (winIcon.isNull())
774
 
            {
775
 
                bullet = "&bull;";
776
 
            }
777
 
            else
778
 
            {
779
 
                data.mimeFactory->setPixmap(QString::number(taskCounter), winIcon);
780
 
                bullet = QString("<img src=\"%1\" width=\"%2\" height=\"%3\">").arg(taskCounter).arg(16).arg(16);
781
 
            }
782
 
 
783
 
            QString name = KStringHandler::cPixelSqueeze(it.data()->visibleName(), fontMetrics(), 400);
784
 
            name = QStyleSheet::escape(name);
785
 
            if (it.data() == m_currentWindow)
786
 
            {
787
 
                data.subtext.append(QString("<br>%1&nbsp; <u>").arg(bullet));
788
 
                data.subtext.append(name).append("</u>");
789
 
            }
790
 
            else
791
 
            {
792
 
                data.subtext.append(QString("<br>%1&nbsp; ").arg(bullet));
793
 
                data.subtext.append(name);
794
 
            }
795
 
        }
796
 
    }
797
 
 
798
 
    if (taskCounter > taskLimiter)
799
 
    {
800
 
        if (taskCounter - taskLimiter == 1)
801
 
        {
802
 
            data.subtext.append("<br>&bull; ").append(lastWindow);
803
 
        }
804
 
        else
805
 
        {
806
 
            data.subtext.append("<br>&bull; <i>")
807
 
                        .append(i18n("and 1 other", "and %n others", taskCounter - taskLimiter))
808
 
                        .append("</i>");
809
 
        }
810
 
    }
811
 
 
812
 
    if (taskCounter > 0)
813
 
    {
814
 
        data.subtext.prepend(i18n("One window:",
815
 
                                  "%n windows:",
816
 
                                  taskCounter));
817
 
    }
818
 
 
819
 
    data.duration = 4000;
820
 
    data.icon = DesktopIcon("window_list", KIcon::SizeMedium);
821
 
    data.message = QStyleSheet::escape(m_desktopName);
822
 
    data.direction = m_pager->popupDirection();
823
 
}
824