Window state tracking is basically the back bond of window fading. We
add a new enum field to the win struct to track the state of the window,
instead of using a set of boolean variables. We also remove the fading
callbacks, since it is only used for fading, so the potential of code
reuse is lost. And it makes the code slightly harder to understand.
Also fixed a problem that --no-fading-openclose is not behaving as
advertised (from my observation, enabling this flag disables fading
entirely, instead of just diabling it for open/close).
Also uses double for opacity everywhere internally. Use opacity_t only
when setting X opacity prop.
TODO: Remove win::*_last
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
Slightly clean up header inclusion with the help of clang's module system.
It's better for files to include the things you need directly.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
Moved:
* Blur kernel related functions to kernel.c
* Vsync related functions to vsync.c
* paint related functions to render.c
This will make the `split-backend` branch easier to rebase.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
This was a dubious "fix" for a Nvidia driver problem. The problem was
never fully understood, and the then developers took a shotgun approach
and implemented xsync fences as a fix. Which somehow fixed the problem.
Again, I don't see any indication that the developers understood why
this "fix" worked.
(for details, see chjj/compton#152 and chjj/compton#181)
The driver problem should have been fixed almost 5 years ago. So this
shouldn't be needed anymore. In addition the way compton uses xsync fences
is apparently wrong according to the xsync spec (fences are attached to
screen, but compton uses them as if they were attached to drawables).
So, I will try removing it and see if anyone will complain. If there are
real concrete reasons why fences are needed, it will be brought back.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
IANAL, but I think I am allowed to add missing copyright notices for
someone else. And I did my best job using git history to figure out who
wrote which functions. So I hope everything is fine.
Bugs:
* There seems to be a noticeable frame loss when window
is being opened/closed. But the same problem also exists
in master/next, so this is not a regression.
* Using --sw-opti and --benchmark at the same time causing
compton to draw more frequently than permitted by the
arguments. That is because the sleep interval calculation
is flawed. Not really a regression either.
Verified still working:
* Usual painting
* Fade
* Benchmark mode
* --sw-opti (with or without benchmark mode)
* DBus
* Unredir delay
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
Re-did the painting logic, and document it.
It is unclear to me what is the previous painting logic. But the current
one is basically this:
1. Go through all windows top to bottom, and put visible windows (not
unmapped, opacity > 0, etc) into a linked list, from bottom to top
2. Accumulate a region of ignore on each window, which is basically the
region of screen that is obscured by all the windows above current
one.
3. Paint all the visible windows from bottom to top. Subtract the region
of ignore from the painting region. If we need to paint shadow, we
subtract the body of the window from the shadow painting region too,
because we don't want shadow behind the window.
4. region of ignore is invalidated when window stack change, an
window on top moved or changed shape, when window changed between
opaque and transparent, etc.
Notes:
It is unclear whether all the different shapes of a window (extents,
noframe, border, bounding shape, etc) are calculated correctly or not.
It is unclear if window shape related events are handled correctly or
not. Need more testing.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
Change `win *` to `win **`, because a window could be freed by the
callback, so we can set `*w` to NULL to communicate that.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
Instead use win_has_alpha to check for alpha channel, window mode is
reserved for determine if the window is possibly transparent.
Signed-off-by: Yuxuan Shui <yshuiv7@gmail.com>
The existing mechanism with set_ignore_next() is (IMHO) ugly and also
does not work with XCB requests. This commit adds a new function
set_ignore_cookie() and fixes callers that were converted to XCB to use
this new function instead.
Signed-off-by: Uli Schlachter <psychon@znc.in>
No functional changes intended. The new xcb_damage_query_version() was
previously done by XDamageQueryExtension() internally.
Signed-off-by: Uli Schlachter <psychon@znc.in>
If an X event is received at a very specific point in time, it can trigger
a race condition in Xlib. Said event will be read, but Xlib will
nonetheless be completely unaware of the event.
This cause compton to sometimes block on select() while there are events
ready to be processed. If the event is a damage report, screen freeze
will happen until some other event is received.
The proper fix is to switch to xcb for event handling, thus avoid this
problem entirely.
* Move code around
* Remove unneeded forward declaration
* Rename win->damaged to win->ever_damaged, to be less confusing
* Expose debug functions even when DEBUG is not enabled. Compiler
would remove the dead code for us anyway.
* Some code cleanup
Also move static function prototypes out of compton.h. Seems like the
previous developers didn't know what header files are for.
Seems to have bugs after the split.
Under extreme race conditions (window A close at the same time as window
B create), there can be multiple windows with same id in compton's window
list. If at this point window B closes itself as well, finish_destroy_win
might destroy a different window as what's passed to destroy_callback.
This can be a problem because someone can still hold a reference to that
window (e.g. 't' in paint_preprocess), and there's no way to clear that
reference. If finish_destroy_win always destroy the same window passed
to destroy_callback, this will not be a problem.
- Remove the const function attribute from get_time_*(), since the
functions they call that actually get the time probably access global
variables or have other behaviors unacceptable for const functions.
- Change the const function attribute on win_has_frame() to pure, as it
accesses memory its parameter points to, which is invalid for a const
function.
Bug fix: Select the larger of the X window border width and
_NET_FRAME_EXTENTS, instead of adding them together, when determining
the frame extents. (Supposedly) more EWMH compliant, as EWMH
_NET_FRAME_EXTENTS should include the X window border width already. We
did not choose to completely rely on _NET_FRAME_EXTENTS to remove the
need to keep track of whether there is a _NET_FRAME_EXTENTS, and
(hopefully) take care of some cases when it is wrong. The commit should
fix awesomeWM/awesome#425. Thanks to psychon for the information. (#302)
The commit fixes the bug in win_get_region_noframe() that the X window
border width is not considered when determining the width/height of the
window without frame, as well.
- Add margin_t, a structure that represents margins around a rectangle.
- Store frame extents of a window with margin_t, replacing the 4
fields ({left,right,top,bottom}_width) in struct _win.
- Add two helper macros, cmemzero() and cmemzero_one(), that zero out a
block of memory.
- Separate GLX parts from session_t into glx_session_t.
- Add --rererdir-on-root-change and --glx-reinit-on-root-change, as
possible solutions for #217. Thanks to jlindgren90 for reporting.
- Add --glx-fshader-win, which specifies a custom fragment shader for
painting windows. compton-default-fshader-win.glsl is the shader with
default behavior, and compton-fake-transparency-fshader-win.glsl
provides a template of fake transparency. (#183)
- Add --force-win-blend to force all windows to be painted with
blending.
- Add --no-fading-destroyed-argb, as a workaround of bugs in some WMs.
(#193)
- Add --xrender-sync{,-fence} to deal with redraw lag issue on GLX
backend. --xrender-sync-fence requires a sufficiently new xorg-server
and libXext. NO_XSYNC=1 may be used to disable it at compile time.
Thanks to tchebb for reporting and everybody else for testing. (#181)
- A bit code clean-up. Replace a few XSync() with XFlush() to minimize
the latency.
- Add new backend "xr_glx_hybird", which uses X Render for all
compositing but GLX on the last step of rendering to screen. This
makes GLX-backend-specific VSync methods usable while may avoid
certain bugs with GLX backend. The idea comes from ali1234.
Experimental.
- GLX backend: Stop using or rendering to depth buffer.
- Use glFinish() instead of glFlush() before VSync. It probably uses
more CPU but could be more reliable than glFlush().
Yuxuan Shui