← Back to branch summary

~compiz-team/compiz/0.9.10

« back to all changes in this revision

Viewing changes to plugins/composite/src/window.cpp

  • Committer: Daniel van Vugt
  • Author(s): smspillaz
  • Date: 2012-06-06 05:12:28 UTC
  • mfrom: (3221.2.17 pixmap)
  • Revision ID: daniel.van.vugt@canonical.com-20120606051228-oh5x09genim3x7nn
Adds some tests for the pixmap rebinding code ... which also means some
refactoring was done.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/composite/src/window.cpp
83
83
}
84
84
 
85
85
void
86
 
CompositeWindow::setNewPixmapReadyCallback (const NewPixmapReadyCallback &cb)
87
 
{
88
 
    priv->newPixmapReadyCallback = cb;
 
86
PrivateCompositeWindow::setNewPixmapReadyCallback (const PixmapBinding::NewPixmapReadyCallback &cb)
 
87
{
 
88
    mPixmapBinding.setNewPixmapReadyCallback (cb);
 
89
}
 
90
 
 
91
void
 
92
CompositeWindow::setNewPixmapReadyCallback (const PixmapBinding::NewPixmapReadyCallback &cb)
 
93
{
 
94
    priv->setNewPixmapReadyCallback (cb);
 
95
}
 
96
 
 
97
void
 
98
PrivateCompositeWindow::allowFurtherRebindAttempts ()
 
99
{
 
100
    mPixmapBinding.allowFurtherRebindAttempts ();
89
101
}
90
102
 
91
103
PrivateCompositeWindow::PrivateCompositeWindow (CompWindow      *w,
93
105
    window (w),
94
106
    cWindow (cw),
95
107
    cScreen (CompositeScreen::get (screen)),
96
 
    pixmap (None),
97
 
    needsRebind (true),
98
 
    newPixmapReadyCallback (),
 
108
    mPixmapBinding (boost::function <void ()> (),
 
109
                     this,
 
110
                     this,
 
111
                     screen->serverGrabInterface ()),
99
112
    damage (None),
100
113
    damaged (false),
101
114
    redirected (cScreen->compositingActive ()),
102
115
    overlayWindow (false),
103
 
    bindFailed (false),
104
116
    opacity (OPAQUE),
105
117
    brightness (BRIGHT),
106
118
    saturation (COLOR),
118
130
        free (damageRects);
119
131
}
120
132
 
 
133
 
 
134
 
 
135
bool
 
136
PrivateCompositeWindow::bind ()
 
137
{
 
138
    return mPixmapBinding.bind ();
 
139
}
 
140
 
121
141
bool
122
142
CompositeWindow::bind ()
123
143
{
125
145
        return false;
126
146
 
127
147
    redirect ();
128
 
    if (priv->needsRebind)
129
 
    {
130
 
        XWindowAttributes attr;
131
 
 
132
 
        /* don't try to bind window again if it failed previously */
133
 
        if (priv->bindFailed)
134
 
            return false;
135
 
 
136
 
        /* We have to grab the server here to make sure that window
137
 
           is mapped when getting the window pixmap */
138
 
        XGrabServer (screen->dpy ());
139
 
 
140
 
        /* Flush changes to the server and wait for it to process them */
141
 
        XSync (screen->dpy (), false);
142
 
        XGetWindowAttributes (screen->dpy (),
143
 
                              ROOTPARENT (priv->window), &attr);
144
 
        if (attr.map_state != IsViewable)
145
 
        {
146
 
            XUngrabServer (screen->dpy ());
147
 
            XSync (screen->dpy (), false);
148
 
            priv->bindFailed = true;
149
 
            return false;
150
 
        }
151
 
 
152
 
        Pixmap newPixmap = XCompositeNameWindowPixmap
153
 
            (screen->dpy (), ROOTPARENT (priv->window));
154
 
        CompSize newSize = CompSize (attr.border_width * 2 + attr.width,
155
 
                                     attr.border_width * 2 + attr.height);
156
 
        XUngrabServer (screen->dpy ());
157
 
        XSync (screen->dpy (), false);
158
 
 
159
 
        if (newPixmap && newSize.width () && newSize.height ())
160
 
        {
161
 
            /* Notify renderer that a new pixmap is about to
162
 
             * be bound */
163
 
            if (priv->newPixmapReadyCallback)
164
 
                priv->newPixmapReadyCallback ();
165
 
 
166
 
            /* Release old pixmap */
167
 
            if (priv->pixmap)
168
 
                XFreePixmap (screen->dpy (), priv->pixmap);
169
 
 
170
 
            /* Assign new pixmap */
171
 
            priv->pixmap = newPixmap;
172
 
            priv->size = newSize;
173
 
 
174
 
            priv->needsRebind = false;
175
 
        }
176
 
        else
177
 
        {
178
 
            priv->bindFailed = true;
179
 
            priv->needsRebind = false;
180
 
            return false;
181
 
        }
182
 
    }
183
 
    return true;
 
148
    return priv->bind ();
 
149
}
 
150
 
 
151
void
 
152
PrivateCompositeWindow::release ()
 
153
{
 
154
    mPixmapBinding.release ();
184
155
}
185
156
 
186
157
void
187
158
CompositeWindow::release ()
188
159
{
189
 
    priv->needsRebind = true;
 
160
    return priv->release ();
 
161
}
 
162
 
 
163
Pixmap
 
164
PrivateCompositeWindow::pixmap () const
 
165
{
 
166
    return mPixmapBinding.pixmap ();
 
167
}
 
168
 
 
169
WindowPixmapInterface::Ptr
 
170
PrivateCompositeWindow::getPixmap ()
 
171
{
 
172
    Pixmap pixmap = XCompositeNameWindowPixmap (screen->dpy (), ROOTPARENT (window));
 
173
    WindowPixmapInterface::Ptr p (new X11WindowPixmap (screen->dpy (), pixmap));
 
174
    return p;
 
175
}
 
176
 
 
177
bool
 
178
PrivateCompositeWindow::getAttributes (XWindowAttributes &attr)
 
179
{
 
180
    if (XGetWindowAttributes (screen->dpy (),
 
181
                              ROOTPARENT (window), &attr))
 
182
        return true;
 
183
 
 
184
    return false;
190
185
}
191
186
 
192
187
Pixmap
193
188
CompositeWindow::pixmap ()
194
189
{
195
 
    static Pixmap nPixmap = None;
196
 
 
197
 
    if (priv->needsRebind)
198
 
        return nPixmap;
199
 
 
200
 
    return priv->pixmap;
 
190
    return priv->pixmap ();
 
191
}
 
192
 
 
193
const CompSize &
 
194
PrivateCompositeWindow::size () const
 
195
{
 
196
    return mPixmapBinding.size ();
201
197
}
202
198
 
203
199
const CompSize &
204
200
CompositeWindow::size ()
205
201
{
206
 
    return priv->size;
 
202
    return priv->size ();
207
203
}
208
204
 
209
205
void
537
533
    switch (n)
538
534
    {
539
535
        case CompWindowNotifyMap:
540
 
            bindFailed = false;
 
536
            allowFurtherRebindAttempts ();
541
537
            damaged = false;
542
538
            break;
543
539
        case CompWindowNotifyUnmap: