← Back to branch summary

~timo-jyrinki/ubuntu/trusty/maliit-framework/fix_qt52

« back to all changes in this revision

Viewing changes to src/quickviewsurfacefactory.cpp

  • Committer: Package Import Robot
  • Author(s): Ricardo Salveti de Araujo, Sergio Schvezov, Ricardo Salveti de Araujo
  • Date: 2013-07-23 19:47:04 UTC
  • mfrom: (1.1.2) (1.2.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130723194704-1lsy1kmlda069cea
Tags: 0.99.0+git20130615+97e8335-0ubuntu1
[ Sergio Schvezov ]
* New build from HEAD 97e8335.
* Packaging import from lp:phablet-extras/maliit-framework.

[ Ricardo Salveti de Araujo ]
* debian/control: adding vcs and fixing dependencies
* General package cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/quickviewsurfacefactory.cpp
1
 
 
2
 
#include "quickviewsurfacefactory.h"
3
 
#include "quickviewsurfacefactory_p.h"
4
 
 
5
 
#include <maliit/plugins/abstractsurface.h>
6
 
#include <maliit/plugins/quickviewsurface.h>
7
 
 
8
 
#include <QtGui>
9
 
#include <QtQuick>
10
 
 
11
 
using Maliit::Plugins::AbstractSurface;
12
 
 
13
 
namespace Maliit {
14
 
namespace Server {
15
 
 
16
 
QuickViewSurfaceImpl::QuickViewSurfaceImpl(QuickViewSurfaceFactory *factory, AbstractSurface::Options options,
17
 
                                           const QSharedPointer<QuickViewSurfaceImpl> &parent)
18
 
    : QuickViewSurface(),
19
 
      mFactory(factory),
20
 
      mOptions(options),
21
 
      mParent(parent),
22
 
      mActive(false),
23
 
      mVisible(false),
24
 
      mRelativePosition(),
25
 
      mWindow()
26
 
{
27
 
    mWindow.reset(new QQuickView(0));
28
 
    if (parent) {
29
 
        QWindow *parentWindow = parent->mWindow.data();
30
 
        mWindow->setTransientParent(parentWindow);
31
 
        parentWindow->installEventFilter(this);
32
 
        connect(parentWindow, SIGNAL(xChanged(int)), this, SLOT(updatePosition()));
33
 
        connect(parentWindow, SIGNAL(yChanged(int)), this, SLOT(updatePosition()));
34
 
    }
35
 
 
36
 
    mWindow->setFlags(Qt::Dialog | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint
37
 
                      | Qt::X11BypassWindowManagerHint | Qt::WindowDoesNotAcceptFocus);
38
 
 
39
 
    QSurfaceFormat format;
40
 
    format.setAlphaBufferSize(8);
41
 
    mWindow->setFormat(format);
42
 
    mWindow->setColor(QColor(Qt::transparent));
43
 
 
44
 
    updateVisibility();
45
 
}
46
 
 
47
 
QuickViewSurfaceImpl::~QuickViewSurfaceImpl()
48
 
{
49
 
}
50
 
 
51
 
void QuickViewSurfaceImpl::show()
52
 
{
53
 
    mVisible = true;
54
 
    updateVisibility();
55
 
}
56
 
 
57
 
void QuickViewSurfaceImpl::hide()
58
 
{
59
 
    mVisible = false;
60
 
    updateVisibility();
61
 
}
62
 
 
63
 
QSize QuickViewSurfaceImpl::size() const
64
 
{
65
 
    return mWindow->size();
66
 
}
67
 
 
68
 
void QuickViewSurfaceImpl::setSize(const QSize &size)
69
 
{
70
 
    const QSize& desktopSize = QGuiApplication::screens().first()->size();
71
 
 
72
 
    // stand-alone Maliit server
73
 
    if (mOptions & PositionCenterBottom) {
74
 
        mWindow->setGeometry(QRect(QPoint((desktopSize.width() - size.width()) / 2,
75
 
                                          desktopSize.height() - size.height()), size));
76
 
    } else {
77
 
        mWindow->resize(size);
78
 
    }
79
 
}
80
 
 
81
 
QPoint QuickViewSurfaceImpl::relativePosition() const
82
 
{
83
 
    return mRelativePosition;
84
 
}
85
 
 
86
 
void QuickViewSurfaceImpl::setRelativePosition(const QPoint &position)
87
 
{
88
 
    mRelativePosition = position;
89
 
    QPoint parentPosition(0, 0);
90
 
    if (mParent) {
91
 
        parentPosition = mParent->mWindow->position();
92
 
    }
93
 
    mWindow->setPosition(parentPosition + mRelativePosition);
94
 
}
95
 
 
96
 
QSharedPointer<AbstractSurface> QuickViewSurfaceImpl::parent() const
97
 
{
98
 
    return mParent;
99
 
}
100
 
 
101
 
QPoint QuickViewSurfaceImpl::translateEventPosition(const QPoint &eventPosition,
102
 
                                                    const QSharedPointer<AbstractSurface> &eventSurface) const
103
 
{
104
 
    if (!eventSurface)
105
 
        return eventPosition;
106
 
 
107
 
    QSharedPointer<QuickViewSurfaceImpl> windowedSurface = qSharedPointerDynamicCast<QuickViewSurfaceImpl>(eventSurface);
108
 
    if (!windowedSurface)
109
 
        return QPoint();
110
 
 
111
 
    return -mWindow->position() + eventPosition + windowedSurface->mWindow->position();
112
 
}
113
 
 
114
 
void QuickViewSurfaceImpl::setActive(bool active)
115
 
{
116
 
    mActive = active;
117
 
    updateVisibility();
118
 
}
119
 
 
120
 
QRegion QuickViewSurfaceImpl::inputMethodArea()
121
 
{
122
 
    if (!mWindow->isVisible())
123
 
        return QRegion();
124
 
 
125
 
    return QRegion(mWindow->geometry());
126
 
}
127
 
 
128
 
QQuickView *QuickViewSurfaceImpl::view() const
129
 
{
130
 
    return mWindow.data();
131
 
}
132
 
 
133
 
bool QuickViewSurfaceImpl::eventFilter(QObject *, QEvent *event)
134
 
{
135
 
    if (event->type() == QEvent::Move) {
136
 
        updatePosition();
137
 
    }
138
 
 
139
 
    return false;
140
 
}
141
 
 
142
 
void QuickViewSurfaceImpl::updateVisibility()
143
 
{
144
 
    mWindow->setVisible(mActive && mVisible);
145
 
}
146
 
 
147
 
void QuickViewSurfaceImpl::updatePosition()
148
 
{
149
 
    setRelativePosition(mRelativePosition);
150
 
}
151
 
 
152
 
QuickViewSurfaceFactory::QuickViewSurfaceFactory()
153
 
{
154
 
}
155
 
 
156
 
QuickViewSurfaceFactory::~QuickViewSurfaceFactory()
157
 
{
158
 
}
159
 
 
160
 
QSize QuickViewSurfaceFactory::screenSize() const
161
 
{
162
 
    return QGuiApplication::screens().first()->size();
163
 
}
164
 
 
165
 
bool QuickViewSurfaceFactory::supported(Maliit::Plugins::AbstractSurface::Options options) const
166
 
{
167
 
    return options & Maliit::Plugins::AbstractSurface::TypeQuick2;
168
 
}
169
 
 
170
 
QSharedPointer<Maliit::Plugins::AbstractSurface> QuickViewSurfaceFactory::create(Maliit::Plugins::AbstractSurface::Options options,
171
 
                                                                                 const QSharedPointer<Maliit::Plugins::AbstractSurface> &parent)
172
 
{
173
 
    QSharedPointer<QuickViewSurfaceImpl> defaultSurfaceParent(qSharedPointerDynamicCast<QuickViewSurfaceImpl>(parent));
174
 
    if (options & Maliit::Plugins::AbstractSurface::TypeQuick2) {
175
 
        QSharedPointer<QuickViewSurfaceImpl> newSurface(new QuickViewSurfaceImpl(this, options, defaultSurfaceParent));
176
 
        surfaces.push_back(newSurface);
177
 
        return newSurface;
178
 
    }
179
 
    return QSharedPointer<AbstractSurface>();
180
 
}
181
 
 
182
 
void QuickViewSurfaceFactory::activate()
183
 
{
184
 
    mActive = true;
185
 
 
186
 
    Q_FOREACH(QWeakPointer<QuickViewSurfaceImpl> weakSurface, surfaces) {
187
 
        QSharedPointer<QuickViewSurfaceImpl> surface = weakSurface.toStrongRef();
188
 
        if (surface)
189
 
            surface->setActive(true);
190
 
    }
191
 
}
192
 
 
193
 
void QuickViewSurfaceFactory::deactivate()
194
 
{
195
 
    mActive = false;
196
 
 
197
 
    Q_FOREACH(QWeakPointer<QuickViewSurfaceImpl> weakSurface, surfaces) {
198
 
        QSharedPointer<QuickViewSurfaceImpl> surface = weakSurface.toStrongRef();
199
 
        if (surface)
200
 
            surface->setActive(false);
201
 
    }
202
 
}
203
 
 
204
 
} // namespace Server
205
 
} // namespace Maliit