dwm picom added
This commit is contained in:
wt committed
1 parent
471b6062af
commit
964ff4b2c7
132 files changed
+32922
No files matched your search
@@ -0,0 +1,28 @@
|
||||
image: freebsd/latest
|
||||
packages:
|
||||
- libev
|
||||
- libXext
|
||||
- libxcb
|
||||
- meson
|
||||
- pkgconf
|
||||
- cmake
|
||||
- xcb-util-renderutil
|
||||
- xcb-util-image
|
||||
- pixman
|
||||
- uthash
|
||||
- libconfig
|
||||
- libglvnd
|
||||
- dbus
|
||||
- pcre
|
||||
sources:
|
||||
- https://github.com/yshui/picom
|
||||
tasks:
|
||||
- setup: |
|
||||
cd picom
|
||||
CPPFLAGS="-I/usr/local/include" meson -Dunittest=true build
|
||||
- build: |
|
||||
cd picom
|
||||
ninja -C build
|
||||
- unittest: |
|
||||
cd picom
|
||||
ninja -C build test
|
||||
@@ -0,0 +1,135 @@
|
||||
executors:
|
||||
e:
|
||||
docker:
|
||||
- image: yshui/comptonci
|
||||
working_directory: "/tmp/workspace"
|
||||
environment:
|
||||
UBSAN_OPTIONS: "halt_on_error=1"
|
||||
|
||||
version: 2.1
|
||||
commands:
|
||||
build:
|
||||
parameters:
|
||||
build-config:
|
||||
type: string
|
||||
default: ""
|
||||
cc:
|
||||
type: string
|
||||
default: cc
|
||||
steps:
|
||||
- restore_cache:
|
||||
keys:
|
||||
- source-v1-{{ .Branch }}-{{ .Revision }}
|
||||
- source-v1-{{ .Branch }}-
|
||||
- source-v1-
|
||||
- checkout
|
||||
- save_cache:
|
||||
key: source-v1-{{ .Branch }}-{{ .Revision }}
|
||||
paths:
|
||||
- ".git"
|
||||
- run:
|
||||
name: config
|
||||
command: CC=<< parameters.cc >> meson << parameters.build-config >> -Dunittest=true --werror . build
|
||||
- run:
|
||||
name: build
|
||||
command: ninja -vC build
|
||||
|
||||
jobs:
|
||||
basic:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
build-config: -Dwith_docs=true -Db_coverage=true
|
||||
- persist_to_workspace:
|
||||
root: .
|
||||
paths:
|
||||
- .
|
||||
test:
|
||||
executor: e
|
||||
steps:
|
||||
- attach_workspace:
|
||||
at: /tmp/workspace
|
||||
- run:
|
||||
name: unit test
|
||||
command: ninja -vC build test
|
||||
- run:
|
||||
name: test config file parsing
|
||||
command: xvfb-run -s "-screen 0 640x480x24" build/src/picom --config picom.sample.conf --no-vsync --diagnostics
|
||||
- run:
|
||||
name: run testsuite
|
||||
command: tests/run_tests.sh build/src/picom
|
||||
- run:
|
||||
name: generate coverage reports
|
||||
command: cd build; find -name '*.gcno' -exec gcov -pb {} +
|
||||
- run:
|
||||
name: download codecov scripts
|
||||
command: curl -s https://codecov.io/bash > codecov.sh
|
||||
- run:
|
||||
name: upload coverage reports
|
||||
command: bash ./codecov.sh -X gcov
|
||||
|
||||
minimal:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
build-config: -Dopengl=false -Ddbus=false -Dregex=false -Dconfig_file=false
|
||||
release:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
build-config: --buildtype=release
|
||||
release-clang:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
cc: clang
|
||||
build-config: --buildtype=release
|
||||
nogl:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
build-config: -Dopengl=false
|
||||
noregex:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
build-config: -Dregex=false
|
||||
clang_basic:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
cc: clang
|
||||
clang_minimal:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
cc: clang
|
||||
build-config: -Dopengl=false -Ddbus=false -Dregex=false -Dconfig_file=false
|
||||
clang_nogl:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
cc: clang
|
||||
build-config: -Dopengl=false
|
||||
clang_noregex:
|
||||
executor: e
|
||||
steps:
|
||||
- build:
|
||||
cc: clang
|
||||
build-config: -Dregex=false
|
||||
|
||||
workflows:
|
||||
all_builds:
|
||||
jobs:
|
||||
- basic
|
||||
- clang_basic
|
||||
- minimal
|
||||
- clang_minimal
|
||||
- nogl
|
||||
- clang_nogl
|
||||
- release
|
||||
- release-clang
|
||||
- test:
|
||||
requires:
|
||||
- basic
|
||||
# vim: set sw=2 ts=8 et:
|
||||
@@ -0,0 +1,38 @@
|
||||
BasedOnStyle: LLVM
|
||||
TabWidth: 8
|
||||
UseTab: ForIndentation
|
||||
BreakBeforeBraces: Attach
|
||||
#BreakStringLiterals: true
|
||||
IndentWidth: 8
|
||||
AlignAfterOpenBracket: Align
|
||||
ColumnLimit: 90
|
||||
#ExperimentalAutoDetectBinPacking: true
|
||||
BinPackArguments: true
|
||||
BinPackParameters: true
|
||||
#ReflowComments: true
|
||||
AlignTrailingComments: true
|
||||
SpacesBeforeTrailingComments: 8
|
||||
SpaceBeforeAssignmentOperators: true
|
||||
SpaceBeforeParens: ControlStatements
|
||||
AllowShortIfStatementsOnASingleLine: false
|
||||
AllowShortCaseLabelsOnASingleLine: true
|
||||
AllowShortFunctionsOnASingleLine: false
|
||||
IndentCaseLabels: false
|
||||
IndentPPDirectives: None
|
||||
PenaltyReturnTypeOnItsOwnLine: 0
|
||||
PenaltyBreakAssignment: 0
|
||||
PenaltyBreakBeforeFirstCallParameter: 1
|
||||
PenaltyBreakComment: 1
|
||||
PenaltyBreakString: 36
|
||||
PenaltyExcessCharacter: 3
|
||||
PenaltyBreakFirstLessLess: 0
|
||||
PenaltyBreakTemplateDeclaration: 0
|
||||
BreakBeforeBinaryOperators: None
|
||||
IncludeCategories:
|
||||
- Regex: '<.*\.h>'
|
||||
Priority: 1
|
||||
- Regex: '".*\.h"'
|
||||
Priority: 2
|
||||
SortIncludes: true
|
||||
#ForEachMacros: [ list_for_each_entry, list_for_each_entry_safe, HASH_ITER ]
|
||||
#AlignConsecutiveAssignments: true
|
||||
@@ -0,0 +1,21 @@
|
||||
Checks: >
|
||||
readability-*,
|
||||
performance-*,
|
||||
modernize-*,
|
||||
google-readability-todo,
|
||||
cert-err34-c,
|
||||
cert-flp30-c,
|
||||
bugprone-*,
|
||||
misc-misplaced-const,
|
||||
misc-redundant-expression,
|
||||
misc-static-assert,
|
||||
-clang-analyzer-*,
|
||||
-readability-isolate-declaration,
|
||||
-readability-magic-numbers
|
||||
AnalyzeTemporaryDtors: false
|
||||
FormatStyle: file
|
||||
CheckOptions:
|
||||
- key: readability-magic-numbers.IgnoredIntegerValues
|
||||
value: 4;8;16;24;32;1;2;3;4096;65536;
|
||||
- key: readability-magic-numbers.IgnoredFloatingPointValues
|
||||
value: 255.0;1.0;
|
||||
@@ -0,0 +1,5 @@
|
||||
root = true
|
||||
[*.{c,h}]
|
||||
indent_style = tab
|
||||
indent_size = 8
|
||||
max_line_length = 90
|
||||
Vendored
+57
@@ -0,0 +1,57 @@
|
||||
<!-- The template below is for reporting bugs. For feature requests and others, feel free to delete irrelevant entries. -->
|
||||
|
||||
### Platform
|
||||
<!-- Example: Ubuntu Desktop 17.04 amd64 -->
|
||||
|
||||
### GPU, drivers, and screen setup
|
||||
<!--
|
||||
Example: NVidia GTX 670, nvidia-drivers 381.09, two monitors configured side-by-side with xrandr
|
||||
Please include the version of the video drivers (xf86-video-*) and mesa.
|
||||
Please also paste the output of `glxinfo -B` here.
|
||||
-->
|
||||
|
||||
### Environment
|
||||
<!-- Tell us something about the desktop environment you are using, for example: i3-gaps, Gnome Shell, etc. -->
|
||||
|
||||
### picom version
|
||||
<!-- Put the output of `picom --version` here. -->
|
||||
<!-- Example: v8.2 -->
|
||||
<details>
|
||||
<summary>Diagnostics</summary>
|
||||
|
||||
<!-- Please also include the output of `picom --diagnostics` -->
|
||||
</details>
|
||||
|
||||
### Configuration:
|
||||
<details>
|
||||
<summary>Configuration file</summary>
|
||||
|
||||
```
|
||||
// Paste your configuration here
|
||||
```
|
||||
</details>
|
||||
|
||||
### Steps of reproduction
|
||||
<!--
|
||||
If you can reliably reproduce this bug, please describe the quickest way to do so
|
||||
This information will greatly help us diagnosing and fixing the issue.
|
||||
-->
|
||||
|
||||
1.
|
||||
2.
|
||||
|
||||
### Expected behavior
|
||||
|
||||
### Current Behavior
|
||||
|
||||
### Stack trace
|
||||
<!--
|
||||
If the compositor crashes, please make sure you built it with debug info, and provide a stack trace captured when it crashed.
|
||||
Note, when the compositor crashes in a debugger, your screen might look frozen. But gdb will likely still handle your input if it is focused.
|
||||
Often you can use 'bt' and press enter to get the stack trace, then 'q', enter, 'y', enter to quit gdb.
|
||||
-->
|
||||
|
||||
<!-- Or, you can enable core dump, and upload the core file with the corresponding executable here. -->
|
||||
|
||||
### Other details
|
||||
<!-- If your problem is visual, you are encouraged to record a short video when the problem occurs and link to it here. -->
|
||||
+1
@@ -0,0 +1 @@
|
||||
<!-- Please enable "Allow edits from maintainers" so we can make necessary changes to your PR -->
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
name: "CodeQL"
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [next]
|
||||
pull_request:
|
||||
branches: [next]
|
||||
|
||||
jobs:
|
||||
analyze:
|
||||
name: Analyze
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: ['cpp', 'python']
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v2
|
||||
with:
|
||||
# We must fetch at least the immediate parents so that if this is
|
||||
# a pull request then we can checkout the head.
|
||||
fetch-depth: 2
|
||||
|
||||
# If this run was triggered by a pull request event, then checkout
|
||||
# the head of the pull request instead of the merge commit.
|
||||
- run: git checkout HEAD^2
|
||||
if: ${{ github.event_name == 'pull_request' }}
|
||||
|
||||
# Initializes the CodeQL tools for scanning.
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v1
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
|
||||
# Install dependencies
|
||||
- run: sudo apt update && sudo apt install libxext-dev libxcb1-dev libxcb-damage0-dev libxcb-xfixes0-dev libxcb-shape0-dev libxcb-render-util0-dev libxcb-render0-dev libxcb-randr0-dev libxcb-composite0-dev libxcb-image0-dev libxcb-present-dev libxcb-xinerama0-dev libxcb-glx0-dev libpixman-1-dev libdbus-1-dev libconfig-dev libgl1-mesa-dev libpcre2-dev libevdev-dev uthash-dev libev-dev libx11-xcb-dev meson ninja-build
|
||||
if: ${{ matrix.language == 'cpp' }}
|
||||
|
||||
# Autobuild
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v1
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v1
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
name: coding-style
|
||||
on: pull_request
|
||||
|
||||
jobs:
|
||||
check:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- run: git fetch --depth=1 origin ${{ github.event.pull_request.base.sha }}
|
||||
- uses: yshui/git-clang-format-lint@v1.11
|
||||
with:
|
||||
base: ${{ github.event.pull_request.base.sha }}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
name: coding-style
|
||||
on: push
|
||||
|
||||
jobs:
|
||||
check:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
with:
|
||||
fetch-depth: 2
|
||||
- uses: yshui/git-clang-format-lint@v1.12
|
||||
with:
|
||||
base: ${{ github.event.ref }}~1
|
||||
@@ -0,0 +1,58 @@
|
||||
# Build files
|
||||
.deps
|
||||
aclocal.m4
|
||||
autom4te.cache
|
||||
config.log
|
||||
config.status
|
||||
configure
|
||||
depcomp
|
||||
install-sh
|
||||
missing
|
||||
stamp-h1
|
||||
compton
|
||||
*.o
|
||||
*.d
|
||||
build/
|
||||
compile_commands.json
|
||||
build.ninja
|
||||
|
||||
# language servers
|
||||
.ccls-cache
|
||||
.clangd
|
||||
.cache
|
||||
|
||||
# CMake files
|
||||
compton-*.deb
|
||||
compton-*.rpm
|
||||
compton-*.tar.bz2
|
||||
release/
|
||||
_CPack_Packages/
|
||||
CMakeCache.txt
|
||||
CMakeFiles/
|
||||
cmake_install.cmake
|
||||
CPackSourceConfig.cmake
|
||||
install_manifest.txt
|
||||
|
||||
|
||||
# Vim files
|
||||
.sw[a-z]
|
||||
.*.sw[a-z]
|
||||
*~
|
||||
|
||||
# Misc files
|
||||
core.*
|
||||
.gdb_history
|
||||
oprofile_data/
|
||||
compton.plist
|
||||
callgrind.out.*
|
||||
man/*.html
|
||||
man/*.1
|
||||
doxygen/
|
||||
.clang_complete
|
||||
.ycm_extra_conf.py
|
||||
.ycm_extra_conf.pyc
|
||||
/src/backtrace-symbols.[ch]
|
||||
/compton*.trace
|
||||
*.orig
|
||||
/tests/log
|
||||
/tests/testcases/__pycache__/
|
||||
Whitespace-only changes.
@@ -0,0 +1,85 @@
|
||||
Sorted in alphabetical order
|
||||
Open an issue or pull request if you don't want your name listed here.
|
||||
|
||||
Adam Jackson <ajax@nwnk.net>
|
||||
adelin-b <berard.adelin@gmail.com>
|
||||
Alexander Kapshuna <kapsh@kap.sh>
|
||||
Antonin Décimo <antonin.decimo@gmail.com>
|
||||
Antonio Vivace <dev@avivace.com>
|
||||
Avi-D-coder <avi.the.coder@gmail.com>
|
||||
Ben Friesen <bfriesen95@gmail.com>
|
||||
Bernd Busse <bernd@busse-net.de>
|
||||
Bert Gijsbers <gijsbers@science.uva.nl>
|
||||
bhagwan <bhagwan@disroot.org>
|
||||
Bodhi <craig.langman@gmail.com>
|
||||
Brottweiler <tibell.christoffer@gmail.com>
|
||||
Carl Worth <cworth@cworth.org>
|
||||
Christopher Jeffrey <chjjeffrey@gmail.com>
|
||||
Corax26 <cor.ax26@gmail.com>
|
||||
Dan Elkouby <streetwalkermc@gmail.com>
|
||||
Dana Jansens <danakj@orodu.net>
|
||||
Daniel Kwan <daniel.w.t.kwan@outlook.com>
|
||||
Dave Airlie <airlied@linux.ie>
|
||||
David Schlachter
|
||||
dolio
|
||||
Duncan <duncan.britton@outlook.com>
|
||||
Dylan Araps <dylan.araps@gmail.com>
|
||||
Einar Lielmanis <einars@gmail.com>
|
||||
Eric Anholt <anholt@freebsd.org> <eric@anholt.net>
|
||||
Greg Flynn
|
||||
Harish Rajagopal <harish.rajagopals@gmail.com>
|
||||
hasufell <julian.ospald@googlemail.com>
|
||||
Ignacio Taranto <ignacio.taranto@eclypsium.com>
|
||||
Istvan Petres
|
||||
James Cloos <cloos@jhcloos.com>
|
||||
Jamey Sharp <jamey@minilop.net>
|
||||
Jan Beich <jbeich@FreeBSD.org>
|
||||
Jarrad <jarrad.whitaker@gmail.com>
|
||||
Javeed Shaikh <syscrash2k@gmail.com>
|
||||
Jerónimo Navarro <jnavarro@ancasrl.com.ar>
|
||||
jialeens <jialeadmin@163.com>
|
||||
Johnny Pribyl <pribylsnbits@gmail.com>
|
||||
Keith Packard <keithp@keithp.com>
|
||||
Kevin Kelley <kelleyk@kelleyk.net>
|
||||
ktprograms <ktprograms@gmail.com>
|
||||
Lukas Schmelzeisen <l.schmelzeisen@gmx.de>
|
||||
mæp <m.aep@live.com>
|
||||
Mark Tiefenbruck <mark@fluxbox.org>
|
||||
Matthew Allum <breakfast@10.am>
|
||||
Maxim Solovyov <visleaf@protonmail.com>
|
||||
Michael Reed <supertron421@gmail.com>
|
||||
Michele Lambertucci <michele.lambertucci@mail.polimi.it>
|
||||
Namkhai Bourquin <namkhai.n3@protonmail.com>
|
||||
Nate Hart <nejthan@gmail.com>
|
||||
nia <nia@netbsd.org>
|
||||
notfoss <static.vortex@gmx.com>
|
||||
Omar Polo <op@omarpolo.com>
|
||||
orbea <orbea@riseup.net>
|
||||
@Paradigm0001
|
||||
Patrick Collins
|
||||
Peter Mattern <matternp@arcor.de>
|
||||
Phil Blundell <pb@reciva.com>
|
||||
Que Quotion <quequotion@bugmenot.com> <the_q123@hotmail.com>
|
||||
Rafael Kitover <rkitover@gmail.com>
|
||||
Richard Grenville <pyxlcy@gmail.com>
|
||||
Rytis Karpuska <rytis.karpuska@gmail.com>
|
||||
Samuel Hand <samuel.d.hand@gmail.com>
|
||||
Scott Leggett <scott@sl.id.au>
|
||||
scrouthtv <lennivh24@gmail.com>
|
||||
Sebastien Waegeneire <sebastien@waegeneire.com>
|
||||
Subhaditya Nath <sn03.general@gmail.com>
|
||||
Tasos Sahanidis <tasos@tasossah.com>
|
||||
Thiago Kenji Okada <thiagokokada@gmail.com>
|
||||
Tilman Sauerbeck <tilman@code-monkey.de>
|
||||
Tim van Dalen <Tim@timvdalen.nl>
|
||||
Tomas Janousek <tomi@nomi.cz>
|
||||
Tom Dörr <tomdoerr96@gmail.com>
|
||||
Toni Jarjour
|
||||
Tuomas Kinnunen <tuomas.kinnunen@aalto.fi>
|
||||
Uli Schlachter <psychon@znc.in>
|
||||
Walter Lapchynski <wxl@ubuntu.com>
|
||||
Will Dietz <w@wdtz.org>
|
||||
XeCycle <XeCycle@Gmail.com>
|
||||
Yuxuan Shui <yshuiv7@gmail.com>
|
||||
zilrich
|
||||
ಠ_ಠ <easteregg@verfriemelt.org>
|
||||
@@ -0,0 +1,20 @@
|
||||
picom - a compositor for X11
|
||||
|
||||
Based on xcompmgr, originally written by Keith Packard, with modifications
|
||||
from several contributors (according to the xcompmgr man page): Matthew Allum,
|
||||
Eric Anholt, Dan Doel, Thomas Luebking, Matthew Hawn, Ely Levy, Phil Blundell,
|
||||
and Carl Worth. Menu transparency was implemented by Dana Jansens.
|
||||
|
||||
Numerous contributions to picom from Richard Grenville.
|
||||
|
||||
See the CONTRIBUTORS file for a complete list of contributors
|
||||
|
||||
This source code is provided under:
|
||||
|
||||
SPDX-License-Identifier: MPL-2.0 AND MIT
|
||||
|
||||
And the preferred license for new source files in this project is:
|
||||
|
||||
SPDX-License-Identifier: MPL-2.0
|
||||
|
||||
You can find the text of the licenses in the LICENSES directory.
|
||||
+1808
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,156 @@
|
||||
# Picom History
|
||||
|
||||
Picom was forked in 2016 from the original Compton because it seemed to have become unmaintained.
|
||||
|
||||
The battle plan of the fork was to refactor it to make the code _possible_ to maintain, so potential contributors won't be scared away when they take a look at the code.
|
||||
|
||||
And also to try to fix bugs.
|
||||
|
||||
## Rename
|
||||
|
||||
In 2019 the project name was changed from Compton to picom (git revision 8ddbeb and following).
|
||||
|
||||
### Rationale
|
||||
|
||||
Since the inception of this fork, the existence of two compton repositories has caused some number of confusions. Mainly, people will report issues of this fork to the original compton, or report issues of the original compton here. Later, when distros started packaging this fork of compton, some wanted to differentiate the newer compton from the older version. They found themselves having no choice but to invent a name for this fork. This is less than ideal since this has the potential to cause more confusions among users.
|
||||
|
||||
Therefore, we decided to move this fork to a new name. Personally, I consider this more than justified since this version of compton has gone through significant changes since it was forked.
|
||||
|
||||
### The name
|
||||
|
||||
The criteria for a good name were
|
||||
|
||||
0. Being short, so it's easy to remember.
|
||||
1. Pronounceability, again, helps memorability
|
||||
2. Searchability, so when people search the name, it's easy for them to find this repository.
|
||||
|
||||
Of course, choosing a name is never easy, and there is no apparent way to objectively evaluate the names. Yet, we have to solve the aforementioned problems as soon as possible.
|
||||
|
||||
In the end, we picked `picom` (a portmanteau of `pico` and `composite`) as our new name. This name might not be perfect, but is what we will move forward with unless there's a compelling reason not to.
|
||||
|
||||
|
||||
# Compton
|
||||
|
||||
This is a copy of the README of the [original Compton project](https://github.com/chjj/compton/).
|
||||
|
||||
[](https://gitter.im/chjj/compton?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
__Compton__ is a compositor for X, and a fork of __xcompmgr-dana__.
|
||||
|
||||
I was frustrated by the low amount of standalone lightweight compositors.
|
||||
Compton was forked from Dana Jansens' fork of xcompmgr and refactored. I fixed
|
||||
whatever bug I found, and added features I wanted. Things seem stable, but don't
|
||||
quote me on it. I will most likely be actively working on this until I get the
|
||||
features I want. This is also a learning experience for me. That is, I'm
|
||||
partially doing this out of a desire to learn Xlib.
|
||||
|
||||
## Changes from xcompmgr:
|
||||
|
||||
* OpenGL backend (`--backend glx`), in addition to the old X Render backend.
|
||||
* Inactive window transparency (`-i`) / dimming (`--inactive-dim`).
|
||||
* Titlebar/frame transparency (`-e`).
|
||||
* Menu transparency (`-m`, thanks to Dana).
|
||||
* shadows are now enabled for argb windows, e.g. terminals with transparency
|
||||
* removed serverside shadows (and simple compositing) to clean the code,
|
||||
the only option that remains is clientside shadows
|
||||
* configuration files (see the man page for more details)
|
||||
* colored shadows (`--shadow-[red/green/blue]`)
|
||||
* a new fade system
|
||||
* VSync support (not always working)
|
||||
* Blur of background of transparent windows, window color inversion (bad in performance)
|
||||
* Some more options...
|
||||
|
||||
## Fixes from the original xcompmgr:
|
||||
|
||||
* fixed a segfault when opening certain window types
|
||||
* fixed a memory leak caused by not freeing up shadows (from the freedesktop
|
||||
repo)
|
||||
* fixed the conflict with chromium and similar windows
|
||||
* [many more](https://github.com/chjj/compton/issues)
|
||||
|
||||
## Building
|
||||
|
||||
### Dependencies:
|
||||
|
||||
__B__ for build-time
|
||||
|
||||
__R__ for runtime
|
||||
|
||||
* libx11 (B,R)
|
||||
* libxcomposite (B,R)
|
||||
* libxdamage (B,R)
|
||||
* libxfixes (B,R)
|
||||
* libXext (B,R)
|
||||
* libxrender (B,R)
|
||||
* libXrandr (B,R)
|
||||
* libXinerama (B,R) (Can be disabled with `NO_XINERAMA` at compile time)
|
||||
* pkg-config (B)
|
||||
* make (B)
|
||||
* xproto / x11proto (B)
|
||||
* sh (R)
|
||||
* xprop,xwininfo / x11-utils (R)
|
||||
* libpcre (B,R) (Can be disabled with `NO_REGEX_PCRE` at compile time)
|
||||
* libconfig (B,R) (Can be disabled with `NO_LIBCONFIG` at compile time)
|
||||
* libdrm (B) (Can be disabled with `NO_VSYNC_DRM` at compile time)
|
||||
* libGL (B,R) (Can be disabled with `NO_VSYNC_OPENGL` at compile time)
|
||||
* libdbus (B,R) (Can be disabled with `NO_DBUS` at compile time)
|
||||
* asciidoc (B) (and docbook-xml-dtd-4.5, libxml-utils, libxslt, xsltproc, xmlto, etc. if your distro doesn't pull them in)
|
||||
|
||||
### How to build
|
||||
|
||||
To build, make sure you have the dependencies above:
|
||||
|
||||
```bash
|
||||
# Make the main program
|
||||
$ make
|
||||
# Make the man pages
|
||||
$ make docs
|
||||
# Install
|
||||
$ make install
|
||||
```
|
||||
|
||||
(Compton does include a `_CMakeLists.txt` in the tree, but we haven't decided whether we should switch to CMake yet. The `Makefile` is fully usable right now.)
|
||||
|
||||
## Known issues
|
||||
|
||||
* Our [FAQ](https://github.com/chjj/compton/wiki/faq) covers some known issues.
|
||||
|
||||
* VSync does not work too well. You may check the [VSync Guide](https://github.com/chjj/compton/wiki/vsync-guide) for how to get (possibly) better effects.
|
||||
|
||||
* If `--unredir-if-possible` is enabled, when compton redirects/unredirects windows, the screen may flicker. Using `--paint-on-overlay` minimizes the problem from my observation, yet I do not know if there's a cure.
|
||||
|
||||
* compton may not track focus correctly in all situations. The focus tracking code is experimental. `--use-ewmh-active-win` might be helpful.
|
||||
|
||||
* The performance of blur under X Render backend might be pretty bad. OpenGL backend could be faster.
|
||||
|
||||
* With `--blur-background` you may sometimes see weird lines around damaged area. `--resize-damage YOUR_BLUR_RADIUS` might be helpful in the case.
|
||||
|
||||
## Usage
|
||||
|
||||
Please refer to the Asciidoc man pages (`man/compton.1.asciidoc` & `man/compton-trans.1.asciidoc`) for more details and examples.
|
||||
|
||||
Note a sample configuration file `compton.sample.conf` is included in the repository.
|
||||
|
||||
## Support
|
||||
|
||||
* Bug reports and feature requests should go to the "Issues" section above.
|
||||
|
||||
* Our (semi?) official IRC channel is #compton on FreeNode.
|
||||
|
||||
* Some information is available on the wiki, including [FAQ](https://github.com/chjj/compton/wiki/faq), [VSync Guide](https://github.com/chjj/compton/wiki/vsync-guide), and [Performance Guide](https://github.com/chjj/compton/wiki/perf-guide).
|
||||
|
||||
## License
|
||||
|
||||
Although compton has kind of taken on a life of its own, it was originally
|
||||
an xcompmgr fork. xcompmgr has gotten around. As far as I can tell, the lineage
|
||||
for this particular tree is something like:
|
||||
|
||||
* Keith Packard (original author)
|
||||
* Matthew Hawn
|
||||
* ...
|
||||
* Dana Jansens
|
||||
* chjj and richardgv
|
||||
|
||||
Not counting the tens of people who forked it in between.
|
||||
|
||||
Compton is distributed under MIT license, as far as I (richardgv) know. See LICENSE for more info.
|
||||
@@ -0,0 +1,4 @@
|
||||
SPDXVersion: SPDX-2.1
|
||||
DataLicense: CC0-1.0
|
||||
PackageName: picom
|
||||
PackageLicenseDeclared: MPL-2.0 AND MIT
|
||||
@@ -0,0 +1,5 @@
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -0,0 +1,373 @@
|
||||
Mozilla Public License Version 2.0
|
||||
==================================
|
||||
|
||||
1. Definitions
|
||||
--------------
|
||||
|
||||
1.1. "Contributor"
|
||||
means each individual or legal entity that creates, contributes to
|
||||
the creation of, or owns Covered Software.
|
||||
|
||||
1.2. "Contributor Version"
|
||||
means the combination of the Contributions of others (if any) used
|
||||
by a Contributor and that particular Contributor's Contribution.
|
||||
|
||||
1.3. "Contribution"
|
||||
means Covered Software of a particular Contributor.
|
||||
|
||||
1.4. "Covered Software"
|
||||
means Source Code Form to which the initial Contributor has attached
|
||||
the notice in Exhibit A, the Executable Form of such Source Code
|
||||
Form, and Modifications of such Source Code Form, in each case
|
||||
including portions thereof.
|
||||
|
||||
1.5. "Incompatible With Secondary Licenses"
|
||||
means
|
||||
|
||||
(a) that the initial Contributor has attached the notice described
|
||||
in Exhibit B to the Covered Software; or
|
||||
|
||||
(b) that the Covered Software was made available under the terms of
|
||||
version 1.1 or earlier of the License, but not also under the
|
||||
terms of a Secondary License.
|
||||
|
||||
1.6. "Executable Form"
|
||||
means any form of the work other than Source Code Form.
|
||||
|
||||
1.7. "Larger Work"
|
||||
means a work that combines Covered Software with other material, in
|
||||
a separate file or files, that is not Covered Software.
|
||||
|
||||
1.8. "License"
|
||||
means this document.
|
||||
|
||||
1.9. "Licensable"
|
||||
means having the right to grant, to the maximum extent possible,
|
||||
whether at the time of the initial grant or subsequently, any and
|
||||
all of the rights conveyed by this License.
|
||||
|
||||
1.10. "Modifications"
|
||||
means any of the following:
|
||||
|
||||
(a) any file in Source Code Form that results from an addition to,
|
||||
deletion from, or modification of the contents of Covered
|
||||
Software; or
|
||||
|
||||
(b) any new file in Source Code Form that contains any Covered
|
||||
Software.
|
||||
|
||||
1.11. "Patent Claims" of a Contributor
|
||||
means any patent claim(s), including without limitation, method,
|
||||
process, and apparatus claims, in any patent Licensable by such
|
||||
Contributor that would be infringed, but for the grant of the
|
||||
License, by the making, using, selling, offering for sale, having
|
||||
made, import, or transfer of either its Contributions or its
|
||||
Contributor Version.
|
||||
|
||||
1.12. "Secondary License"
|
||||
means either the GNU General Public License, Version 2.0, the GNU
|
||||
Lesser General Public License, Version 2.1, the GNU Affero General
|
||||
Public License, Version 3.0, or any later versions of those
|
||||
licenses.
|
||||
|
||||
1.13. "Source Code Form"
|
||||
means the form of the work preferred for making modifications.
|
||||
|
||||
1.14. "You" (or "Your")
|
||||
means an individual or a legal entity exercising rights under this
|
||||
License. For legal entities, "You" includes any entity that
|
||||
controls, is controlled by, or is under common control with You. For
|
||||
purposes of this definition, "control" means (a) the power, direct
|
||||
or indirect, to cause the direction or management of such entity,
|
||||
whether by contract or otherwise, or (b) ownership of more than
|
||||
fifty percent (50%) of the outstanding shares or beneficial
|
||||
ownership of such entity.
|
||||
|
||||
2. License Grants and Conditions
|
||||
--------------------------------
|
||||
|
||||
2.1. Grants
|
||||
|
||||
Each Contributor hereby grants You a world-wide, royalty-free,
|
||||
non-exclusive license:
|
||||
|
||||
(a) under intellectual property rights (other than patent or trademark)
|
||||
Licensable by such Contributor to use, reproduce, make available,
|
||||
modify, display, perform, distribute, and otherwise exploit its
|
||||
Contributions, either on an unmodified basis, with Modifications, or
|
||||
as part of a Larger Work; and
|
||||
|
||||
(b) under Patent Claims of such Contributor to make, use, sell, offer
|
||||
for sale, have made, import, and otherwise transfer either its
|
||||
Contributions or its Contributor Version.
|
||||
|
||||
2.2. Effective Date
|
||||
|
||||
The licenses granted in Section 2.1 with respect to any Contribution
|
||||
become effective for each Contribution on the date the Contributor first
|
||||
distributes such Contribution.
|
||||
|
||||
2.3. Limitations on Grant Scope
|
||||
|
||||
The licenses granted in this Section 2 are the only rights granted under
|
||||
this License. No additional rights or licenses will be implied from the
|
||||
distribution or licensing of Covered Software under this License.
|
||||
Notwithstanding Section 2.1(b) above, no patent license is granted by a
|
||||
Contributor:
|
||||
|
||||
(a) for any code that a Contributor has removed from Covered Software;
|
||||
or
|
||||
|
||||
(b) for infringements caused by: (i) Your and any other third party's
|
||||
modifications of Covered Software, or (ii) the combination of its
|
||||
Contributions with other software (except as part of its Contributor
|
||||
Version); or
|
||||
|
||||
(c) under Patent Claims infringed by Covered Software in the absence of
|
||||
its Contributions.
|
||||
|
||||
This License does not grant any rights in the trademarks, service marks,
|
||||
or logos of any Contributor (except as may be necessary to comply with
|
||||
the notice requirements in Section 3.4).
|
||||
|
||||
2.4. Subsequent Licenses
|
||||
|
||||
No Contributor makes additional grants as a result of Your choice to
|
||||
distribute the Covered Software under a subsequent version of this
|
||||
License (see Section 10.2) or under the terms of a Secondary License (if
|
||||
permitted under the terms of Section 3.3).
|
||||
|
||||
2.5. Representation
|
||||
|
||||
Each Contributor represents that the Contributor believes its
|
||||
Contributions are its original creation(s) or it has sufficient rights
|
||||
to grant the rights to its Contributions conveyed by this License.
|
||||
|
||||
2.6. Fair Use
|
||||
|
||||
This License is not intended to limit any rights You have under
|
||||
applicable copyright doctrines of fair use, fair dealing, or other
|
||||
equivalents.
|
||||
|
||||
2.7. Conditions
|
||||
|
||||
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
|
||||
in Section 2.1.
|
||||
|
||||
3. Responsibilities
|
||||
-------------------
|
||||
|
||||
3.1. Distribution of Source Form
|
||||
|
||||
All distribution of Covered Software in Source Code Form, including any
|
||||
Modifications that You create or to which You contribute, must be under
|
||||
the terms of this License. You must inform recipients that the Source
|
||||
Code Form of the Covered Software is governed by the terms of this
|
||||
License, and how they can obtain a copy of this License. You may not
|
||||
attempt to alter or restrict the recipients' rights in the Source Code
|
||||
Form.
|
||||
|
||||
3.2. Distribution of Executable Form
|
||||
|
||||
If You distribute Covered Software in Executable Form then:
|
||||
|
||||
(a) such Covered Software must also be made available in Source Code
|
||||
Form, as described in Section 3.1, and You must inform recipients of
|
||||
the Executable Form how they can obtain a copy of such Source Code
|
||||
Form by reasonable means in a timely manner, at a charge no more
|
||||
than the cost of distribution to the recipient; and
|
||||
|
||||
(b) You may distribute such Executable Form under the terms of this
|
||||
License, or sublicense it under different terms, provided that the
|
||||
license for the Executable Form does not attempt to limit or alter
|
||||
the recipients' rights in the Source Code Form under this License.
|
||||
|
||||
3.3. Distribution of a Larger Work
|
||||
|
||||
You may create and distribute a Larger Work under terms of Your choice,
|
||||
provided that You also comply with the requirements of this License for
|
||||
the Covered Software. If the Larger Work is a combination of Covered
|
||||
Software with a work governed by one or more Secondary Licenses, and the
|
||||
Covered Software is not Incompatible With Secondary Licenses, this
|
||||
License permits You to additionally distribute such Covered Software
|
||||
under the terms of such Secondary License(s), so that the recipient of
|
||||
the Larger Work may, at their option, further distribute the Covered
|
||||
Software under the terms of either this License or such Secondary
|
||||
License(s).
|
||||
|
||||
3.4. Notices
|
||||
|
||||
You may not remove or alter the substance of any license notices
|
||||
(including copyright notices, patent notices, disclaimers of warranty,
|
||||
or limitations of liability) contained within the Source Code Form of
|
||||
the Covered Software, except that You may alter any license notices to
|
||||
the extent required to remedy known factual inaccuracies.
|
||||
|
||||
3.5. Application of Additional Terms
|
||||
|
||||
You may choose to offer, and to charge a fee for, warranty, support,
|
||||
indemnity or liability obligations to one or more recipients of Covered
|
||||
Software. However, You may do so only on Your own behalf, and not on
|
||||
behalf of any Contributor. You must make it absolutely clear that any
|
||||
such warranty, support, indemnity, or liability obligation is offered by
|
||||
You alone, and You hereby agree to indemnify every Contributor for any
|
||||
liability incurred by such Contributor as a result of warranty, support,
|
||||
indemnity or liability terms You offer. You may include additional
|
||||
disclaimers of warranty and limitations of liability specific to any
|
||||
jurisdiction.
|
||||
|
||||
4. Inability to Comply Due to Statute or Regulation
|
||||
---------------------------------------------------
|
||||
|
||||
If it is impossible for You to comply with any of the terms of this
|
||||
License with respect to some or all of the Covered Software due to
|
||||
statute, judicial order, or regulation then You must: (a) comply with
|
||||
the terms of this License to the maximum extent possible; and (b)
|
||||
describe the limitations and the code they affect. Such description must
|
||||
be placed in a text file included with all distributions of the Covered
|
||||
Software under this License. Except to the extent prohibited by statute
|
||||
or regulation, such description must be sufficiently detailed for a
|
||||
recipient of ordinary skill to be able to understand it.
|
||||
|
||||
5. Termination
|
||||
--------------
|
||||
|
||||
5.1. The rights granted under this License will terminate automatically
|
||||
if You fail to comply with any of its terms. However, if You become
|
||||
compliant, then the rights granted under this License from a particular
|
||||
Contributor are reinstated (a) provisionally, unless and until such
|
||||
Contributor explicitly and finally terminates Your grants, and (b) on an
|
||||
ongoing basis, if such Contributor fails to notify You of the
|
||||
non-compliance by some reasonable means prior to 60 days after You have
|
||||
come back into compliance. Moreover, Your grants from a particular
|
||||
Contributor are reinstated on an ongoing basis if such Contributor
|
||||
notifies You of the non-compliance by some reasonable means, this is the
|
||||
first time You have received notice of non-compliance with this License
|
||||
from such Contributor, and You become compliant prior to 30 days after
|
||||
Your receipt of the notice.
|
||||
|
||||
5.2. If You initiate litigation against any entity by asserting a patent
|
||||
infringement claim (excluding declaratory judgment actions,
|
||||
counter-claims, and cross-claims) alleging that a Contributor Version
|
||||
directly or indirectly infringes any patent, then the rights granted to
|
||||
You by any and all Contributors for the Covered Software under Section
|
||||
2.1 of this License shall terminate.
|
||||
|
||||
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
|
||||
end user license agreements (excluding distributors and resellers) which
|
||||
have been validly granted by You or Your distributors under this License
|
||||
prior to termination shall survive termination.
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 6. Disclaimer of Warranty *
|
||||
* ------------------------- *
|
||||
* *
|
||||
* Covered Software is provided under this License on an "as is" *
|
||||
* basis, without warranty of any kind, either expressed, implied, or *
|
||||
* statutory, including, without limitation, warranties that the *
|
||||
* Covered Software is free of defects, merchantable, fit for a *
|
||||
* particular purpose or non-infringing. The entire risk as to the *
|
||||
* quality and performance of the Covered Software is with You. *
|
||||
* Should any Covered Software prove defective in any respect, You *
|
||||
* (not any Contributor) assume the cost of any necessary servicing, *
|
||||
* repair, or correction. This disclaimer of warranty constitutes an *
|
||||
* essential part of this License. No use of any Covered Software is *
|
||||
* authorized under this License except under this disclaimer. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 7. Limitation of Liability *
|
||||
* -------------------------- *
|
||||
* *
|
||||
* Under no circumstances and under no legal theory, whether tort *
|
||||
* (including negligence), contract, or otherwise, shall any *
|
||||
* Contributor, or anyone who distributes Covered Software as *
|
||||
* permitted above, be liable to You for any direct, indirect, *
|
||||
* special, incidental, or consequential damages of any character *
|
||||
* including, without limitation, damages for lost profits, loss of *
|
||||
* goodwill, work stoppage, computer failure or malfunction, or any *
|
||||
* and all other commercial damages or losses, even if such party *
|
||||
* shall have been informed of the possibility of such damages. This *
|
||||
* limitation of liability shall not apply to liability for death or *
|
||||
* personal injury resulting from such party's negligence to the *
|
||||
* extent applicable law prohibits such limitation. Some *
|
||||
* jurisdictions do not allow the exclusion or limitation of *
|
||||
* incidental or consequential damages, so this exclusion and *
|
||||
* limitation may not apply to You. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
8. Litigation
|
||||
-------------
|
||||
|
||||
Any litigation relating to this License may be brought only in the
|
||||
courts of a jurisdiction where the defendant maintains its principal
|
||||
place of business and such litigation shall be governed by laws of that
|
||||
jurisdiction, without reference to its conflict-of-law provisions.
|
||||
Nothing in this Section shall prevent a party's ability to bring
|
||||
cross-claims or counter-claims.
|
||||
|
||||
9. Miscellaneous
|
||||
----------------
|
||||
|
||||
This License represents the complete agreement concerning the subject
|
||||
matter hereof. If any provision of this License is held to be
|
||||
unenforceable, such provision shall be reformed only to the extent
|
||||
necessary to make it enforceable. Any law or regulation which provides
|
||||
that the language of a contract shall be construed against the drafter
|
||||
shall not be used to construe this License against a Contributor.
|
||||
|
||||
10. Versions of the License
|
||||
---------------------------
|
||||
|
||||
10.1. New Versions
|
||||
|
||||
Mozilla Foundation is the license steward. Except as provided in Section
|
||||
10.3, no one other than the license steward has the right to modify or
|
||||
publish new versions of this License. Each version will be given a
|
||||
distinguishing version number.
|
||||
|
||||
10.2. Effect of New Versions
|
||||
|
||||
You may distribute the Covered Software under the terms of the version
|
||||
of the License under which You originally received the Covered Software,
|
||||
or under the terms of any subsequent version published by the license
|
||||
steward.
|
||||
|
||||
10.3. Modified Versions
|
||||
|
||||
If you create software not governed by this License, and you want to
|
||||
create a new license for such software, you may create and use a
|
||||
modified version of this License if you rename the license and remove
|
||||
any references to the name of the license steward (except to note that
|
||||
such modified license differs from this License).
|
||||
|
||||
10.4. Distributing Source Code Form that is Incompatible With Secondary
|
||||
Licenses
|
||||
|
||||
If You choose to distribute Source Code Form that is Incompatible With
|
||||
Secondary Licenses under the terms of this version of the License, the
|
||||
notice described in Exhibit B of this License must be attached.
|
||||
|
||||
Exhibit A - Source Code Form License Notice
|
||||
-------------------------------------------
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla Public
|
||||
License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular
|
||||
file, then You may include the notice in a location (such as a LICENSE
|
||||
file in a relevant directory) where a recipient would be likely to look
|
||||
for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
|
||||
Exhibit B - "Incompatible With Secondary Licenses" Notice
|
||||
---------------------------------------------------------
|
||||
|
||||
This Source Code Form is "Incompatible With Secondary Licenses", as
|
||||
defined by the Mozilla Public License, v. 2.0.
|
||||
@@ -0,0 +1,136 @@
|
||||
picom
|
||||
=====
|
||||
|
||||
__picom__ is a compositor for X, and a [fork of Compton](History.md).
|
||||
|
||||
**This is a development branch, bugs to be expected**
|
||||
|
||||
You can leave your feedback or thoughts in the [discussion tab](https://github.com/yshui/picom/discussions).
|
||||
|
||||
## About this Fork
|
||||
|
||||
Extended animation support (auto, fly-in, zoom, squeeze, slide-up, slide-down, slide-left, slide-right) from original [repo](https://github.com/dccsillag/picom) by @dccsillag, added slide-out, slide-in for workspace switching with [Custom Fluxbox](https://github.com/pijulius/fluxbox/commit/83ee4dbee67a68fe38b0f96431473719e165bf1e) , animation on window type basis (for e.g. make transient windows like "about us" slide down and slide backup to the titlebar of the owner window), animation-exclude list for disabling animations on window/program basis and some fixes.
|
||||
|
||||
Reason: original picom by @yshui [repo](https://github.com/yshui/picom/) didn't have animation support and @dccsillag implementation was the best could find so building uppon his work this repo was made. FYI: looks like original picom will have animation support starting with version 12 but will keep this repo as atm looks like the animation here are smoother/better (of course everyone's own point of view) and had some trouble with the latest picom so till find out the reasons will use this repo personally and everyone is velcome to do so.
|
||||
|
||||
**Would like to thank everyone working on all 3 repos of picom as without their work we (old timers) wouldn't have a good compositor so thank you guys for your hard work/time to keep it updated and maintenanced regularly!**
|
||||
|
||||
**IMPORTANT**: always run picom with `--experimental-backends` argument as otherwise animations won't really look good.
|
||||
|
||||
## Call for testers
|
||||
|
||||
### `--experimental-backends`
|
||||
|
||||
This flag enables the refactored/partially rewritten backends.
|
||||
|
||||
Currently, new backends feature better vsync with the xrender backend and improved input lag with the glx backend (for non-NVIDIA users). The performance should be on par with the old backends.
|
||||
|
||||
New backend features will only be implemented on the new backends from now on, and the old backends will eventually be phased out after the new backends stabilize.
|
||||
|
||||
To test the new backends, add the `--experimental-backends` flag to the command you use to run picom. This flag is not available from the configuration file.
|
||||
|
||||
To report issues with the new backends, please state explicitly you are using the new backends in your report.
|
||||
|
||||
## Change Log
|
||||
|
||||
See [Releases](https://github.com/yshui/picom/releases)
|
||||
|
||||
## Build
|
||||
|
||||
### Dependencies
|
||||
|
||||
Assuming you already have all the usual building tools installed (e.g. gcc, python, meson, ninja, etc.), you still need:
|
||||
|
||||
* libx11
|
||||
* libx11-xcb
|
||||
* libXext
|
||||
* xproto
|
||||
* xcb
|
||||
* xcb-damage
|
||||
* xcb-xfixes
|
||||
* xcb-shape
|
||||
* xcb-renderutil
|
||||
* xcb-render
|
||||
* xcb-randr
|
||||
* xcb-composite
|
||||
* xcb-image
|
||||
* xcb-present
|
||||
* xcb-xinerama
|
||||
* xcb-glx
|
||||
* pixman
|
||||
* libdbus (optional, disable with the `-Ddbus=false` meson configure flag)
|
||||
* libconfig (optional, disable with the `-Dconfig_file=false` meson configure flag)
|
||||
* libGL (optional, disable with the `-Dopengl=false` meson configure flag)
|
||||
* libpcre (optional, disable with the `-Dregex=false` meson configure flag)
|
||||
* libev
|
||||
* uthash
|
||||
|
||||
On Debian based distributions (e.g. Ubuntu), the needed packages are
|
||||
|
||||
```
|
||||
libxext-dev libxcb1-dev libxcb-damage0-dev libxcb-xfixes0-dev libxcb-shape0-dev libxcb-render-util0-dev libxcb-render0-dev libxcb-randr0-dev libxcb-composite0-dev libxcb-image0-dev libxcb-present-dev libxcb-xinerama0-dev libxcb-glx0-dev libpixman-1-dev libdbus-1-dev libconfig-dev libgl1-mesa-dev libpcre2-dev libpcre3-dev libevdev-dev uthash-dev libev-dev libx11-xcb-dev meson
|
||||
```
|
||||
|
||||
On Fedora, the needed packages are
|
||||
|
||||
```
|
||||
dbus-devel gcc git libconfig-devel libdrm-devel libev-devel libX11-devel libX11-xcb libXext-devel libxcb-devel mesa-libGL-devel meson pcre-devel pixman-devel uthash-devel xcb-util-image-devel xcb-util-renderutil-devel xorg-x11-proto-devel
|
||||
```
|
||||
|
||||
To build the documents, you need `asciidoc`
|
||||
|
||||
### To build
|
||||
|
||||
```bash
|
||||
$ git submodule update --init --recursive
|
||||
$ meson --buildtype=release . build
|
||||
$ ninja -C build
|
||||
```
|
||||
|
||||
Built binary can be found in `build/src`
|
||||
|
||||
If you have libraries and/or headers installed at non-default location (e.g. under `/usr/local/`), you might need to tell meson about them, since meson doesn't look for dependencies there by default.
|
||||
|
||||
You can do that by setting the `CPPFLAGS` and `LDFLAGS` environment variables when running `meson`. Like this:
|
||||
|
||||
```bash
|
||||
$ LDFLAGS="-L/path/to/libraries" CPPFLAGS="-I/path/to/headers" meson --buildtype=release . build
|
||||
|
||||
```
|
||||
|
||||
As an example, on FreeBSD, you might have to run meson with:
|
||||
```bash
|
||||
$ LDFLAGS="-L/usr/local/lib" CPPFLAGS="-I/usr/local/include" meson --buildtype=release . build
|
||||
$ ninja -C build
|
||||
```
|
||||
|
||||
### To install
|
||||
|
||||
``` bash
|
||||
$ ninja -C build install
|
||||
```
|
||||
|
||||
Default install prefix is `/usr/local`, you can change it with `meson configure -Dprefix=<path> build`
|
||||
|
||||
## How to Contribute
|
||||
|
||||
### Code
|
||||
|
||||
You can look at the [Projects](https://github.com/yshui/picom/projects) page, and see if there is anything that interests you. Or you can take a look at the [Issues](https://github.com/yshui/picom/issues).
|
||||
|
||||
### Non-code
|
||||
|
||||
Even if you don't want to contribute code, you can still contribute by compiling and running this branch, and report any issue you can find.
|
||||
|
||||
Contributions to the documents and wiki will also be appreciated.
|
||||
|
||||
## Contributors
|
||||
|
||||
See [CONTRIBUTORS](CONTRIBUTORS)
|
||||
|
||||
The README for the [original Compton project](https://github.com/chjj/compton/) can be found [here](History.md#Compton).
|
||||
|
||||
## Licensing
|
||||
|
||||
picom is free software, made available under the [MIT](LICENSES/MIT) and [MPL-2.0](LICENSES/MPL-2.0) software
|
||||
licenses. See the individual source files for details.
|
||||
Executable
+407
@@ -0,0 +1,407 @@
|
||||
#!/bin/sh
|
||||
# SPDX-License-Identifier: MIT
|
||||
|
||||
#
|
||||
# picom-trans
|
||||
# Copyright (c) 2021, Subhaditya Nath
|
||||
# Based on previous works of Christopher Jeffrey
|
||||
#
|
||||
|
||||
#
|
||||
# Conforming to POSIX-1.2007
|
||||
# https://pubs.opengroup.org/onlinepubs/9699919799
|
||||
#
|
||||
|
||||
# Usage:
|
||||
# $ picom-trans [options] [+|-]opacity
|
||||
# By window id
|
||||
# $ picom-trans -w "$WINDOWID" 75
|
||||
# By name
|
||||
# $ picom-trans -n "urxvt" 75
|
||||
# By current window
|
||||
# $ picom-trans -c 75
|
||||
# By selection
|
||||
# $ picom-trans 75
|
||||
# $ picom-trans -s 75
|
||||
# Increment current window 5%
|
||||
# $ picom-trans -c +5
|
||||
# Delete current window's opacity
|
||||
# $ picom-trans -c --delete
|
||||
# Toggle current window's opacity between 90 and unset
|
||||
# $ picom-trans -c --toggle 90
|
||||
# Reset all windows
|
||||
# $ picom-trans --reset
|
||||
|
||||
|
||||
# Save $0 now to print correct value while printing from functions.
|
||||
# Printing errormsgs from functions using "$0" prints the function name
|
||||
# instead of the executable name.
|
||||
EXE_NAME="$0"
|
||||
|
||||
|
||||
# Instead of printing the full path to this file (e.g. /usr/bin/picom-trans)
|
||||
# only print the base name (i.e. picom-trans)
|
||||
EXE_NAME="$(basename "$EXE_NAME")"
|
||||
|
||||
|
||||
print_usage()
|
||||
{ #{{
|
||||
echo "Usage: $EXE_NAME [options] [+|-]opacity"
|
||||
echo ""
|
||||
echo "Options:"
|
||||
echo " -h, --help Print this help message."
|
||||
echo " -o, --opacity OPACITY Specify the new opacity value in range 0-100 for the window. If"
|
||||
echo " prefixed with + or -, increment or decrement from the current"
|
||||
echo " opacity of the target window."
|
||||
echo ""
|
||||
echo "Actions:"
|
||||
echo " -g, --get Print current opacity of the target window."
|
||||
echo " -d, --delete Delete opacity of the target window."
|
||||
echo " -t, --toggle Toggle the target window's opacity, i.e. set if not already set"
|
||||
echo " and delete else."
|
||||
echo " -r, --reset Reset opacity for all windows."
|
||||
echo ""
|
||||
echo "Window Selection:"
|
||||
echo " -s, --select Select target window with mouse cursor. (DEFAULT)"
|
||||
echo " -c, --current Select the currently active window as target."
|
||||
echo " -n, --name WINDOW_NAME Specify and try to match a window name."
|
||||
echo " -w, --window WINDOW_ID Specify the window id of the target window."
|
||||
} #}}
|
||||
|
||||
|
||||
parse_args()
|
||||
{ #{{
|
||||
i=1 # because we start from "$1", not from "$0"
|
||||
while [ $i -le $# ]
|
||||
do
|
||||
#### [START] Convert GNU longopts to POSIX equivalents ####
|
||||
if [ "$1" = "--${1##--}" ] # check if $1 is a longopt
|
||||
then
|
||||
# Catch invalid options
|
||||
case "$1" in
|
||||
(--opacity=|--name=|--window=)
|
||||
echo "$EXE_NAME: option ${1%=} needs a value" >&2
|
||||
exit 1;;
|
||||
(--opacity|--name|--window)
|
||||
test $i -eq $# \
|
||||
&& echo "$EXE_NAME: option $1 needs a value" >&2 \
|
||||
&& exit 1;;
|
||||
esac
|
||||
|
||||
# Separate "--ARG=VAL" into "--ARG" "VAL"
|
||||
case "$1" in
|
||||
(--opacity=*|--name=*|--window=*)
|
||||
ARG="$(echo "$1" | sed -E 's/(--[^=]+)=.*$/\1/')"
|
||||
VAL="${1##${ARG}=}"
|
||||
shift && set -- "$ARG" "$VAL" "$@"
|
||||
esac
|
||||
|
||||
# Turn into short form
|
||||
case "$1" in
|
||||
(--help|--opacity|--get|--delete|--toggle|--reset|--select|--current|--name|--window)
|
||||
ARG=${1#-} # remove one '-' from prefix
|
||||
ARG="$(echo "$ARG" | cut -c -2)" # get first two characters
|
||||
shift && set -- "$ARG" "$@"
|
||||
esac
|
||||
|
||||
# If the argument still starts with --, it is an invalid argument
|
||||
case "$1" in
|
||||
(--*)
|
||||
echo "$EXE_NAME: illegal option $1" >&2
|
||||
exit 1
|
||||
esac
|
||||
fi
|
||||
#### [END] Convert GNU longopts to POSIX equivalents ####
|
||||
|
||||
|
||||
#### [START] Prepend '-o' to standalone opacity values ####
|
||||
# Iterate over every argument and check if it is an opacity without the -o
|
||||
# option in the previous argument. If so, then prepend the -o option.
|
||||
# e.g. Turn this -
|
||||
# picom-trans -c +10 -s
|
||||
# into this -
|
||||
# picom-trans -c -o +10 -s
|
||||
#
|
||||
# NOTE: Don't touch arguments that are preceded by -o, -w, or -n (i.e. the
|
||||
# options that take a value.)
|
||||
# e.g. This -
|
||||
# picom-trans -w 75 -o 90
|
||||
# should NOT be turned into this -
|
||||
# picom-trans -w -o 75 -o 90
|
||||
# We ensure this by checking the "$#"th (i.e. the last) argument. If
|
||||
# argument is an option that needs a value, we don't do anything to $1.
|
||||
#
|
||||
# NOTE: we are using printf because most echo implementations aren't
|
||||
# POSIX-compliant. For example, according to POSIX.1-2017, echo doesn't
|
||||
# support any options, so,
|
||||
# $ echo "-n"
|
||||
# should output -
|
||||
# -n
|
||||
# But it doesn't. It instead interprets the "-n" as the option -n, which,
|
||||
# in most implementations, means that the trailing newline should not be
|
||||
# printed.
|
||||
if echo "$1" | grep -qE '^[+-]?[[:digit:]]+%?$' && \
|
||||
! eval "printf '%s' \"\${$#}\"" | grep -q '^-[hdtrgsc]*[own]$'
|
||||
# NOTE: eval "printf '%s' \"\${$#}\"" means 'print the last argument'
|
||||
# NOTE: The letters inside the first square brackets (ie. hdtrgsc) are
|
||||
# the same as those in the getopts argument, minus those that are
|
||||
# followed by a ':'
|
||||
# NOTE: The letters inside the second square brackets (ie. own) are
|
||||
# the same as those in the getopts argument, minus those that are
|
||||
# NOT followed by a ':'
|
||||
then
|
||||
set -- "$@" "-o"
|
||||
i=$(( i + 1 ))
|
||||
fi
|
||||
#### [END] Prepend '-o' to standalone opacity values ####
|
||||
|
||||
|
||||
# Prepare for next iteration
|
||||
ARG="$1"
|
||||
shift && set -- "$@" "$ARG"
|
||||
i=$(( i + 1 ))
|
||||
done
|
||||
|
||||
|
||||
# NOTE: DO NOT ATTEMPT TO USE "$OPTIND" INSIDE THE getopts LOOP
|
||||
# - https://github.com/yshui/picom/pull/634#discussion_r654571535
|
||||
# - https://www.mail-archive.com/austin-group-l%40opengroup.org/msg04112.html
|
||||
OPTIND=1
|
||||
while getopts 'ho:dtrgsn:w:c' OPTION
|
||||
do
|
||||
case "$OPTION" in
|
||||
(h) print_usage; exit 0;;
|
||||
(o) target_opacity="$OPTARG";;
|
||||
(d) action=delete;;
|
||||
(t) action=toggle;;
|
||||
(r) action=reset;;
|
||||
(g) action=get;;
|
||||
(s) winidtype=; winid=;;
|
||||
(n) winidtype=-name; winid="$OPTARG";;
|
||||
(w) winidtype=-id; winid="$OPTARG";;
|
||||
(c) winidtype=-id; winid="$(get_focused_window_id)";;
|
||||
(\?) exit 1
|
||||
esac
|
||||
done
|
||||
} #}}
|
||||
|
||||
|
||||
get_target_window_id()
|
||||
{ #{{
|
||||
|
||||
# Get the output of xwininfo
|
||||
if test -z "$winidtype"
|
||||
then xwininfo_output="$(xwininfo -children -frame)"
|
||||
elif test "$winidtype" = "-name"
|
||||
then xwininfo_output="$(xwininfo -children -name "$winid")"
|
||||
elif test "$winidtype" = "-id"
|
||||
then
|
||||
# First, check if supplied window id is valid
|
||||
if ! echo "$winid" | grep -Eiq '^[[:space:]]*(0x[[:xdigit:]]+|[[:digit:]]+)[[:space:]]*$'
|
||||
then
|
||||
echo "Bad window ID" >&2
|
||||
exit 1
|
||||
fi
|
||||
xwininfo_output="$(xwininfo -children -id "$winid")"
|
||||
fi
|
||||
|
||||
# Extract window id from xwininfo output
|
||||
winid="$(echo "$xwininfo_output" | sed -n 's/^xwininfo:.*: \(0x[[:xdigit:]]*\).*$/\1/p')"
|
||||
if test -z "$winid"
|
||||
then
|
||||
echo "Failed to find window" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Make sure it's not root window
|
||||
if echo "$xwininfo_output" | grep -Fq "Parent window id: 0x0"
|
||||
then
|
||||
echo "Cannot set opacity on root window" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# If it's not the topmost window, get the topmost window
|
||||
if ! echo "$xwininfo_output" | grep -q 'Parent window id: 0x[[:xdigit:]]* (the root window)'
|
||||
then
|
||||
window_tree="$(xwininfo -root -tree)"
|
||||
if test -z "$window_tree"
|
||||
then
|
||||
echo "Failed to get root window tree" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Find the highest ancestor of the target window
|
||||
winid="$(echo "$window_tree" \
|
||||
| sed -n "/^\s*$winid/q;s/^ \(0x[[:xdigit:]]*\).*/\1/p" \
|
||||
| tail -n 1)"
|
||||
if test -z "$winid"
|
||||
then
|
||||
echo "Failed to find window in window tree" >&2
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
if test -z "$winid"
|
||||
then
|
||||
echo "Failed to find the highest parent window below root of the selected window" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "$winid"
|
||||
} #}}
|
||||
|
||||
get_focused_window_id()
|
||||
{ #{{
|
||||
id="$(xprop -root -notype -f _NET_ACTIVE_WINDOW 32x '$0' _NET_ACTIVE_WINDOW)"
|
||||
echo "${id#_NET_ACTIVE_WINDOW}"
|
||||
} #}}
|
||||
|
||||
get_current_opacity()
|
||||
{ #{{
|
||||
# Gets current opacity in the range 0-100
|
||||
# Doesn't output anything if opacity isn't set
|
||||
cur="$(xprop -id "$winid" -notype -f _NET_WM_WINDOW_OPACITY 32c '$0' _NET_WM_WINDOW_OPACITY)"
|
||||
cur="${cur#_NET_WM_WINDOW_OPACITY}"
|
||||
cur="${cur%:*}"
|
||||
test -n "$cur" &&
|
||||
cur=$(( cur * 100 / 0xffffffff ))
|
||||
echo "$cur"
|
||||
} #}}
|
||||
|
||||
|
||||
get_opacity()
|
||||
{ #{{
|
||||
cur="$(get_current_opacity)"
|
||||
test -z "$cur" && cur=100 # Unset opacity means fully opaque
|
||||
echo "$cur"
|
||||
exit 0
|
||||
} #}}
|
||||
|
||||
delete_opacity()
|
||||
{ #{{
|
||||
xprop -id "$winid" -remove _NET_WM_WINDOW_OPACITY
|
||||
exit 0
|
||||
} #}}
|
||||
|
||||
reset_opacity() # Reset opacity of all windows
|
||||
{ #{{
|
||||
for winid in $(xwininfo -root -tree | sed -n 's/^ \(0x[[:xdigit:]]*\).*/\1/p')
|
||||
do xprop -id "$winid" -remove _NET_WM_WINDOW_OPACITY 2>/dev/null
|
||||
done
|
||||
exit 0
|
||||
} #}}
|
||||
|
||||
set_opacity()
|
||||
{ #{{
|
||||
if ! echo "$target_opacity" | grep -qE '^[+-]?[[:digit:]]+%?$'
|
||||
then
|
||||
if test -z "$target_opacity"
|
||||
then echo "No opacity specified" >&2
|
||||
else echo "Invalid opacity specified: $target_opacity" >&2
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# strip trailing '%' sign, if any
|
||||
target_opacity="${target_opacity%%%}"
|
||||
|
||||
if echo "$target_opacity" | grep -q '^[+-]'
|
||||
then
|
||||
current_opacity="$(get_current_opacity)"
|
||||
test -z "$current_opacity" && current_opacity=100
|
||||
target_opacity=$(( current_opacity + target_opacity ))
|
||||
fi
|
||||
|
||||
test $target_opacity -lt 0 && target_opacity=0
|
||||
test $target_opacity -gt 100 && target_opacity=100
|
||||
|
||||
target_opacity=$(( target_opacity * 0xffffffff / 100 ))
|
||||
xprop -id "$winid" -f _NET_WM_WINDOW_OPACITY 32c \
|
||||
-set _NET_WM_WINDOW_OPACITY "$target_opacity"
|
||||
|
||||
exit $?
|
||||
} #}}
|
||||
|
||||
toggle_opacity()
|
||||
{ #{{
|
||||
# If opacity is currently set, unset it.
|
||||
# If opacity is currently unset, set opacity to the supplied value. If no
|
||||
# value is supplied, we default to 100%.
|
||||
if test -z "$(get_current_opacity)"
|
||||
then
|
||||
test -n "$target_opacity" || target_opacity=100
|
||||
set_opacity
|
||||
else
|
||||
delete_opacity
|
||||
fi
|
||||
} #}}
|
||||
|
||||
|
||||
# Warn about rename of compton to picom
|
||||
case "$0" in
|
||||
*compton-trans*) echo "Warning: compton has been renamed, please use picom-trans instead" >&2;;
|
||||
esac
|
||||
|
||||
|
||||
# Check if both xwininfo and xprop are available
|
||||
if ! command -v xprop >/dev/null || ! command -v xwininfo >/dev/null
|
||||
then
|
||||
echo "The command xwininfo or xprop is not available. They might reside in a package named xwininfo, xprop, x11-utils, xorg-xprop, or xorg-xwininfo" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
# No arguments given. Show help.
|
||||
if test $# -eq 0
|
||||
then
|
||||
print_usage >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
# Variables
|
||||
# action is set to 'set' by default
|
||||
action=set
|
||||
winid=
|
||||
winidtype=
|
||||
target_opacity=
|
||||
|
||||
# If there's only one argument, and it's a valid opacity
|
||||
# then take it as target_opacity. Else, parse all arguments.
|
||||
if test $# -eq 1 && echo "$1" | grep -qE '^[+-]?[[:digit:]]+%?$'
|
||||
then
|
||||
target_opacity=$1
|
||||
shift
|
||||
else
|
||||
parse_args "$@"
|
||||
fi
|
||||
|
||||
|
||||
# reset_opacity doesn't need $winid
|
||||
case $action in
|
||||
(reset) reset_opacity;;
|
||||
esac
|
||||
|
||||
# Any other action needs $winid
|
||||
#
|
||||
# NOTE: Do NOT change the order of winid= and winidtype= below
|
||||
# the output of get_target_window_id depends on $winidtype
|
||||
#
|
||||
# NOTE: If get_target_window_id returns with a non-zero $?
|
||||
# that must mean that some error occured. So, exit with that same $?
|
||||
#
|
||||
winid=$(get_target_window_id) || exit $?
|
||||
winidtype=-id
|
||||
case $action in
|
||||
(set) set_opacity;;
|
||||
(get) get_opacity;;
|
||||
(delete) delete_opacity;;
|
||||
(toggle) toggle_opacity;;
|
||||
esac
|
||||
|
||||
|
||||
# We should never reach this part of the file
|
||||
echo "This sentence shouldn't have been printed. Please file a bug report." >&2
|
||||
exit 128
|
||||
|
||||
|
||||
# vim:ft=sh:ts=4:sts=4:sw=2:et:fdm=marker:fmr=#{{,#}}:nowrap
|
||||
@@ -0,0 +1,11 @@
|
||||
uniform float opacity;
|
||||
uniform bool invert_color;
|
||||
uniform sampler2D tex;
|
||||
|
||||
void main() {
|
||||
vec4 c = texture2D(tex, gl_TexCoord[0]);
|
||||
if (invert_color)
|
||||
c = vec4(vec3(c.a, c.a, c.a) - vec3(c), c.a);
|
||||
c *= opacity;
|
||||
gl_FragColor = c;
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
uniform float opacity;
|
||||
uniform bool invert_color;
|
||||
uniform sampler2D tex;
|
||||
|
||||
void main() {
|
||||
vec4 c = texture2D(tex, gl_TexCoord[0]);
|
||||
{
|
||||
// Change vec4(1.0, 1.0, 1.0, 1.0) to your desired color
|
||||
vec4 vdiff = abs(vec4(1.0, 1.0, 1.0, 1.0) - c);
|
||||
float diff = max(max(max(vdiff.r, vdiff.g), vdiff.b), vdiff.a);
|
||||
// Change 0.8 to your desired opacity
|
||||
if (diff < 0.001)
|
||||
c *= 0.8;
|
||||
}
|
||||
if (invert_color)
|
||||
c = vec4(vec3(c.a, c.a, c.a) - vec3(c), c.a);
|
||||
c *= opacity;
|
||||
gl_FragColor = c;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
[Desktop Entry]
|
||||
Version=1.0
|
||||
Type=Application
|
||||
NoDisplay=true
|
||||
Name=compton
|
||||
GenericName=X compositor
|
||||
Comment=An X compositor
|
||||
Categories=Utility;
|
||||
Keywords=compositor;composite manager;window effects;transparency;opacity;
|
||||
TryExec=compton
|
||||
Exec=compton
|
||||
Icon=compton
|
||||
# Thanks to quequotion for providing this file!
|
||||
Executable
+54
@@ -0,0 +1,54 @@
|
||||
#!/bin/sh
|
||||
|
||||
if [ -z "$SED" ]; then
|
||||
SED="sed"
|
||||
command -v gsed > /dev/null && SED="gsed"
|
||||
fi
|
||||
|
||||
# === Get connection parameters ===
|
||||
|
||||
dpy=$(echo -n "$DISPLAY" | tr -c '[:alnum:]' _)
|
||||
|
||||
if [ -z "$dpy" ]; then
|
||||
echo "Cannot find display."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
service="com.github.chjj.compton.${dpy}"
|
||||
interface='com.github.chjj.compton'
|
||||
object='/com/github/chjj/compton'
|
||||
type_win='uint32'
|
||||
type_enum='uint32'
|
||||
|
||||
# === DBus methods ===
|
||||
|
||||
# List all window ID compton manages (except destroyed ones)
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.list_win"
|
||||
|
||||
# Get window ID of currently focused window
|
||||
focused=$(dbus-send --print-reply --dest="$service" "$object" "${interface}.find_win" string:focused | $SED -n 's/^[[:space:]]*'${type_win}'[[:space:]]*\([[:digit:]]*\).*/\1/p')
|
||||
|
||||
if [ -n "$focused" ]; then
|
||||
# Get invert_color_force property of the window
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.win_get" "${type_win}:${focused}" string:invert_color_force
|
||||
|
||||
# Set the window to have inverted color
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.win_set" "${type_win}:${focused}" string:invert_color_force "${type_enum}:1"
|
||||
else
|
||||
echo "Cannot find focused window."
|
||||
fi
|
||||
|
||||
# Reset compton
|
||||
sleep 3
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.reset"
|
||||
|
||||
# Undirect window
|
||||
sleep 3
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.opts_set" string:redirected_force "${type_enum}:0"
|
||||
|
||||
# Revert back to auto
|
||||
sleep 3
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.opts_set" string:redirected_force "${type_enum}:2"
|
||||
|
||||
# Force repaint
|
||||
dbus-send --print-reply --dest="$service" "$object" "${interface}.repaint"
|
||||
Executable
+69
@@ -0,0 +1,69 @@
|
||||
#!/bin/sh
|
||||
|
||||
# == Declare stderr function ===
|
||||
|
||||
stderr() {
|
||||
printf "\033[1;31m%s\n\033[0m" "$@" >&2
|
||||
}
|
||||
|
||||
# === Verify `picom --dbus` status ===
|
||||
|
||||
if [ -z "$(dbus-send --session --dest=org.freedesktop.DBus --type=method_call --print-reply /org/freedesktop/DBus org.freedesktop.DBus.ListNames | grep compton)" ]; then
|
||||
stderr "picom DBus interface unavailable"
|
||||
if [ -n "$(pgrep picom)" ]; then
|
||||
stderr "picom running without dbus interface"
|
||||
#killall picom & # Causes all windows to flicker away and come back ugly.
|
||||
#picom --dbus & # Causes all windows to flicker away and come back beautiful
|
||||
else
|
||||
stderr "picom not running"
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# === Setup sed ===
|
||||
|
||||
SED="${SED:-$(command -v gsed || printf 'sed')}"
|
||||
|
||||
# === Get connection parameters ===
|
||||
|
||||
dpy=$(printf "$DISPLAY" | tr -c '[:alnum:]' _)
|
||||
|
||||
if [ -z "$dpy" ]; then
|
||||
stderr "Cannot find display."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
service="com.github.chjj.compton.${dpy}"
|
||||
interface="com.github.chjj.compton"
|
||||
picom_dbus="dbus-send --print-reply --dest="${service}" / "${interface}"."
|
||||
type_win='uint32'
|
||||
type_enum='uint32'
|
||||
|
||||
# === Color Inversion ===
|
||||
|
||||
# Get window ID of window to invert
|
||||
if [ -z "$1" -o "$1" = "selected" ]; then
|
||||
window=$(xwininfo -frame | sed -n 's/^xwininfo: Window id: \(0x[[:xdigit:]][[:xdigit:]]*\).*/\1/p') # Select window by mouse
|
||||
elif [ "$1" = "focused" ]; then
|
||||
# Ensure we are tracking focus
|
||||
window=$(${picom_dbus}find_win string:focused | $SED -n 's/^[[:space:]]*'${type_win}'[[:space:]]*\([[:digit:]]*\).*/\1/p') # Query picom for the active window
|
||||
elif echo "$1" | grep -Eiq '^([[:digit:]][[:digit:]]*|0x[[:xdigit:]][[:xdigit:]]*)$'; then
|
||||
window="$1" # Accept user-specified window-id if the format is correct
|
||||
else
|
||||
echo "$0" "[ selected | focused | window-id ]"
|
||||
fi
|
||||
|
||||
# Color invert the selected or focused window
|
||||
if [ -n "$window" ]; then
|
||||
invert_status="$(${picom_dbus}win_get "${type_win}:${window}" string:invert_color | $SED -n 's/^[[:space:]]*boolean[[:space:]]*\([[:alpha:]]*\).*/\1/p')"
|
||||
if [ "$invert_status" = true ]; then
|
||||
invert=0 # Set the window to have normal color
|
||||
else
|
||||
invert=1 # Set the window to have inverted color
|
||||
fi
|
||||
${picom_dbus}win_set "${type_win}:${window}" string:invert_color_force "${type_enum}:${invert}" &
|
||||
else
|
||||
stderr "Cannot find $1 window."
|
||||
exit 1
|
||||
fi
|
||||
exit 0
|
||||
@@ -0,0 +1 @@
|
||||
Compton is a X compositing window manager, fork of xcompmgr-dana.
|
||||
@@ -0,0 +1,13 @@
|
||||
mans = ['picom.1', 'picom-trans.1']
|
||||
if get_option('with_docs')
|
||||
a2x = find_program('a2x')
|
||||
foreach m : mans
|
||||
custom_target(m, output: [m], input: [m+'.asciidoc'],
|
||||
command: [a2x, '-a',
|
||||
'picom-version='+version,
|
||||
'--format', 'manpage', '@INPUT@', '-D',
|
||||
meson.current_build_dir()],
|
||||
install: true,
|
||||
install_dir: join_paths(get_option('mandir'), 'man1'))
|
||||
endforeach
|
||||
endif
|
||||
@@ -0,0 +1,114 @@
|
||||
picom-trans(1)
|
||||
================
|
||||
:doctype: manpage
|
||||
:man source: picom
|
||||
:man version: {picom-version}
|
||||
:man manual: User Commands
|
||||
|
||||
NAME
|
||||
----
|
||||
picom-trans - an opacity setter tool
|
||||
|
||||
SYNOPSIS
|
||||
--------
|
||||
|
||||
*picom-trans* [-w 'WINDOW_ID'] [-n 'WINDOW_NAME'] [-c] [-s] 'OPACITY'
|
||||
|
||||
DESCRIPTION
|
||||
-----------
|
||||
|
||||
*picom-trans* is a bash script that sets '_NET_WM_WINDOW_OPACITY' attribute of a window using standard X11 command-line utilities, including *xprop*(1) and *xwininfo*(1). It is similar to *transset*(1) or *transset-df*(1).
|
||||
|
||||
OPTIONS
|
||||
-------
|
||||
*-w*, *--window*='WINDOW_ID'::
|
||||
Specify the window id of the target window.
|
||||
|
||||
*-n*, *--name*='WINDOW_NAME'::
|
||||
Specify and try to match a window name.
|
||||
|
||||
*-c*, *--current*::
|
||||
Specify the currently active window as target. Only works if EWMH '_NET_ACTIVE_WINDOW' property exists on root window.
|
||||
|
||||
*-s*, *--select*::
|
||||
Select target window with mouse cursor. This is the default if no window has been specified.
|
||||
|
||||
*-o*, *--opacity*='OPACITY'::
|
||||
Specify the new opacity value for the window. This value can be anywhere from 1-100. If it is prefixed with a plus or minus (+/-), this will increment or decrement from the target window's current opacity instead.
|
||||
|
||||
*-g*, *--get*::
|
||||
Print the target window's opacity instead of setting it.
|
||||
|
||||
*-d*, *--delete*::
|
||||
Delete opacity of the target window instead of setting it.
|
||||
|
||||
*-t*, *--toggle*::
|
||||
Toggle the target window's opacity: Set opacity if not already set, and delete if already set.
|
||||
|
||||
*-r*, *--reset*::
|
||||
Reset opacity for all windows instead of setting it.
|
||||
|
||||
EXAMPLES
|
||||
--------
|
||||
|
||||
* Set the opacity of the window with specific window ID to 75%:
|
||||
+
|
||||
------------
|
||||
picom-trans -w "$WINDOWID" 75
|
||||
------------
|
||||
|
||||
* Set the opacity of the window with the name "urxvt" to 75%:
|
||||
+
|
||||
------------
|
||||
picom-trans -n "urxvt" 75
|
||||
------------
|
||||
|
||||
* Set current window to opacity of 75%:
|
||||
+
|
||||
------------
|
||||
picom-trans -c 75
|
||||
------------
|
||||
|
||||
* Select target window and set opacity to 75%:
|
||||
+
|
||||
------------
|
||||
picom-trans -s 75
|
||||
------------
|
||||
|
||||
* Increment opacity of current active window by 5%:
|
||||
+
|
||||
------------
|
||||
picom-trans -c +5
|
||||
------------
|
||||
|
||||
* Decrement opacity of current active window by 5%:
|
||||
+
|
||||
------------
|
||||
picom-trans -c -- -5
|
||||
------------
|
||||
|
||||
* Delete current window's opacity:
|
||||
+
|
||||
------------
|
||||
picom-trans -c --delete
|
||||
------------
|
||||
|
||||
* Toggle current window's opacity between 90 and unset
|
||||
+
|
||||
------------
|
||||
picom-trans -c --toggle 90
|
||||
------------
|
||||
|
||||
* Reset all windows:
|
||||
+
|
||||
------------
|
||||
picom-trans --reset
|
||||
------------
|
||||
|
||||
BUGS
|
||||
----
|
||||
Please submit bug reports to <https://github.com/yshui/picom>.
|
||||
|
||||
SEE ALSO
|
||||
--------
|
||||
link:picom.1.html[*picom*(1)], *xprop*(1), *xwininfo*(1)
|
||||
@@ -0,0 +1,509 @@
|
||||
picom(1)
|
||||
========
|
||||
:doctype: manpage
|
||||
:man source: picom
|
||||
:man version: {picom-version}
|
||||
:man manual: User Commands
|
||||
|
||||
NAME
|
||||
----
|
||||
picom - a compositor for X11
|
||||
|
||||
SYNOPSIS
|
||||
--------
|
||||
*picom* ['OPTIONS']
|
||||
|
||||
DESCRIPTION
|
||||
-----------
|
||||
picom is a compositor based on Dana Jansens' version of xcompmgr (which itself was written by Keith Packard). It includes some improvements over the original xcompmgr, like window frame opacity and inactive window transparency.
|
||||
|
||||
OPTIONS
|
||||
-------
|
||||
*-h*, *--help*::
|
||||
Get the usage text embedded in program code, which may be more up-to-date than this man page.
|
||||
|
||||
*-r*, *--shadow-radius*='RADIUS'::
|
||||
The blur radius for shadows, in pixels. (defaults to 12)
|
||||
|
||||
*-o*, *--shadow-opacity*='OPACITY'::
|
||||
The opacity of shadows. (0.0 - 1.0, defaults to 0.75)
|
||||
|
||||
*-l*, *--shadow-offset-x*='OFFSET'::
|
||||
The left offset for shadows, in pixels. (defaults to -15)
|
||||
|
||||
*-t*, *--shadow-offset-y*='OFFSET'::
|
||||
The top offset for shadows, in pixels. (defaults to -15)
|
||||
|
||||
*-I*, *--fade-in-step*='OPACITY_STEP'::
|
||||
Opacity change between steps while fading in. (0.01 - 1.0, defaults to 0.028)
|
||||
|
||||
*-O*, *--fade-out-step*='OPACITY_STEP'::
|
||||
Opacity change between steps while fading out. (0.01 - 1.0, defaults to 0.03)
|
||||
|
||||
*-D*, *--fade-delta*='MILLISECONDS'::
|
||||
The time between steps in fade step, in milliseconds. (> 0, defaults to 10)
|
||||
|
||||
*-c*, *--shadow*::
|
||||
Enabled client-side shadows on windows. Note desktop windows (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow, unless explicitly requested using the wintypes option.
|
||||
|
||||
*-f*, *--fading*::
|
||||
Fade windows in/out when opening/closing and when opacity changes, unless *--no-fading-openclose* is used.
|
||||
|
||||
*-F*::
|
||||
Equals to *-f*. Deprecated.
|
||||
|
||||
*--animations*::
|
||||
Run animations for window geometry changes (movement and scaling).
|
||||
We use spring-based animations, which are parametrized by *--animation-stiffness*, *--animation-dampening*, *--animation-window-mass* and *--animation-clamp*. +
|
||||
A useful resource for selecting animation parameters is https://react-spring-visualizer.com/, which allows you to interactively try out various parameters and see the resulting animation curve. Or you can just edit the values in the config file, which is automatically reloaded.
|
||||
|
||||
*--animation-for-open-window*::
|
||||
Which animation to run when opening a window. Must be one of `none`, `fly-in`, `zoom` (default: `none`).
|
||||
|
||||
*--animation-stiffness*::
|
||||
Stiffness (a.k.a. tension) parameter for spring-based animation (default: 200.0).
|
||||
|
||||
*--animation-dampening*::
|
||||
Dampening (a.k.a. friction) parameter for spring-based animation (default: 25.0).
|
||||
|
||||
*--animation-window-mass*::
|
||||
Mass parameter for spring-based animation (default: 1.0).
|
||||
|
||||
*--animation-clamping*::
|
||||
Whether to clamp animations (default: true).
|
||||
|
||||
**NOTE:** With clamping disabled, on very low performance conditions (e.g., over 100ms to render an animation frame), windows may diverge. If this is your case, it is strongly advised to keep clamping on, as it protects against that.
|
||||
|
||||
*-i*, *--inactive-opacity*='OPACITY'::
|
||||
Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0)
|
||||
|
||||
*-e*, *--frame-opacity*='OPACITY'::
|
||||
Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default)
|
||||
|
||||
*-b*, *--daemon*::
|
||||
Daemonize process. Fork to background after initialization. This option can only be set from the command line, setting this in the configuration file will have no effect.
|
||||
|
||||
*--log-level*::
|
||||
Set the log level. Possible values are "TRACE", "DEBUG", "INFO", "WARN", "ERROR", in increasing level of importance. Case doesn't matter. If using the "TRACE" log level, it's better to log into a file using *--log-file*, since it can generate a huge stream of logs.
|
||||
|
||||
*--log-file*::
|
||||
Set the log file. If *--log-file* is never specified, logs will be written to stderr. Otherwise, logs will to written to the given file, though some of the early logs might still be written to the stderr. When setting this option from the config file, it is recommended to use an absolute path.
|
||||
|
||||
*--experimental-backends*::
|
||||
Use the new, reimplemented version of the backends. The new backends are HIGHLY UNSTABLE at this point, you have been warned. This option is not available in the config file.
|
||||
|
||||
*--show-all-xerrors*::
|
||||
Show all X errors (for debugging).
|
||||
|
||||
*--config* 'PATH'::
|
||||
Look for configuration file at the path. See *CONFIGURATION FILES* section below for where picom looks for a configuration file by default. Use `/dev/null` to avoid loading configuration file.
|
||||
|
||||
*--write-pid-path* 'PATH'::
|
||||
Write process ID to a file. it is recommended to use an absolute path.
|
||||
|
||||
*--shadow-color* 'STRING'::
|
||||
Color of shadow, as a hex string ('#000000')
|
||||
|
||||
*--shadow-red* 'VALUE'::
|
||||
Red color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
|
||||
*--shadow-green* 'VALUE'::
|
||||
Green color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
|
||||
*--shadow-blue* 'VALUE'::
|
||||
Blue color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
|
||||
*--inactive-opacity-override*::
|
||||
Let inactive opacity set by *-i* override the '_NET_WM_WINDOW_OPACITY' values of windows.
|
||||
|
||||
*--active-opacity* 'OPACITY'::
|
||||
Default opacity for active windows. (0.0 - 1.0, defaults to 1.0)
|
||||
|
||||
*--inactive-dim* 'VALUE'::
|
||||
Dim inactive windows. (0.0 - 1.0, defaults to 0.0)
|
||||
|
||||
*--corner-radius* 'VALUE'::
|
||||
Sets the radius of rounded window corners. When > 0, the compositor will round the corners of windows. Does not interact well with *--transparent-clipping*. (defaults to 0).
|
||||
|
||||
*--rounded-corners-exclude* 'CONDITION'::
|
||||
Exclude conditions for rounded corners.
|
||||
|
||||
*--mark-wmwin-focused*::
|
||||
Try to detect WM windows (a non-override-redirect window with no child that has 'WM_STATE') and mark them as active.
|
||||
|
||||
*--mark-ovredir-focused*::
|
||||
Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused.
|
||||
|
||||
*--no-fading-openclose*::
|
||||
Do not fade on window open/close.
|
||||
|
||||
*--no-fading-destroyed-argb*::
|
||||
Do not fade destroyed ARGB windows with WM frame. Workaround of bugs in Openbox, Fluxbox, etc.
|
||||
|
||||
*--shadow-ignore-shaped*::
|
||||
Do not paint shadows on shaped windows. Note shaped windows here means windows setting its shape through X Shape extension. Those using ARGB background is beyond our control. Deprecated, use `--shadow-exclude 'bounding_shaped'` or `--shadow-exclude 'bounding_shaped && !rounded_corners'` instead.
|
||||
|
||||
*--detect-rounded-corners*::
|
||||
Try to detect windows with rounded corners and don't consider them shaped windows. The accuracy is not very high, unfortunately.
|
||||
|
||||
*--detect-client-opacity*::
|
||||
Detect '_NET_WM_WINDOW_OPACITY' on client windows, useful for window managers not passing '_NET_WM_WINDOW_OPACITY' of client windows to frame windows.
|
||||
|
||||
*--vsync*, *--no-vsync*::
|
||||
Enable/disable VSync.
|
||||
|
||||
*--use-ewmh-active-win*::
|
||||
Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy, provided that the WM supports it.
|
||||
|
||||
*--unredir-if-possible*::
|
||||
Unredirect all windows if a full-screen opaque window is detected, to maximize performance for full-screen windows. Known to cause flickering when redirecting/unredirecting windows.
|
||||
|
||||
*--unredir-if-possible-delay* 'MILLISECONDS'::
|
||||
Delay before unredirecting the window, in milliseconds. Defaults to 0.
|
||||
|
||||
*--unredir-if-possible-exclude* 'CONDITION'::
|
||||
Conditions of windows that shouldn't be considered full-screen for unredirecting screen.
|
||||
|
||||
*--shadow-exclude* 'CONDITION'::
|
||||
Specify a list of conditions of windows that should have no shadow.
|
||||
|
||||
*--clip-shadow-above* 'CONDITION'::
|
||||
Specify a list of conditions of windows that should have no shadow painted over, such as a dock window.
|
||||
|
||||
*--fade-exclude* 'CONDITION'::
|
||||
Specify a list of conditions of windows that should not be faded.
|
||||
|
||||
*--focus-exclude* 'CONDITION'::
|
||||
Specify a list of conditions of windows that should always be considered focused.
|
||||
|
||||
*--inactive-dim-fixed*::
|
||||
Use fixed inactive dim value, instead of adjusting according to window opacity.
|
||||
|
||||
*--detect-transient*::
|
||||
Use 'WM_TRANSIENT_FOR' to group windows, and consider windows in the same group focused at the same time.
|
||||
|
||||
*--detect-client-leader*::
|
||||
Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same group focused at the same time. This usually means windows from the same application will be considered focused or unfocused at the same time.'WM_TRANSIENT_FOR' has higher priority if *--detect-transient* is enabled, too.
|
||||
|
||||
*--blur-method*, *--blur-size*, *--blur-deviation*, *--blur-strength*::
|
||||
Parameters for background blurring, see the *BLUR* section for more information.
|
||||
|
||||
*--blur-background*::
|
||||
Blur background of semi-transparent / ARGB windows. Bad in performance, with driver-dependent behavior. The name of the switch may change without prior notifications.
|
||||
|
||||
*--blur-background-frame*::
|
||||
Blur background of windows when the window frame is not opaque. Implies *--blur-background*. Bad in performance, with driver-dependent behavior. The name may change.
|
||||
|
||||
*--blur-background-fixed*::
|
||||
Use fixed blur strength rather than adjusting according to window opacity.
|
||||
|
||||
*--blur-kern* 'MATRIX'::
|
||||
Specify the blur convolution kernel, with the following format:
|
||||
+
|
||||
----
|
||||
WIDTH,HEIGHT,ELE1,ELE2,ELE3,ELE4,ELE5...
|
||||
----
|
||||
+
|
||||
In other words, the matrix is formatted as a list of comma separated numbers. The first two numbers must be integers, which specify the width and height of the matrix. They must be odd numbers. Then, the following 'width * height - 1' numbers specifies the numbers in the matrix, row by row, excluding the center element.
|
||||
+
|
||||
The elements are finite floating point numbers. The decimal pointer has to be '.' (a period), scientific notation is not supported.
|
||||
+
|
||||
The element in the center will either be 1.0 or varying based on opacity, depending on whether you have *--blur-background-fixed*. Yet the automatic adjustment of blur factor may not work well with a custom blur kernel.
|
||||
+
|
||||
A 7x7 Gaussian blur kernel (sigma = 0.84089642) looks like:
|
||||
+
|
||||
----
|
||||
--blur-kern '7,7,0.000003,0.000102,0.000849,0.001723,0.000849,0.000102,0.000003,0.000102,0.003494,0.029143,0.059106,0.029143,0.003494,0.000102,0.000849,0.029143,0.243117,0.493069,0.243117,0.029143,0.000849,0.001723,0.059106,0.493069,0.493069,0.059106,0.001723,0.000849,0.029143,0.243117,0.493069,0.243117,0.029143,0.000849,0.000102,0.003494,0.029143,0.059106,0.029143,0.003494,0.000102,0.000003,0.000102,0.000849,0.001723,0.000849,0.000102,0.000003'
|
||||
----
|
||||
+
|
||||
May also be one of the predefined kernels: `3x3box` (default), `5x5box`, `7x7box`, `3x3gaussian`, `5x5gaussian`, `7x7gaussian`, `9x9gaussian`, `11x11gaussian`. All Gaussian kernels are generated with sigma = 0.84089642 . If you find yourself needing to generate custom blur kernels, you might want to try the new blur configuration supported by the experimental backends (See *BLUR* and *--experimental-backends*).
|
||||
|
||||
*--blur-background-exclude* 'CONDITION'::
|
||||
Exclude conditions for background blur.
|
||||
|
||||
*--resize-damage* 'INTEGER'::
|
||||
Resize damaged region by a specific number of pixels. A positive value enlarges it while a negative one shrinks it. If the value is positive, those additional pixels will not be actually painted to screen, only used in blur calculation, and such. (Due to technical limitations, with *--use-damage*, those pixels will still be incorrectly painted to screen.) Primarily used to fix the line corruption issues of blur, in which case you should use the blur radius value here (e.g. with a 3x3 kernel, you should use `--resize-damage 1`, with a 5x5 one you use `--resize-damage 2`, and so on). May or may not work with *--glx-no-stencil*. Shrinking doesn't function correctly.
|
||||
|
||||
*--invert-color-include* 'CONDITION'::
|
||||
Specify a list of conditions of windows that should be painted with inverted color. Resource-hogging, and is not well tested.
|
||||
|
||||
*--opacity-rule* 'OPACITY':'CONDITION'::
|
||||
Specify a list of opacity rules, in the format `PERCENT:PATTERN`, like `50:name *= "Firefox"`. picom-trans is recommended over this. Note we don't make any guarantee about possible conflicts with other programs that set '_NET_WM_WINDOW_OPACITY' on frame or client windows.
|
||||
|
||||
*--shadow-exclude-reg* 'GEOMETRY'::
|
||||
Specify a X geometry that describes the region in which shadow should not be painted in, such as a dock window region. Use `--shadow-exclude-reg x10+0-0`, for example, if the 10 pixels on the bottom of the screen should not have shadows painted on.
|
||||
|
||||
*--xinerama-shadow-crop*::
|
||||
Crop shadow of a window fully on a particular Xinerama screen to the screen.
|
||||
|
||||
*--backend* 'BACKEND'::
|
||||
Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`. `xrender` is the default one.
|
||||
+
|
||||
--
|
||||
* `xrender` backend performs all rendering operations with X Render extension. It is what `xcompmgr` uses, and is generally a safe fallback when you encounter rendering artifacts or instability.
|
||||
* `glx` (OpenGL) backend performs all rendering operations with OpenGL. It is more friendly to some VSync methods, and has significantly superior performance on color inversion (*--invert-color-include*) or blur (*--blur-background*). It requires proper OpenGL 2.0 support from your driver and hardware. You may wish to look at the GLX performance optimization options below. *--xrender-sync-fence* might be needed on some systems to avoid delay in changes of screen contents.
|
||||
* `xr_glx_hybrid` backend renders the updated screen contents with X Render and presents it on the screen with GLX. It attempts to address the rendering issues some users encountered with GLX backend and enables the better VSync of GLX backends. *--vsync-use-glfinish* might fix some rendering issues with this backend.
|
||||
--
|
||||
|
||||
*--glx-no-stencil*::
|
||||
GLX backend: Avoid using stencil buffer, useful if you don't have a stencil buffer. Might cause incorrect opacity when rendering transparent content (but never practically happened) and may not work with *--blur-background*. My tests show a 15% performance boost. Recommended.
|
||||
|
||||
*--glx-no-rebind-pixmap*::
|
||||
GLX backend: Avoid rebinding pixmap on window damage. Probably could improve performance on rapid window content changes, but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.). Recommended if it works.
|
||||
|
||||
*--no-use-damage*::
|
||||
Disable the use of damage information. This cause the whole screen to be redrawn everytime, instead of the part of the screen has actually changed. Potentially degrades the performance, but might fix some artifacts.
|
||||
|
||||
*--xrender-sync-fence*::
|
||||
Use X Sync fence to sync clients' draw calls, to make sure all draw calls are finished before picom starts drawing. Needed on nvidia-drivers with GLX backend for some users.
|
||||
|
||||
*--glx-fshader-win* 'SHADER'::
|
||||
GLX backend: Use specified GLSL fragment shader for rendering window contents. See `compton-default-fshader-win.glsl` and `compton-fake-transparency-fshader-win.glsl` in the source tree for examples.
|
||||
|
||||
*--force-win-blend*::
|
||||
Force all windows to be painted with blending. Useful if you have a *--glx-fshader-win* that could turn opaque pixels transparent.
|
||||
|
||||
*--dbus*::
|
||||
Enable remote control via D-Bus. See the *D-BUS API* section below for more details.
|
||||
|
||||
*--benchmark* 'CYCLES'::
|
||||
Benchmark mode. Repeatedly paint until reaching the specified cycles.
|
||||
|
||||
*--benchmark-wid* 'WINDOW_ID'::
|
||||
Specify window ID to repaint in benchmark mode. If omitted or is 0, the whole screen is repainted.
|
||||
|
||||
*--no-ewmh-fullscreen*::
|
||||
Do not use EWMH to detect fullscreen windows. Reverts to checking if a window is fullscreen based only on its size and coordinates.
|
||||
|
||||
*--max-brightness*::
|
||||
Dimming bright windows so their brightness doesn't exceed this set value. Brightness of a window is estimated by averaging all pixels in the window, so this could comes with a performance hit. Setting this to 1.0 disables this behaviour. Requires *--use-damage* to be disabled. (default: 1.0)
|
||||
|
||||
*--transparent-clipping*::
|
||||
Make transparent windows clip other windows like non-transparent windows do, instead of blending on top of them.
|
||||
|
||||
FORMAT OF CONDITIONS
|
||||
--------------------
|
||||
Some options accept a condition string to match certain windows. A condition string is formed by one or more conditions, joined by logical operators.
|
||||
|
||||
A condition with "exists" operator looks like this:
|
||||
|
||||
<NEGATION> <TARGET> <CLIENT/FRAME> [<INDEX>] : <FORMAT> <TYPE>
|
||||
|
||||
With equals operator it looks like:
|
||||
|
||||
<NEGATION> <TARGET> <CLIENT/FRAME> [<INDEX>] : <FORMAT> <TYPE> <NEGATION> <OP QUALIFIER> <MATCH TYPE> = <PATTERN>
|
||||
|
||||
With greater-than/less-than operators it looks like:
|
||||
|
||||
<NEGATION> <TARGET> <CLIENT/FRAME> [<INDEX>] : <FORMAT> <TYPE> <NEGATION> <OPERATOR> <PATTERN>
|
||||
|
||||
'NEGATION' (optional) is one or more exclamation marks;
|
||||
|
||||
'TARGET' is either a predefined target name, or the name of a window property to match. Supported predefined targets are `id`, `x`, `y`, `x2` (`x` + `widthb`), `y2` (like `x2`), `width`, `height`, `widthb` (`width` + 2 * `border_width`), `heightb` (like `widthb`), `border_width`, `fullscreen`, `override_redirect`, `argb` (whether the window has an ARGB visual), `focused`, `wmwin` (whether the window looks like a WM window, i.e. has no child window with `WM_STATE` and is not override-redirected), `bounding_shaped`, `rounded_corners` (requires *--detect-rounded-corners*), `client` (ID of client window), `window_type` (window type in string), `leader` (ID of window leader), `name`, `class_g` (= `WM_CLASS[1]`), `class_i` (= `WM_CLASS[0]`), and `role`.
|
||||
|
||||
'CLIENT/FRAME' is a single `@` if the window attribute should be be looked up on client window, nothing if on frame window;
|
||||
|
||||
'INDEX' (optional) is the index number of the property to look up. For example, `[2]` means look at the third value in the property. If not specified, the first value (index `[0]`) is used implicitly. Use the special value `[*]` to perform matching against all available property values using logical OR. Do not specify it for predefined targets.
|
||||
|
||||
'FORMAT' (optional) specifies the format of the property, 8, 16, or 32. On absence we use format X reports. Do not specify it for predefined or string targets.
|
||||
|
||||
'TYPE' is a single character representing the type of the property to match for: `c` for 'CARDINAL', `a` for 'ATOM', `w` for 'WINDOW', `d` for 'DRAWABLE', `s` for 'STRING' (and any other string types, such as 'UTF8_STRING'). Do not specify it for predefined targets.
|
||||
|
||||
'OP QUALIFIER' (optional), applicable only for equals operator, could be `?` (ignore-case).
|
||||
|
||||
'MATCH TYPE' (optional), applicable only for equals operator, could be nothing (exact match), `*` (match anywhere), `^` (match from start), `%` (wildcard), or `~` (PCRE regular expression).
|
||||
|
||||
'OPERATOR' is one of `=` (equals), `<`, `>`, `<=`, `=>`, or nothing (exists). Exists operator checks whether a property exists on a window (but for predefined targets, exists means != 0 then).
|
||||
|
||||
'PATTERN' is either an integer or a string enclosed by single or double quotes. Python-3-style escape sequences and raw string are supported in the string format.
|
||||
|
||||
Supported logical operators are `&&` (and) and `||` (or). `&&` has higher precedence than `||`, left-to-right associativity. Use parentheses to change precedence.
|
||||
|
||||
Examples:
|
||||
|
||||
# If the window is focused
|
||||
focused
|
||||
focused = 1
|
||||
# If the window is not override-redirected
|
||||
!override_redirect
|
||||
override_redirect = false
|
||||
override_redirect != true
|
||||
override_redirect != 1
|
||||
# If the window is a menu
|
||||
window_type *= "menu"
|
||||
_NET_WM_WINDOW_TYPE@:a *= "MENU"
|
||||
# If the window is marked hidden: _NET_WM_STATE contains _NET_WM_STATE_HIDDEN
|
||||
_NET_WM_STATE@[*]:a = "_NET_WM_STATE_HIDDEN"
|
||||
# If the window is marked sticky: _NET_WM_STATE contains an atom that contains
|
||||
# "sticky", ignore case
|
||||
_NET_WM_STATE@[*]:a *?= "sticky"
|
||||
# If the window name contains "Firefox", ignore case
|
||||
name *?= "Firefox"
|
||||
_NET_WM_NAME@:s *?= "Firefox"
|
||||
# If the window name ends with "Firefox"
|
||||
name %= "*Firefox"
|
||||
name ~= "Firefox$"
|
||||
# If the window has a property _COMPTON_SHADOW with value 0, type CARDINAL,
|
||||
# format 32, value 0, on its frame window
|
||||
_COMPTON_SHADOW:32c = 0
|
||||
# If the third value of _NET_FRAME_EXTENTS is less than 20, or there's no
|
||||
# _NET_FRAME_EXTENTS property on client window
|
||||
_NET_FRAME_EXTENTS@[2]:32c < 20 || !_NET_FRAME_EXTENTS@:32c
|
||||
# The pattern here will be parsed as "dd4"
|
||||
name = "\x64\x64\o64"
|
||||
# The pattern here will be parsed as "\x64\x64\x64"
|
||||
name = r"\x64\x64\o64"
|
||||
|
||||
|
||||
LEGACY FORMAT OF CONDITIONS
|
||||
---------------------------
|
||||
|
||||
This is the old condition format we once used. Support of this format might be removed in the future.
|
||||
|
||||
condition = TARGET:TYPE[FLAGS]:PATTERN
|
||||
|
||||
'TARGET' is one of "n" (window name), "i" (window class instance), "g" (window general class), and "r" (window role).
|
||||
|
||||
'TYPE' is one of "e" (exact match), "a" (match anywhere), "s" (match from start), "w" (wildcard), and "p" (PCRE regular expressions, if compiled with the support).
|
||||
|
||||
'FLAGS' could be a series of flags. Currently the only defined flag is "i" (ignore case).
|
||||
|
||||
'PATTERN' is the actual pattern string.
|
||||
|
||||
CONFIGURATION FILES
|
||||
-------------------
|
||||
picom could read from a configuration file if libconfig support is compiled in. If *--config* is not used, picom will seek for a configuration file in `$XDG_CONFIG_HOME/picom.conf` (`~/.config/picom.conf`, usually), then `$XDG_CONFIG_HOME/picom/picom.conf`, then `$XDG_CONFIG_DIRS/picom.conf` (often `/etc/xdg/picom.conf`), then `$XDG_CONFIG_DIRS/picom/picom.conf`.
|
||||
|
||||
picom uses general libconfig configuration file format. A sample configuration file is available as `picom.sample.conf` in the source tree. Most of commandline switches can be used as options in configuration file as well. For example, *--vsync* option documented above can be set in the configuration file using `vsync = `. Command line options will always overwrite the settings in the configuration file.
|
||||
|
||||
Window-type-specific settings are exposed only in configuration file and has the following format:
|
||||
|
||||
------------
|
||||
wintypes:
|
||||
{
|
||||
WINDOW_TYPE = { fade = BOOL; shadow = BOOL; opacity = FLOAT; focus = BOOL; blur-background = BOOL; full-shadow = BOOL; clip-shadow-above = BOOL; redir-ignore = BOOL; };
|
||||
};
|
||||
------------
|
||||
|
||||
'WINDOW_TYPE' is one of the 15 window types defined in EWMH standard: "unknown", "desktop", "dock", "toolbar", "menu", "utility", "splash", "dialog", "normal", "dropdown_menu", "popup_menu", "tooltip", "notification", "combo", and "dnd".
|
||||
|
||||
Following per window-type options are available: ::
|
||||
|
||||
fade, shadow:::
|
||||
Controls window-type-specific shadow and fade settings.
|
||||
|
||||
opacity:::
|
||||
Controls default opacity of the window type.
|
||||
|
||||
focus:::
|
||||
Controls whether the window of this type is to be always considered focused. (By default, all window types except "normal" and "dialog" has this on.)
|
||||
|
||||
blur-background:::
|
||||
Controls wether the window of this type will have its transparent background blurred.
|
||||
|
||||
full-shadow:::
|
||||
Controls whether shadow is drawn under the parts of the window that you normally won't be able to see. Useful when the window has parts of it transparent, and you want shadows in those areas.
|
||||
|
||||
clip-shadow-above:::
|
||||
Controls wether shadows that would have been drawn above the window should be clipped. Useful for dock windows that should have no shadow painted on top.
|
||||
|
||||
redir-ignore:::
|
||||
Controls whether this type of windows should cause screen to become redirected again after been unredirected. If you have *--unredir-if-possible* set, and doesn't want certain window to cause unnecessary screen redirection, you can set this to `true`.
|
||||
|
||||
BLUR
|
||||
----
|
||||
You can configure how the window background is blurred using a 'blur' section in your configuration file. Here is an example:
|
||||
|
||||
--------
|
||||
blur:
|
||||
{
|
||||
method = "gaussian";
|
||||
size = 10;
|
||||
deviation = 5.0;
|
||||
};
|
||||
--------
|
||||
|
||||
Available options of the 'blur' section are: ::
|
||||
|
||||
*method*:::
|
||||
A string. Controls the blur method. Corresponds to the *--blur-method* command line option. Available choices are:
|
||||
'none' to disable blurring; 'gaussian' for gaussian blur; 'box' for box blur; 'kernel' for convolution blur with a custom kernel; 'dual_kawase' for dual-filter kawase blur.
|
||||
Note: 'gaussian', 'box' and 'dual_kawase' blur methods are only supported by the experimental backends.
|
||||
(default: none)
|
||||
|
||||
*size*:::
|
||||
An integer. The size of the blur kernel, required by 'gaussian' and 'box' blur methods. For the 'kernel' method, the size is included in the kernel. Corresponds to the *--blur-size* command line option (default: 3).
|
||||
|
||||
*deviation*:::
|
||||
A floating point number. The standard deviation for the 'gaussian' blur method. Corresponds to the *--blur-deviation* command line option (default: 0.84089642).
|
||||
|
||||
*strength*:::
|
||||
An integer in the range 0-20. The strength of the 'dual_kawase' blur method. Corresponds to the *--blur-strength* command line option. If set to zero, the value requested by *--blur-size* is approximated (default: 5).
|
||||
|
||||
*kernel*:::
|
||||
A string. The kernel to use for the 'kernel' blur method, specified in the same format as the *--blur-kerns* option. Corresponds to the *--blur-kerns* command line option.
|
||||
|
||||
SIGNALS
|
||||
-------
|
||||
|
||||
* picom reinitializes itself upon receiving `SIGUSR1`.
|
||||
|
||||
D-BUS API
|
||||
---------
|
||||
|
||||
It's possible to control picom via D-Bus messages, by running picom with *--dbus* and send messages to `com.github.chjj.compton.<DISPLAY>`. `<DISPLAY>` is the display used by picom, with all non-alphanumeric characters transformed to underscores. For `DISPLAY=:0.0` you should use `com.github.chjj.compton._0_0`, for example.
|
||||
|
||||
The D-Bus methods and signals are not yet stable, thus undocumented right now.
|
||||
|
||||
EXAMPLES
|
||||
--------
|
||||
|
||||
* Disable configuration file parsing:
|
||||
+
|
||||
------------
|
||||
$ picom --config /dev/null
|
||||
------------
|
||||
|
||||
* Run picom with client-side shadow and fading:
|
||||
+
|
||||
------------
|
||||
$ picom -cf
|
||||
------------
|
||||
|
||||
* Same thing as above, plus making inactive windows 80% transparent, making frame 80% transparent, don't fade on window open/close, and fork to background:
|
||||
+
|
||||
------------
|
||||
$ picom -bcf -i 0.8 -e 0.8 --no-fading-openclose
|
||||
------------
|
||||
|
||||
* Draw white shadows:
|
||||
+
|
||||
------------
|
||||
$ picom -c --shadow-red 1 --shadow-green 1 --shadow-blue 1
|
||||
------------
|
||||
|
||||
* Avoid drawing shadows on wbar window:
|
||||
+
|
||||
------------
|
||||
$ picom -c --shadow-exclude 'class_g = "wbar"'
|
||||
------------
|
||||
|
||||
* Enable VSync with GLX backend:
|
||||
+
|
||||
------------
|
||||
$ picom --backend glx --vsync
|
||||
------------
|
||||
|
||||
BUGS
|
||||
----
|
||||
Please submit bug reports to <https://github.com/yshui/picom>.
|
||||
|
||||
Out dated information in this man page is considered a bug.
|
||||
|
||||
RESOURCES
|
||||
---------
|
||||
Homepage: <https://github.com/yshui/picom>
|
||||
|
||||
SEE ALSO
|
||||
--------
|
||||
*xcompmgr*(1), link:picom-trans.html[*picom-trans*(1)]
|
||||
@@ -0,0 +1,76 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
|
||||
<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="1024px" height="1024px" viewBox="0 0 1024 1024" enable-background="new 0 0 1024 1024" xml:space="preserve">
|
||||
<g id="Gear_Shadow">
|
||||
<path opacity="0.15" fill="#4D4D4D" d="M578.36,85.13c-12.18-1.9-24.53-3.28-37.02-4.13h-58.66c-12.56,0.85-24.98,2.25-37.23,4.16
|
||||
l-17.91,89.79c-33.35,8.74-64.74,22.12-93.35,39.78l-76.69-51.23c-36.03,26.43-67.86,58.28-94.25,94.34l52.54,78.77
|
||||
c-16.01,27.81-28.71,58.05-36.5,90.05l-94.08,18.58C81.78,467.02,80,489.31,80,512c0,22.76,1.79,45.13,5.23,66.96l20,20l80.96,16
|
||||
c7.96,24.45,18.65,47.71,31.52,69.43l-54.44,81.8c13.29,18.15,27.96,35.24,43.85,51.1l19.5,19.5
|
||||
c15.86,15.89,32.94,30.56,51.08,43.85l81.89-54.57c21.72,12.86,44.99,23.71,69.44,31.72l16.02,80.97l20,20
|
||||
c21.84,3.44,44.2,5.23,66.96,5.23c22.69,0,44.99-1.78,66.76-5.19l18.59-94.08c32-7.79,62.26-20.26,90.07-36.27l78.69,52.35
|
||||
c36.1-26.42,68-58.28,94.45-94.36l-51.05-76.6c17.66-28.62,30.82-60.02,39.56-93.37l89.78-17.92c1.92-12.25,3.31-24.67,4.16-37.23
|
||||
v-58.66c-0.85-12.49-2.23-24.84-4.13-37.02l-20-20l-72.49-14.46c-8.28-28.39-19.99-55.26-34.91-80.1l49.1-73.5
|
||||
c-13.34-18.2-28.07-35.32-44.02-51.22l-19-19c-15.91-15.95-33.04-30.68-51.25-44.02l-73.41,48.96
|
||||
c-24.84-14.92-51.71-26.47-80.09-34.7l-14.45-72.48L578.36,85.13z"/>
|
||||
</g>
|
||||
<g id="Gear_1_">
|
||||
<g>
|
||||
<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="206.9023" y1="817.0986" x2="817.0984" y2="206.9026">
|
||||
<stop offset="0" style="stop-color:#00FFFF"/>
|
||||
<stop offset="1" style="stop-color:#D9E021"/>
|
||||
</linearGradient>
|
||||
<path fill="url(#SVGID_1_)" d="M938.84,578.56c1.92-12.25,3.31-24.67,4.16-37.23v-58.66c-0.85-12.49-2.23-24.84-4.13-37.02
|
||||
l-88-17.56c-8.28-34.66-21.56-67.28-39.4-97.01l49.1-73.5c-26.41-36.02-58.24-67.85-94.27-94.24l-73.41,48.96
|
||||
c-29.72-17.85-62.34-30.9-97-39.18l-17.54-88c-12.18-1.9-24.53-3.28-37.02-4.13h-58.66c-12.56,0.85-24.98,2.25-37.23,4.16
|
||||
l-17.91,89.79c-33.35,8.74-64.74,22.12-93.35,39.78l-76.69-51.23c-36.03,26.43-67.86,58.28-94.25,94.34l52.54,78.77
|
||||
c-16.01,27.81-28.71,58.05-36.5,90.05l-94.08,18.58C81.78,467.02,80,489.31,80,512c0,22.76,1.79,45.13,5.23,66.96l95.91,18.95
|
||||
c8.2,30.72,20.74,59.76,36.56,86.48l-54.44,81.8c26.44,36.11,58.33,68.01,94.43,94.46l81.89-54.57
|
||||
c26.72,15.82,55.77,28.59,86.49,36.79l18.97,95.91c21.84,3.44,44.2,5.23,66.96,5.23c22.69,0,44.99-1.78,66.76-5.19l18.59-94.08
|
||||
c32-7.79,62.26-20.26,90.07-36.27l78.69,52.35c36.1-26.42,68-58.28,94.45-94.36l-51.05-76.6c17.66-28.62,30.82-60.02,39.56-93.37
|
||||
L938.84,578.56z"/>
|
||||
</g>
|
||||
<g>
|
||||
<linearGradient id="SVGID_2_" gradientUnits="userSpaceOnUse" x1="206.9023" y1="817.0986" x2="817.0984" y2="206.9026">
|
||||
<stop offset="0" style="stop-color:#00E6E6"/>
|
||||
<stop offset="1" style="stop-color:#77E1E3"/>
|
||||
</linearGradient>
|
||||
<path fill="url(#SVGID_2_)" d="M938.84,578.56c1.92-12.25,3.31-24.67,4.16-37.23v-58.66c-0.85-12.49-2.23-24.84-4.13-37.02
|
||||
l-88-17.56c-8.28-34.66-21.56-67.28-39.4-97.01l49.1-73.5c-26.41-36.02-58.24-67.85-94.27-94.24l-73.41,48.96
|
||||
c-29.72-17.85-62.34-30.9-97-39.18l-17.54-88c-12.18-1.9-24.53-3.28-37.02-4.13h-58.66c-12.56,0.85-24.98,2.25-37.23,4.16
|
||||
l-17.91,89.79c-33.35,8.74-64.74,22.12-93.35,39.78l-76.69-51.23c-36.03,26.43-67.86,58.28-94.25,94.34l52.54,78.77
|
||||
c-16.01,27.81-28.71,58.05-36.5,90.05l-94.08,18.58C81.78,467.02,80,489.31,80,512c0,22.76,1.79,45.13,5.23,66.96l95.91,18.95
|
||||
c8.2,30.72,20.74,59.76,36.56,86.48l-54.44,81.8c26.44,36.11,58.33,68.01,94.43,94.46l81.89-54.57
|
||||
c26.72,15.82,55.77,28.59,86.49,36.79l18.97,95.91c21.84,3.44,44.2,5.23,66.96,5.23c22.69,0,44.99-1.78,66.76-5.19l18.59-94.08
|
||||
c32-7.79,62.26-20.26,90.07-36.27l78.69,52.35c36.1-26.42,68-58.28,94.45-94.36l-51.05-76.6c17.66-28.62,30.82-60.02,39.56-93.37
|
||||
L938.84,578.56z"/>
|
||||
</g>
|
||||
</g>
|
||||
<g id="C_Shadow">
|
||||
<linearGradient id="SVGID_3_" gradientUnits="userSpaceOnUse" x1="559.1299" y1="479.3999" x2="826.0795" y2="746.3495">
|
||||
<stop offset="0" style="stop-color:#4D4D4D"/>
|
||||
<stop offset="1" style="stop-color:#4D4D4D;stop-opacity:0"/>
|
||||
</linearGradient>
|
||||
<path opacity="0.5" fill="url(#SVGID_3_)" d="M939.57,573.54L720,353.97c-6.64-6.63-13.23-13.38-20.03-19.97l-69.18,69.33
|
||||
c-28.98-28.91-67.48-44.84-108.42-44.84c-84.64,0-153.51,68.86-153.51,153.51c0,84.64,68.86,153.51,153.51,153.51
|
||||
c40.94,0,79.44-15.92,108.42-44.84L686,676h0.25l27.57,27.57c14.67-14.68,32.28-26.37,51.54-34.1
|
||||
c19.38-7.78,40.28-11.45,61.14-10.91c9.38-19.73,16.9-40.49,22.56-62.08l89.78-17.92C939.1,576.89,939.33,575.21,939.57,573.54z"/>
|
||||
<linearGradient id="SVGID_4_" gradientUnits="userSpaceOnUse" x1="540.2842" y1="707.1182" x2="764.223" y2="931.057">
|
||||
<stop offset="0" style="stop-color:#4D4D4D"/>
|
||||
<stop offset="1" style="stop-color:#4D4D4D;stop-opacity:0"/>
|
||||
</linearGradient>
|
||||
<path opacity="0.5" fill="url(#SVGID_4_)" d="M713.97,703.85c-0.07-0.07-0.15-0.15-0.22-0.22c0.17-0.17,0.33-0.32,0.5-0.49
|
||||
c-0.14,0.14-0.29,0.28-0.44,0.43L686.25,676H686l14,14.03c-47.48,47.37-110.56,73.46-177.63,73.46
|
||||
c-59.95,0-116.68-20.85-161.96-59.09l220.86,221.65l16.07-81.33c32-7.79,62.26-20.26,90.07-36.27l78.69,52.35
|
||||
c20.03-14.65,38.75-30.99,55.98-48.79L713.97,703.85z"/>
|
||||
</g>
|
||||
<g id="C">
|
||||
<g>
|
||||
<g>
|
||||
<path fill="#FFFFFF" d="M522.37,763.49c-67.18,0-130.33-26.16-177.83-73.66c-47.5-47.5-73.66-110.66-73.66-177.83
|
||||
c0-67.18,26.16-130.33,73.66-177.83s110.66-73.66,177.83-73.66c67.07,0,130.15,26.09,177.63,73.46l-69.21,69.36
|
||||
c-28.98-28.91-67.48-44.84-108.42-44.84c-84.64,0-153.51,68.86-153.51,153.51c0,84.64,68.86,153.51,153.51,153.51
|
||||
c40.94,0,79.44-15.92,108.42-44.84L700,690.03C652.52,737.4,589.44,763.49,522.37,763.49z"/>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 5.7 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.4 KiB |
@@ -0,0 +1,83 @@
|
||||
project('picom', 'c', version: '9',
|
||||
default_options: ['c_std=c11'])
|
||||
|
||||
cc = meson.get_compiler('c')
|
||||
|
||||
# use project version by default
|
||||
version = 'v'+meson.project_version()
|
||||
|
||||
# use git describe if that's available
|
||||
git = find_program('git', required: false)
|
||||
if git.found()
|
||||
gitv = run_command('git', 'rev-parse', '--short=5', 'HEAD')
|
||||
if gitv.returncode() == 0
|
||||
version = 'vgit-'+gitv.stdout().strip()
|
||||
endif
|
||||
endif
|
||||
|
||||
add_global_arguments('-DCOMPTON_VERSION="'+version+'"', language: 'c')
|
||||
|
||||
if get_option('buildtype') == 'release'
|
||||
add_global_arguments('-DNDEBUG', language: 'c')
|
||||
endif
|
||||
|
||||
if get_option('sanitize')
|
||||
sanitizers = ['address', 'undefined']
|
||||
if cc.has_argument('-fsanitize=integer')
|
||||
sanitizers += ['integer']
|
||||
endif
|
||||
if cc.has_argument('-fsanitize=nullability')
|
||||
sanitizers += ['nullability']
|
||||
endif
|
||||
add_global_arguments('-fsanitize='+','.join(sanitizers), language: 'c')
|
||||
add_global_link_arguments('-fsanitize='+','.join(sanitizers), language: 'c')
|
||||
if cc.has_argument('-fno-sanitize=unsigned-integer-overflow')
|
||||
add_global_arguments('-fno-sanitize=unsigned-integer-overflow', language: 'c')
|
||||
endif
|
||||
endif
|
||||
|
||||
if get_option('modularize')
|
||||
if not cc.has_argument('-fmodules')
|
||||
error('option \'modularize\' requires clang')
|
||||
endif
|
||||
add_global_arguments(['-fmodules',
|
||||
'-fmodule-map-file='+
|
||||
meson.current_source_dir()+
|
||||
'/src/picom.modulemap'],
|
||||
language: 'c')
|
||||
endif
|
||||
|
||||
add_global_arguments('-D_GNU_SOURCE', language: 'c')
|
||||
|
||||
if cc.has_header('stdc-predef.h')
|
||||
add_global_arguments('-DHAS_STDC_PREDEF_H', language: 'c')
|
||||
endif
|
||||
|
||||
warns = [ 'all', 'cast-function-type', 'ignored-qualifiers', 'missing-parameter-type',
|
||||
'nonnull', 'shadow', 'no-type-limits', 'old-style-declaration', 'override-init',
|
||||
'sign-compare', 'type-limits', 'uninitialized', 'shift-negative-value',
|
||||
'unused-but-set-parameter', 'unused-parameter', 'implicit-fallthrough',
|
||||
'no-unknown-warning-option', 'no-missing-braces', 'conversion', 'empty-body' ]
|
||||
foreach w : warns
|
||||
if cc.has_argument('-W'+w)
|
||||
add_global_arguments('-W'+w, language: 'c')
|
||||
endif
|
||||
endforeach
|
||||
|
||||
test_h_dep = subproject('test.h').get_variable('test_h_dep')
|
||||
|
||||
subdir('src')
|
||||
subdir('man')
|
||||
|
||||
install_data('bin/picom-trans', install_dir: get_option('bindir'))
|
||||
install_data('picom.desktop', install_dir: 'share/applications')
|
||||
|
||||
if get_option('compton')
|
||||
install_data('compton.desktop', install_dir: 'share/applications')
|
||||
install_data('media/icons/48x48/compton.png',
|
||||
install_dir: 'share/icons/hicolor/48x48/apps')
|
||||
install_data('media/compton.svg',
|
||||
install_dir: 'share/icons/hicolor/scalable/apps')
|
||||
|
||||
meson.add_install_script('meson/install.sh')
|
||||
endif
|
||||
Executable
+11
@@ -0,0 +1,11 @@
|
||||
#!/bin/sh
|
||||
|
||||
if [ ! -e "${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton" ]; then
|
||||
echo "Linking picom to ${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton"
|
||||
ln -s picom "${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton"
|
||||
fi
|
||||
|
||||
if [ ! -e "${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton-trans" ]; then
|
||||
echo "Linking picom-trans to ${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton-trans"
|
||||
ln -s picom-trans "${MESON_INSTALL_DESTDIR_PREFIX}/bin/compton-trans"
|
||||
fi
|
||||
@@ -0,0 +1,18 @@
|
||||
option('sanitize', type: 'boolean', value: false, description: 'Build with sanitizers enabled (deprecated)')
|
||||
option('config_file', type: 'boolean', value: true, description: 'Enable config file support')
|
||||
option('regex', type: 'boolean', value: true, description: 'Enable regex support in window conditions')
|
||||
|
||||
option('vsync_drm', type: 'boolean', value: false, description: 'Enable support for using drm for vsync')
|
||||
|
||||
option('opengl', type: 'boolean', value: true, description: 'Enable features that require opengl (opengl backend, and opengl vsync methods)')
|
||||
option('dbus', type: 'boolean', value: true, description: 'Enable support for D-Bus remote control')
|
||||
|
||||
option('xrescheck', type: 'boolean', value: false, description: 'Enable X resource leak checker (for debug only)')
|
||||
|
||||
option('compton', type: 'boolean', value: true, description: 'Install backwards compat with compton')
|
||||
|
||||
option('with_docs', type: 'boolean', value: false, description: 'Build documentation and man pages')
|
||||
|
||||
option('modularize', type: 'boolean', value: false, description: 'Build with clang\'s module system')
|
||||
|
||||
option('unittest', type: 'boolean', value: false, description: 'Enable unittests in the code')
|
||||
@@ -0,0 +1,11 @@
|
||||
[Desktop Entry]
|
||||
Version=1.0
|
||||
Type=Application
|
||||
NoDisplay=true
|
||||
Name=picom (dbus)
|
||||
GenericName=X compositor (dbus)
|
||||
Comment=An X compositor with dbus backend enabled
|
||||
Categories=Utility;
|
||||
Keywords=compositor;composite manager;window effects;transparency;opacity;
|
||||
TryExec=picom
|
||||
Exec=picom --dbus
|
||||
@@ -0,0 +1,13 @@
|
||||
[Desktop Entry]
|
||||
Version=1.0
|
||||
Type=Application
|
||||
NoDisplay=false
|
||||
Name=picom
|
||||
GenericName=X compositor
|
||||
Comment=An X compositor
|
||||
Categories=Utility;
|
||||
Keywords=compositor;composite manager;window effects;transparency;opacity;
|
||||
TryExec=picom
|
||||
Exec=picom
|
||||
# Thanks to quequotion for providing this file!
|
||||
Icon=picom
|
||||
@@ -0,0 +1,455 @@
|
||||
#################################
|
||||
# Shadows #
|
||||
#################################
|
||||
|
||||
|
||||
# Enabled client-side shadows on windows. Note desktop windows
|
||||
# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow,
|
||||
# unless explicitly requested using the wintypes option.
|
||||
#
|
||||
# shadow = false
|
||||
shadow = true;
|
||||
|
||||
# The blur radius for shadows, in pixels. (defaults to 12)
|
||||
# shadow-radius = 12
|
||||
shadow-radius = 7;
|
||||
|
||||
# The opacity of shadows. (0.0 - 1.0, defaults to 0.75)
|
||||
# shadow-opacity = .75
|
||||
|
||||
# The left offset for shadows, in pixels. (defaults to -15)
|
||||
# shadow-offset-x = -15
|
||||
shadow-offset-x = -7;
|
||||
|
||||
# The top offset for shadows, in pixels. (defaults to -15)
|
||||
# shadow-offset-y = -15
|
||||
shadow-offset-y = -7;
|
||||
|
||||
# Red color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
# shadow-red = 0
|
||||
|
||||
# Green color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
# shadow-green = 0
|
||||
|
||||
# Blue color value of shadow (0.0 - 1.0, defaults to 0).
|
||||
# shadow-blue = 0
|
||||
|
||||
# Hex string color value of shadow (#000000 - #FFFFFF, defaults to #000000). This option will override options set shadow-(red/green/blue)
|
||||
# shadow-color = "#000000"
|
||||
|
||||
# Specify a list of conditions of windows that should have no shadow.
|
||||
#
|
||||
# examples:
|
||||
# shadow-exclude = "n:e:Notification";
|
||||
#
|
||||
# shadow-exclude = []
|
||||
shadow-exclude = [
|
||||
"name = 'Notification'",
|
||||
"class_g = 'Conky'",
|
||||
"class_g ?= 'Notify-osd'",
|
||||
"class_g = 'Cairo-clock'",
|
||||
"_GTK_FRAME_EXTENTS@:c"
|
||||
];
|
||||
|
||||
# Specify a list of conditions of windows that should have no shadow painted over, such as a dock window.
|
||||
# clip-shadow-above = []
|
||||
|
||||
# Specify a X geometry that describes the region in which shadow should not
|
||||
# be painted in, such as a dock window region. Use
|
||||
# shadow-exclude-reg = "x10+0+0"
|
||||
# for example, if the 10 pixels on the bottom of the screen should not have shadows painted on.
|
||||
#
|
||||
# shadow-exclude-reg = ""
|
||||
|
||||
# Crop shadow of a window fully on a particular Xinerama screen to the screen.
|
||||
# xinerama-shadow-crop = false
|
||||
|
||||
|
||||
#################################
|
||||
# Fading #
|
||||
#################################
|
||||
|
||||
|
||||
# Fade windows in/out when opening/closing and when opacity changes,
|
||||
# unless no-fading-openclose is used.
|
||||
# fading = false
|
||||
fading = true;
|
||||
|
||||
# Opacity change between steps while fading in. (0.01 - 1.0, defaults to 0.028)
|
||||
# fade-in-step = 0.028
|
||||
fade-in-step = 0.03;
|
||||
|
||||
# Opacity change between steps while fading out. (0.01 - 1.0, defaults to 0.03)
|
||||
# fade-out-step = 0.03
|
||||
fade-out-step = 0.03;
|
||||
|
||||
# The time between steps in fade step, in milliseconds. (> 0, defaults to 10)
|
||||
# fade-delta = 10
|
||||
|
||||
# Specify a list of conditions of windows that should not be faded.
|
||||
# fade-exclude = []
|
||||
|
||||
# Do not fade on window open/close.
|
||||
# no-fading-openclose = false
|
||||
|
||||
# Do not fade destroyed ARGB windows with WM frame. Workaround of bugs in Openbox, Fluxbox, etc.
|
||||
# no-fading-destroyed-argb = false
|
||||
|
||||
|
||||
#################################
|
||||
# Transparency / Opacity #
|
||||
#################################
|
||||
|
||||
|
||||
# Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0)
|
||||
# inactive-opacity = 1
|
||||
inactive-opacity = 0.8;
|
||||
|
||||
# Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default)
|
||||
# frame-opacity = 1.0
|
||||
frame-opacity = 0.7;
|
||||
|
||||
# Let inactive opacity set by -i override the '_NET_WM_WINDOW_OPACITY' values of windows.
|
||||
# inactive-opacity-override = true
|
||||
inactive-opacity-override = false;
|
||||
|
||||
# Default opacity for active windows. (0.0 - 1.0, defaults to 1.0)
|
||||
# active-opacity = 1.0
|
||||
|
||||
# Dim inactive windows. (0.0 - 1.0, defaults to 0.0)
|
||||
# inactive-dim = 0.0
|
||||
|
||||
# Specify a list of conditions of windows that should never be considered focused.
|
||||
# focus-exclude = []
|
||||
focus-exclude = [ "class_g = 'Cairo-clock'" ];
|
||||
|
||||
# Use fixed inactive dim value, instead of adjusting according to window opacity.
|
||||
# inactive-dim-fixed = 1.0
|
||||
|
||||
# Specify a list of opacity rules, in the format `PERCENT:PATTERN`,
|
||||
# like `50:name *= "Firefox"`. picom-trans is recommended over this.
|
||||
# Note we don't make any guarantee about possible conflicts with other
|
||||
# programs that set '_NET_WM_WINDOW_OPACITY' on frame or client windows.
|
||||
# example:
|
||||
# opacity-rule = [ "80:class_g = 'URxvt'" ];
|
||||
#
|
||||
# opacity-rule = []
|
||||
|
||||
|
||||
#################################
|
||||
# Corners #
|
||||
#################################
|
||||
|
||||
# Sets the radius of rounded window corners. When > 0, the compositor will
|
||||
# round the corners of windows. Does not interact well with
|
||||
# `transparent-clipping`.
|
||||
corner-radius = 0
|
||||
|
||||
# Exclude conditions for rounded corners.
|
||||
rounded-corners-exclude = [
|
||||
"window_type = 'dock'",
|
||||
"window_type = 'desktop'"
|
||||
];
|
||||
|
||||
|
||||
#################################
|
||||
# Background-Blurring #
|
||||
#################################
|
||||
|
||||
|
||||
# Parameters for background blurring, see the *BLUR* section for more information.
|
||||
# blur-method =
|
||||
# blur-size = 12
|
||||
#
|
||||
# blur-deviation = false
|
||||
#
|
||||
# blur-strength = 5
|
||||
|
||||
# Blur background of semi-transparent / ARGB windows.
|
||||
# Bad in performance, with driver-dependent behavior.
|
||||
# The name of the switch may change without prior notifications.
|
||||
#
|
||||
# blur-background = false
|
||||
|
||||
# Blur background of windows when the window frame is not opaque.
|
||||
# Implies:
|
||||
# blur-background
|
||||
# Bad in performance, with driver-dependent behavior. The name may change.
|
||||
#
|
||||
# blur-background-frame = false
|
||||
|
||||
|
||||
# Use fixed blur strength rather than adjusting according to window opacity.
|
||||
# blur-background-fixed = false
|
||||
|
||||
|
||||
# Specify the blur convolution kernel, with the following format:
|
||||
# example:
|
||||
# blur-kern = "5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1";
|
||||
#
|
||||
# blur-kern = ""
|
||||
blur-kern = "3x3box";
|
||||
|
||||
|
||||
# Exclude conditions for background blur.
|
||||
# blur-background-exclude = []
|
||||
blur-background-exclude = [
|
||||
"window_type = 'dock'",
|
||||
"window_type = 'desktop'",
|
||||
"_GTK_FRAME_EXTENTS@:c"
|
||||
];
|
||||
|
||||
#################################
|
||||
# General Settings #
|
||||
#################################
|
||||
|
||||
# Enable remote control via D-Bus. See the man page for more details.
|
||||
# dbus = true
|
||||
|
||||
# Daemonize process. Fork to background after initialization. Causes issues with certain (badly-written) drivers.
|
||||
# daemon = false
|
||||
|
||||
# Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`.
|
||||
# `xrender` is the default one.
|
||||
#
|
||||
# backend = "glx"
|
||||
backend = "xrender";
|
||||
|
||||
# Enable/disable VSync.
|
||||
# vsync = false
|
||||
vsync = true;
|
||||
|
||||
# Enable remote control via D-Bus. See the *D-BUS API* section below for more details.
|
||||
# dbus = false
|
||||
|
||||
# Try to detect WM windows (a non-override-redirect window with no
|
||||
# child that has 'WM_STATE') and mark them as active.
|
||||
#
|
||||
# mark-wmwin-focused = false
|
||||
mark-wmwin-focused = true;
|
||||
|
||||
# Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused.
|
||||
# mark-ovredir-focused = false
|
||||
mark-ovredir-focused = true;
|
||||
|
||||
# Try to detect windows with rounded corners and don't consider them
|
||||
# shaped windows. The accuracy is not very high, unfortunately.
|
||||
#
|
||||
# detect-rounded-corners = false
|
||||
detect-rounded-corners = true;
|
||||
|
||||
# Detect '_NET_WM_WINDOW_OPACITY' on client windows, useful for window managers
|
||||
# not passing '_NET_WM_WINDOW_OPACITY' of client windows to frame windows.
|
||||
#
|
||||
# detect-client-opacity = false
|
||||
detect-client-opacity = true;
|
||||
|
||||
# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window,
|
||||
# rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy,
|
||||
# provided that the WM supports it.
|
||||
#
|
||||
# use-ewmh-active-win = false
|
||||
|
||||
# Unredirect all windows if a full-screen opaque window is detected,
|
||||
# to maximize performance for full-screen windows. Known to cause flickering
|
||||
# when redirecting/unredirecting windows.
|
||||
#
|
||||
# unredir-if-possible = false
|
||||
|
||||
# Delay before unredirecting the window, in milliseconds. Defaults to 0.
|
||||
# unredir-if-possible-delay = 0
|
||||
|
||||
# Conditions of windows that shouldn't be considered full-screen for unredirecting screen.
|
||||
# unredir-if-possible-exclude = []
|
||||
|
||||
# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows
|
||||
# in the same group focused at the same time.
|
||||
#
|
||||
# detect-transient = false
|
||||
detect-transient = true;
|
||||
|
||||
# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same
|
||||
# group focused at the same time. This usually means windows from the same application
|
||||
# will be considered focused or unfocused at the same time.
|
||||
# 'WM_TRANSIENT_FOR' has higher priority if detect-transient is enabled, too.
|
||||
#
|
||||
# detect-client-leader = false
|
||||
|
||||
# Resize damaged region by a specific number of pixels.
|
||||
# A positive value enlarges it while a negative one shrinks it.
|
||||
# If the value is positive, those additional pixels will not be actually painted
|
||||
# to screen, only used in blur calculation, and such. (Due to technical limitations,
|
||||
# with use-damage, those pixels will still be incorrectly painted to screen.)
|
||||
# Primarily used to fix the line corruption issues of blur,
|
||||
# in which case you should use the blur radius value here
|
||||
# (e.g. with a 3x3 kernel, you should use `--resize-damage 1`,
|
||||
# with a 5x5 one you use `--resize-damage 2`, and so on).
|
||||
# May or may not work with *--glx-no-stencil*. Shrinking doesn't function correctly.
|
||||
#
|
||||
# resize-damage = 1
|
||||
|
||||
# Specify a list of conditions of windows that should be painted with inverted color.
|
||||
# Resource-hogging, and is not well tested.
|
||||
#
|
||||
# invert-color-include = []
|
||||
|
||||
# GLX backend: Avoid using stencil buffer, useful if you don't have a stencil buffer.
|
||||
# Might cause incorrect opacity when rendering transparent content (but never
|
||||
# practically happened) and may not work with blur-background.
|
||||
# My tests show a 15% performance boost. Recommended.
|
||||
#
|
||||
# glx-no-stencil = false
|
||||
|
||||
# GLX backend: Avoid rebinding pixmap on window damage.
|
||||
# Probably could improve performance on rapid window content changes,
|
||||
# but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.).
|
||||
# Recommended if it works.
|
||||
#
|
||||
# glx-no-rebind-pixmap = false
|
||||
|
||||
# Disable the use of damage information.
|
||||
# This cause the whole screen to be redrawn everytime, instead of the part of the screen
|
||||
# has actually changed. Potentially degrades the performance, but might fix some artifacts.
|
||||
# The opposing option is use-damage
|
||||
#
|
||||
# no-use-damage = false
|
||||
use-damage = true;
|
||||
|
||||
# Use X Sync fence to sync clients' draw calls, to make sure all draw
|
||||
# calls are finished before picom starts drawing. Needed on nvidia-drivers
|
||||
# with GLX backend for some users.
|
||||
#
|
||||
# xrender-sync-fence = false
|
||||
|
||||
# GLX backend: Use specified GLSL fragment shader for rendering window contents.
|
||||
# See `compton-default-fshader-win.glsl` and `compton-fake-transparency-fshader-win.glsl`
|
||||
# in the source tree for examples.
|
||||
#
|
||||
# glx-fshader-win = ""
|
||||
|
||||
# Force all windows to be painted with blending. Useful if you
|
||||
# have a glx-fshader-win that could turn opaque pixels transparent.
|
||||
#
|
||||
# force-win-blend = false
|
||||
|
||||
# Do not use EWMH to detect fullscreen windows.
|
||||
# Reverts to checking if a window is fullscreen based only on its size and coordinates.
|
||||
#
|
||||
# no-ewmh-fullscreen = false
|
||||
|
||||
# Dimming bright windows so their brightness doesn't exceed this set value.
|
||||
# Brightness of a window is estimated by averaging all pixels in the window,
|
||||
# so this could comes with a performance hit.
|
||||
# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled. (default: 1.0)
|
||||
#
|
||||
# max-brightness = 1.0
|
||||
|
||||
# Make transparent windows clip other windows like non-transparent windows do,
|
||||
# instead of blending on top of them.
|
||||
#
|
||||
# transparent-clipping = false
|
||||
|
||||
# Set the log level. Possible values are:
|
||||
# "trace", "debug", "info", "warn", "error"
|
||||
# in increasing level of importance. Case doesn't matter.
|
||||
# If using the "TRACE" log level, it's better to log into a file
|
||||
# using *--log-file*, since it can generate a huge stream of logs.
|
||||
#
|
||||
# log-level = "debug"
|
||||
log-level = "warn";
|
||||
|
||||
# Set the log file.
|
||||
# If *--log-file* is never specified, logs will be written to stderr.
|
||||
# Otherwise, logs will to written to the given file, though some of the early
|
||||
# logs might still be written to the stderr.
|
||||
# When setting this option from the config file, it is recommended to use an absolute path.
|
||||
#
|
||||
# log-file = "/path/to/your/log/file"
|
||||
|
||||
# Show all X errors (for debugging)
|
||||
# show-all-xerrors = false
|
||||
|
||||
# Write process ID to a file.
|
||||
# write-pid-path = "/path/to/your/log/file"
|
||||
|
||||
# Window type settings
|
||||
#
|
||||
# 'WINDOW_TYPE' is one of the 15 window types defined in EWMH standard:
|
||||
# "unknown", "desktop", "dock", "toolbar", "menu", "utility",
|
||||
# "splash", "dialog", "normal", "dropdown_menu", "popup_menu",
|
||||
# "tooltip", "notification", "combo", and "dnd".
|
||||
#
|
||||
# Following per window-type options are available: ::
|
||||
#
|
||||
# fade, shadow:::
|
||||
# Controls window-type-specific shadow and fade settings.
|
||||
#
|
||||
# opacity:::
|
||||
# Controls default opacity of the window type.
|
||||
#
|
||||
# focus:::
|
||||
# Controls whether the window of this type is to be always considered focused.
|
||||
# (By default, all window types except "normal" and "dialog" has this on.)
|
||||
#
|
||||
# full-shadow:::
|
||||
# Controls whether shadow is drawn under the parts of the window that you
|
||||
# normally won't be able to see. Useful when the window has parts of it
|
||||
# transparent, and you want shadows in those areas.
|
||||
#
|
||||
# clip-shadow-above:::
|
||||
# Controls wether shadows that would have been drawn above the window should
|
||||
# be clipped. Useful for dock windows that should have no shadow painted on top.
|
||||
#
|
||||
# redir-ignore:::
|
||||
# Controls whether this type of windows should cause screen to become
|
||||
# redirected again after been unredirected. If you have unredir-if-possible
|
||||
# set, and doesn't want certain window to cause unnecessary screen redirection,
|
||||
# you can set this to `true`.
|
||||
#
|
||||
wintypes:
|
||||
{
|
||||
tooltip = { fade = true; shadow = true; opacity = 0.75; focus = true; full-shadow = false; };
|
||||
dock = { shadow = false; clip-shadow-above = true; }
|
||||
dnd = { shadow = false; }
|
||||
menu = { animation = "slide-down"; }
|
||||
popup_menu = { animation = "slide-down"; opacity = 0.8; }
|
||||
dropdown_menu = { animation = "slide-down"; opacity = 0.8; }
|
||||
toolbar = { animation = "none"; }
|
||||
};
|
||||
|
||||
#################################
|
||||
# Animation Settings #
|
||||
#################################
|
||||
|
||||
animations = true;
|
||||
|
||||
# Values can be none, auto, fly-in, zoom, squeeze, slide-up, slide-down, slide-left, slide-right
|
||||
animation-for-open-window = "squeeze";
|
||||
animation-for-transient-window = "slide-down";
|
||||
animation-for-unmap-window = "auto";
|
||||
animation-for-workspace-switch-in = "auto";
|
||||
animation-for-workspace-switch-out = "auto";
|
||||
|
||||
# Stiffness (a.k.a. tension) parameter for spring-based animation (default: 200.0).
|
||||
animation-stiffness = 1000;
|
||||
|
||||
# Dampening (a.k.a. friction) parameter for spring-based animation (default: 25.0).
|
||||
animation-dampening = 50;
|
||||
|
||||
# Mass parameter for spring-based animation (default: 1.0).
|
||||
animation-window-mass = 1;
|
||||
|
||||
# The time between steps in animation, in milliseconds. (> 0, defaults to 10).
|
||||
animation-delta = 7;
|
||||
|
||||
# Force animations to go step by step even if cpu usage is high
|
||||
animation-force-steps = true;
|
||||
|
||||
# Whether to clamp animations (default: true).
|
||||
#animation-clamping = false;
|
||||
|
||||
# Specify a list of conditions of windows that should have no animations.
|
||||
animation-exclude = [
|
||||
"class_g *= 'flameshot'",
|
||||
"class_g *= 'i3lock'"
|
||||
];
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <string.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "atom.h"
|
||||
#include "common.h"
|
||||
#include "utils.h"
|
||||
#include "log.h"
|
||||
|
||||
static inline void *atom_getter(void *ud, const char *atom_name, int *err) {
|
||||
xcb_connection_t *c = ud;
|
||||
xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(
|
||||
c, xcb_intern_atom(c, 0, to_u16_checked(strlen(atom_name)), atom_name), NULL);
|
||||
|
||||
xcb_atom_t atom = XCB_NONE;
|
||||
if (reply) {
|
||||
log_debug("Atom %s is %d", atom_name, reply->atom);
|
||||
atom = reply->atom;
|
||||
free(reply);
|
||||
} else {
|
||||
log_error("Failed to intern atoms");
|
||||
*err = 1;
|
||||
}
|
||||
return (void *)(intptr_t)atom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new atom structure and fetch all predefined atoms
|
||||
*/
|
||||
struct atom *init_atoms(xcb_connection_t *c) {
|
||||
auto atoms = ccalloc(1, struct atom);
|
||||
atoms->c = new_cache((void *)c, atom_getter, NULL);
|
||||
#define ATOM_GET(x) atoms->a##x = (xcb_atom_t)(intptr_t)cache_get(atoms->c, #x, NULL)
|
||||
LIST_APPLY(ATOM_GET, SEP_COLON, ATOM_LIST1);
|
||||
LIST_APPLY(ATOM_GET, SEP_COLON, ATOM_LIST2);
|
||||
#undef ATOM_GET
|
||||
return atoms;
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
#pragma once
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "meta.h"
|
||||
#include "cache.h"
|
||||
|
||||
// clang-format off
|
||||
// Splitted into 2 lists because of the limitation of our macros
|
||||
#define ATOM_LIST1 \
|
||||
_NET_WM_WINDOW_OPACITY, \
|
||||
_NET_FRAME_EXTENTS, \
|
||||
WM_STATE, \
|
||||
_NET_WM_NAME, \
|
||||
_NET_WM_PID, \
|
||||
WM_NAME, \
|
||||
WM_CLASS, \
|
||||
WM_ICON_NAME, \
|
||||
WM_TRANSIENT_FOR, \
|
||||
WM_WINDOW_ROLE, \
|
||||
WM_CLIENT_LEADER, \
|
||||
WM_CLIENT_MACHINE, \
|
||||
_NET_ACTIVE_WINDOW, \
|
||||
_COMPTON_SHADOW, \
|
||||
_NET_WM_WINDOW_TYPE, \
|
||||
_NET_CURRENT_DESKTOP
|
||||
|
||||
#define ATOM_LIST2 \
|
||||
_NET_WM_WINDOW_TYPE_DESKTOP, \
|
||||
_NET_WM_WINDOW_TYPE_DOCK, \
|
||||
_NET_WM_WINDOW_TYPE_TOOLBAR, \
|
||||
_NET_WM_WINDOW_TYPE_MENU, \
|
||||
_NET_WM_WINDOW_TYPE_UTILITY, \
|
||||
_NET_WM_WINDOW_TYPE_SPLASH, \
|
||||
_NET_WM_WINDOW_TYPE_DIALOG, \
|
||||
_NET_WM_WINDOW_TYPE_NORMAL, \
|
||||
_NET_WM_WINDOW_TYPE_DROPDOWN_MENU, \
|
||||
_NET_WM_WINDOW_TYPE_POPUP_MENU, \
|
||||
_NET_WM_WINDOW_TYPE_TOOLTIP, \
|
||||
_NET_WM_WINDOW_TYPE_NOTIFICATION, \
|
||||
_NET_WM_WINDOW_TYPE_COMBO, \
|
||||
_NET_WM_WINDOW_TYPE_DND, \
|
||||
_NET_WM_STATE, \
|
||||
_NET_WM_STATE_FULLSCREEN, \
|
||||
_NET_WM_BYPASS_COMPOSITOR, \
|
||||
UTF8_STRING, \
|
||||
C_STRING
|
||||
// clang-format on
|
||||
|
||||
#define ATOM_DEF(x) xcb_atom_t a##x
|
||||
|
||||
struct atom {
|
||||
struct cache *c;
|
||||
LIST_APPLY(ATOM_DEF, SEP_COLON, ATOM_LIST1);
|
||||
LIST_APPLY(ATOM_DEF, SEP_COLON, ATOM_LIST2);
|
||||
};
|
||||
|
||||
struct atom *init_atoms(xcb_connection_t *);
|
||||
|
||||
static inline xcb_atom_t get_atom(struct atom *a, const char *key) {
|
||||
return (xcb_atom_t)(intptr_t)cache_get(a->c, key, NULL);
|
||||
}
|
||||
|
||||
static inline void destroy_atoms(struct atom *a) {
|
||||
cache_free(a->c);
|
||||
free(a);
|
||||
}
|
||||
@@ -0,0 +1,540 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <xcb/sync.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
extern struct backend_operations xrender_ops, dummy_ops;
|
||||
#ifdef CONFIG_OPENGL
|
||||
extern struct backend_operations glx_ops;
|
||||
#endif
|
||||
|
||||
struct backend_operations *backend_list[NUM_BKEND] = {
|
||||
[BKEND_XRENDER] = &xrender_ops,
|
||||
[BKEND_DUMMY] = &dummy_ops,
|
||||
#ifdef CONFIG_OPENGL
|
||||
[BKEND_GLX] = &glx_ops,
|
||||
#endif
|
||||
};
|
||||
|
||||
/**
|
||||
* @param all_damage if true ignore damage and repaint the whole screen
|
||||
*/
|
||||
region_t get_damage(session_t *ps, bool all_damage) {
|
||||
region_t region;
|
||||
auto buffer_age_fn = ps->backend_data->ops->buffer_age;
|
||||
int buffer_age = buffer_age_fn ? buffer_age_fn(ps->backend_data) : -1;
|
||||
|
||||
if (all_damage) {
|
||||
buffer_age = -1;
|
||||
}
|
||||
|
||||
pixman_region32_init(®ion);
|
||||
if (buffer_age == -1 || buffer_age > ps->ndamage) {
|
||||
pixman_region32_copy(®ion, &ps->screen_reg);
|
||||
} else {
|
||||
for (int i = 0; i < buffer_age; i++) {
|
||||
auto curr = ((ps->damage - ps->damage_ring) + i) % ps->ndamage;
|
||||
log_trace("damage index: %d, damage ring offset: %td", i, curr);
|
||||
dump_region(&ps->damage_ring[curr]);
|
||||
pixman_region32_union(®ion, ®ion, &ps->damage_ring[curr]);
|
||||
}
|
||||
pixman_region32_intersect(®ion, ®ion, &ps->screen_reg);
|
||||
}
|
||||
return region;
|
||||
}
|
||||
|
||||
static void process_window_for_painting(session_t *ps, struct managed_win *w,
|
||||
void *win_image, double additional_alpha,
|
||||
region_t *reg_bound, region_t *reg_visible,
|
||||
region_t *reg_paint, region_t *reg_paint_in_bound) {
|
||||
// For window image processing, we don't have to limit the process
|
||||
// region to damage for correctness. (see <damager-note> for
|
||||
// details)
|
||||
|
||||
// The visible region, in window local coordinates Although we
|
||||
// don't limit process region to damage, we provide that info in
|
||||
// reg_visible as a hint. Since window image data outside of the
|
||||
// damage region won't be painted onto target
|
||||
region_t reg_visible_local;
|
||||
{
|
||||
// The bounding shape, in window local coordinates
|
||||
region_t reg_bound_local;
|
||||
pixman_region32_init(®_bound_local);
|
||||
pixman_region32_copy(®_bound_local, reg_bound);
|
||||
pixman_region32_translate(®_bound_local, -w->g.x, -w->g.y);
|
||||
|
||||
pixman_region32_init(®_visible_local);
|
||||
pixman_region32_intersect(®_visible_local, reg_visible, reg_paint);
|
||||
pixman_region32_translate(®_visible_local, -w->g.x, -w->g.y);
|
||||
// Data outside of the bounding shape won't be visible,
|
||||
// but it is not necessary to limit the image operations
|
||||
// to the bounding shape yet. So pass that as the visible
|
||||
// region, not the clip region.
|
||||
pixman_region32_intersect(®_visible_local, ®_visible_local,
|
||||
®_bound_local);
|
||||
pixman_region32_fini(®_bound_local);
|
||||
}
|
||||
|
||||
auto new_img = ps->backend_data->ops->clone_image(ps->backend_data, win_image,
|
||||
®_visible_local);
|
||||
auto reg_frame = win_get_region_frame_local_by_val(w);
|
||||
double alpha = additional_alpha * w->opacity;
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_OPACITY, new_img, &alpha);
|
||||
ps->backend_data->ops->image_op(ps->backend_data, IMAGE_OP_APPLY_ALPHA, new_img,
|
||||
®_frame, ®_visible_local,
|
||||
(double[]){w->frame_opacity});
|
||||
pixman_region32_fini(®_frame);
|
||||
ps->backend_data->ops->compose(ps->backend_data, new_img, w->g.x, w->g.y,
|
||||
w->g.x + w->widthb, w->g.y + w->heightb,
|
||||
reg_paint_in_bound, reg_visible);
|
||||
ps->backend_data->ops->release_image(ps->backend_data, new_img);
|
||||
pixman_region32_fini(®_visible_local);
|
||||
}
|
||||
|
||||
void handle_device_reset(session_t *ps) {
|
||||
log_error("Device reset detected");
|
||||
// Wait for reset to complete
|
||||
// Although ideally the backend should return DEVICE_STATUS_NORMAL after a reset
|
||||
// is completed, it's not always possible.
|
||||
//
|
||||
// According to ARB_robustness (emphasis mine):
|
||||
//
|
||||
// "If a reset status other than NO_ERROR is returned and subsequent
|
||||
// calls return NO_ERROR, the context reset was encountered and
|
||||
// completed. If a reset status is repeatedly returned, the context **may**
|
||||
// be in the process of resetting."
|
||||
//
|
||||
// Which means it may also not be in the process of resetting. For example on
|
||||
// AMDGPU devices, Mesa OpenGL always return CONTEXT_RESET after a reset has
|
||||
// started, completed or not.
|
||||
//
|
||||
// So here we blindly wait 5 seconds and hope ourselves best of the luck.
|
||||
sleep(5);
|
||||
|
||||
// Reset picom
|
||||
log_info("Resetting picom after device reset");
|
||||
ev_break(ps->loop, EVBREAK_ALL);
|
||||
}
|
||||
|
||||
/// paint all windows
|
||||
void paint_all_new(session_t *ps, struct managed_win *t, bool ignore_damage) {
|
||||
if (ps->backend_data->ops->device_status &&
|
||||
ps->backend_data->ops->device_status(ps->backend_data) != DEVICE_STATUS_NORMAL) {
|
||||
return handle_device_reset(ps);
|
||||
}
|
||||
if (ps->o.xrender_sync_fence) {
|
||||
if (ps->xsync_exists && !x_fence_sync(ps->c, ps->sync_fence)) {
|
||||
log_error("x_fence_sync failed, xrender-sync-fence will be "
|
||||
"disabled from now on.");
|
||||
xcb_sync_destroy_fence(ps->c, ps->sync_fence);
|
||||
ps->sync_fence = XCB_NONE;
|
||||
ps->o.xrender_sync_fence = false;
|
||||
ps->xsync_exists = false;
|
||||
}
|
||||
}
|
||||
// All painting will be limited to the damage, if _some_ of
|
||||
// the paints bleed out of the damage region, it will destroy
|
||||
// part of the image we want to reuse
|
||||
region_t reg_damage;
|
||||
if (!ignore_damage) {
|
||||
reg_damage = get_damage(ps, ps->o.monitor_repaint || !ps->o.use_damage);
|
||||
} else {
|
||||
pixman_region32_init(®_damage);
|
||||
pixman_region32_copy(®_damage, &ps->screen_reg);
|
||||
}
|
||||
|
||||
if (!pixman_region32_not_empty(®_damage)) {
|
||||
pixman_region32_fini(®_damage);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_REPAINT
|
||||
static struct timespec last_paint = {0};
|
||||
#endif
|
||||
|
||||
// <damage-note>
|
||||
// If use_damage is enabled, we MUST make sure only the damaged regions of the
|
||||
// screen are ever touched by the compositor. The reason is that at the beginning
|
||||
// of each render, we clear the damaged regions with the wallpaper, and nothing
|
||||
// else. If later during the render we changed anything outside the damaged
|
||||
// region, that won't be cleared by the next render, and will thus accumulate.
|
||||
// (e.g. if shadow is drawn outside the damaged region, it will become thicker and
|
||||
// thicker over time.)
|
||||
|
||||
/// The adjusted damaged regions
|
||||
region_t reg_paint;
|
||||
assert(ps->o.blur_method != BLUR_METHOD_INVALID);
|
||||
if (ps->o.blur_method != BLUR_METHOD_NONE && ps->backend_data->ops->get_blur_size) {
|
||||
int blur_width, blur_height;
|
||||
ps->backend_data->ops->get_blur_size(ps->backend_blur_context,
|
||||
&blur_width, &blur_height);
|
||||
|
||||
// The region of screen a given window influences will be smeared
|
||||
// out by blur. With more windows on top of the given window, the
|
||||
// influences region will be smeared out more.
|
||||
//
|
||||
// Also, blurring requires data slightly outside the area that needs
|
||||
// to be blurred. The more semi-transparent windows are stacked on top
|
||||
// of each other, the larger the area will be.
|
||||
//
|
||||
// Instead of accurately calculate how much bigger the damage
|
||||
// region will be because of blur, we assume the worst case here.
|
||||
// That is, the damaged window is at the bottom of the stack, and
|
||||
// all other windows have semi-transparent background
|
||||
int resize_factor = 1;
|
||||
if (t) {
|
||||
resize_factor = t->stacking_rank;
|
||||
}
|
||||
resize_region_in_place(®_damage, blur_width * resize_factor,
|
||||
blur_height * resize_factor);
|
||||
reg_paint = resize_region(®_damage, blur_width * resize_factor,
|
||||
blur_height * resize_factor);
|
||||
pixman_region32_intersect(®_paint, ®_paint, &ps->screen_reg);
|
||||
pixman_region32_intersect(®_damage, ®_damage, &ps->screen_reg);
|
||||
} else {
|
||||
pixman_region32_init(®_paint);
|
||||
pixman_region32_copy(®_paint, ®_damage);
|
||||
}
|
||||
|
||||
// A hint to backend, the region that will be visible on screen
|
||||
// backend can optimize based on this info
|
||||
region_t reg_visible;
|
||||
pixman_region32_init(®_visible);
|
||||
pixman_region32_copy(®_visible, &ps->screen_reg);
|
||||
if (t && !ps->o.transparent_clipping) {
|
||||
// Calculate the region upon which the root window (wallpaper) is to be
|
||||
// painted based on the ignore region of the lowest window, if available
|
||||
//
|
||||
// NOTE If transparent_clipping is enabled, transparent windows are
|
||||
// included in the reg_ignore, but we still want to have the wallpaper
|
||||
// beneath them, so we don't use reg_ignore for wallpaper in that case.
|
||||
pixman_region32_subtract(®_visible, ®_visible, t->reg_ignore);
|
||||
}
|
||||
|
||||
// Region on screen we don't want any shadows on
|
||||
region_t reg_shadow_clip;
|
||||
pixman_region32_init(®_shadow_clip);
|
||||
|
||||
if (ps->backend_data->ops->prepare) {
|
||||
ps->backend_data->ops->prepare(ps->backend_data, ®_paint);
|
||||
}
|
||||
|
||||
if (ps->root_image) {
|
||||
ps->backend_data->ops->compose(ps->backend_data, ps->root_image, 0, 0,
|
||||
ps->root_width, ps->root_height,
|
||||
®_paint, ®_visible);
|
||||
} else {
|
||||
ps->backend_data->ops->fill(ps->backend_data, (struct color){0, 0, 0, 1},
|
||||
®_paint);
|
||||
}
|
||||
|
||||
// Windows are sorted from bottom to top
|
||||
// Each window has a reg_ignore, which is the region obscured by all the windows
|
||||
// on top of that window. This is used to reduce the number of pixels painted.
|
||||
//
|
||||
// Whether this is beneficial is to be determined XXX
|
||||
for (auto w = t; w; w = w->prev_trans) {
|
||||
pixman_region32_subtract(®_visible, &ps->screen_reg, w->reg_ignore);
|
||||
assert(!(w->flags & WIN_FLAGS_IMAGE_ERROR));
|
||||
assert(!(w->flags & WIN_FLAGS_PIXMAP_STALE));
|
||||
assert(!(w->flags & WIN_FLAGS_PIXMAP_NONE));
|
||||
|
||||
// The bounding shape of the window, in global/target coordinates
|
||||
// reminder: bounding shape contains the WM frame
|
||||
auto reg_bound = win_get_bounding_shape_global_by_val(w);
|
||||
auto reg_bound_no_corner =
|
||||
win_get_bounding_shape_global_without_corners_by_val(w);
|
||||
|
||||
// The clip region for the current window, in global/target coordinates
|
||||
// reg_paint_in_bound \in reg_paint
|
||||
region_t reg_paint_in_bound;
|
||||
pixman_region32_init(®_paint_in_bound);
|
||||
pixman_region32_intersect(®_paint_in_bound, ®_bound, ®_paint);
|
||||
if (ps->o.transparent_clipping) {
|
||||
// <transparent-clipping-note>
|
||||
// If transparent_clipping is enabled, we need to be SURE that
|
||||
// things are not drawn inside reg_ignore, because otherwise they
|
||||
// will appear underneath transparent windows.
|
||||
// So here we have make sure reg_paint_in_bound \in reg_visible
|
||||
// There are a few other places below where this is needed as
|
||||
// well.
|
||||
pixman_region32_intersect(®_paint_in_bound,
|
||||
®_paint_in_bound, ®_visible);
|
||||
}
|
||||
|
||||
// Blur window background
|
||||
/* TODO(yshui) since the backend might change the content of the window
|
||||
* (e.g. with shaders), we should consult the backend whether the window
|
||||
* is transparent or not. for now we will just rely on the force_win_blend
|
||||
* option */
|
||||
auto real_win_mode = w->mode;
|
||||
|
||||
if (w->blur_background &&
|
||||
(ps->o.force_win_blend || real_win_mode == WMODE_TRANS ||
|
||||
(ps->o.blur_background_frame && real_win_mode == WMODE_FRAME_TRANS))) {
|
||||
// Minimize the region we try to blur, if the window
|
||||
// itself is not opaque, only the frame is.
|
||||
|
||||
double blur_opacity = 1;
|
||||
if (w->opacity < (1.0 / MAX_ALPHA)) {
|
||||
// Hide blur for fully transparent windows.
|
||||
blur_opacity = 0;
|
||||
} else if (w->state == WSTATE_MAPPING) {
|
||||
// Gradually increase the blur intensity during
|
||||
// fading in.
|
||||
assert(w->opacity <= w->opacity_target);
|
||||
blur_opacity = w->opacity / w->opacity_target;
|
||||
} else if (w->state == WSTATE_UNMAPPING ||
|
||||
w->state == WSTATE_DESTROYING) {
|
||||
// Gradually decrease the blur intensity during
|
||||
// fading out.
|
||||
assert(w->opacity <= w->opacity_target_old);
|
||||
blur_opacity = w->opacity / w->opacity_target_old;
|
||||
} else if (w->state == WSTATE_FADING) {
|
||||
if (w->opacity < w->opacity_target &&
|
||||
w->opacity_target_old < (1.0 / MAX_ALPHA)) {
|
||||
// Gradually increase the blur intensity during
|
||||
// fading in.
|
||||
assert(w->opacity <= w->opacity_target);
|
||||
blur_opacity = w->opacity / w->opacity_target;
|
||||
} else if (w->opacity > w->opacity_target &&
|
||||
w->opacity_target < (1.0 / MAX_ALPHA)) {
|
||||
// Gradually decrease the blur intensity during
|
||||
// fading out.
|
||||
assert(w->opacity <= w->opacity_target_old);
|
||||
blur_opacity = w->opacity / w->opacity_target_old;
|
||||
}
|
||||
}
|
||||
assert(blur_opacity >= 0 && blur_opacity <= 1);
|
||||
|
||||
if (real_win_mode == WMODE_TRANS || ps->o.force_win_blend) {
|
||||
// We need to blur the bounding shape of the window
|
||||
// (reg_paint_in_bound = reg_bound \cap reg_paint)
|
||||
ps->backend_data->ops->blur(
|
||||
ps->backend_data, blur_opacity, ps->backend_blur_context,
|
||||
®_paint_in_bound, ®_visible);
|
||||
} else {
|
||||
// Window itself is solid, we only need to blur the frame
|
||||
// region
|
||||
|
||||
// Readability assertions
|
||||
assert(ps->o.blur_background_frame);
|
||||
assert(real_win_mode == WMODE_FRAME_TRANS);
|
||||
|
||||
auto reg_blur = win_get_region_frame_local_by_val(w);
|
||||
pixman_region32_translate(®_blur, w->g.x, w->g.y);
|
||||
// make sure reg_blur \in reg_paint
|
||||
pixman_region32_intersect(®_blur, ®_blur, ®_paint);
|
||||
if (ps->o.transparent_clipping) {
|
||||
// ref: <transparent-clipping-note>
|
||||
pixman_region32_intersect(®_blur, ®_blur,
|
||||
®_visible);
|
||||
}
|
||||
ps->backend_data->ops->blur(ps->backend_data, blur_opacity,
|
||||
ps->backend_blur_context,
|
||||
®_blur, ®_visible);
|
||||
pixman_region32_fini(®_blur);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw shadow on target
|
||||
if (w->shadow) {
|
||||
assert(!(w->flags & WIN_FLAGS_SHADOW_NONE));
|
||||
// Clip region for the shadow
|
||||
// reg_shadow \in reg_paint
|
||||
auto reg_shadow = win_extents_by_val(w);
|
||||
pixman_region32_intersect(®_shadow, ®_shadow, ®_paint);
|
||||
if (!ps->o.wintype_option[w->window_type].full_shadow) {
|
||||
pixman_region32_subtract(®_shadow, ®_shadow,
|
||||
®_bound_no_corner);
|
||||
}
|
||||
|
||||
// Mask out the region we don't want shadow on
|
||||
if (pixman_region32_not_empty(&ps->shadow_exclude_reg)) {
|
||||
pixman_region32_subtract(®_shadow, ®_shadow,
|
||||
&ps->shadow_exclude_reg);
|
||||
}
|
||||
if (pixman_region32_not_empty(®_shadow_clip)) {
|
||||
pixman_region32_subtract(®_shadow, ®_shadow,
|
||||
®_shadow_clip);
|
||||
}
|
||||
|
||||
if (ps->o.xinerama_shadow_crop && w->xinerama_scr >= 0 &&
|
||||
w->xinerama_scr < ps->xinerama_nscrs) {
|
||||
// There can be a window where number of screens is
|
||||
// updated, but the screen number attached to the windows
|
||||
// have not.
|
||||
//
|
||||
// Window screen number will be updated eventually, so
|
||||
// here we just check to make sure we don't access out of
|
||||
// bounds.
|
||||
pixman_region32_intersect(
|
||||
®_shadow, ®_shadow,
|
||||
&ps->xinerama_scr_regs[w->xinerama_scr]);
|
||||
}
|
||||
|
||||
if (ps->o.transparent_clipping) {
|
||||
// ref: <transparent-clipping-note>
|
||||
pixman_region32_intersect(®_shadow, ®_shadow,
|
||||
®_visible);
|
||||
}
|
||||
|
||||
assert(w->shadow_image);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_OPACITY, w->shadow_image,
|
||||
&w->opacity);
|
||||
|
||||
ps->backend_data->ops->compose(
|
||||
ps->backend_data, w->shadow_image, w->g.x + w->shadow_dx,
|
||||
w->g.y + w->shadow_dy, w->g.x + w->shadow_dx + w->shadow_width,
|
||||
w->g.y + w->shadow_dy + w->shadow_height, ®_shadow,
|
||||
®_visible);
|
||||
pixman_region32_fini(®_shadow);
|
||||
}
|
||||
|
||||
// Update image properties
|
||||
{
|
||||
double dim_opacity = 0.0;
|
||||
if (w->dim) {
|
||||
dim_opacity = ps->o.inactive_dim;
|
||||
if (!ps->o.inactive_dim_fixed) {
|
||||
dim_opacity *= w->opacity;
|
||||
}
|
||||
}
|
||||
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_MAX_BRIGHTNESS, w->win_image,
|
||||
&ps->o.max_brightness);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_INVERTED, w->win_image,
|
||||
&w->invert_color);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_DIM_LEVEL, w->win_image,
|
||||
&dim_opacity);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_OPACITY, w->win_image, &w->opacity);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_CORNER_RADIUS, w->win_image,
|
||||
(double[]){w->corner_radius});
|
||||
if (w->corner_radius) {
|
||||
int border_width = w->g.border_width;
|
||||
if (border_width == 0) {
|
||||
// Some WM has borders implemented as WM frames
|
||||
border_width = min3(w->frame_extents.left,
|
||||
w->frame_extents.right,
|
||||
w->frame_extents.bottom);
|
||||
}
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_BORDER_WIDTH,
|
||||
w->win_image, &border_width);
|
||||
if (w->old_win_image) {
|
||||
// TODO(dccsillag): explain why the following is
|
||||
// "necessary"
|
||||
double zero = 0.0;
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_BORDER_WIDTH,
|
||||
w->old_win_image, &zero);
|
||||
ps->backend_data->ops->set_image_property(
|
||||
ps->backend_data, IMAGE_PROPERTY_CORNER_RADIUS,
|
||||
w->old_win_image, &zero);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (w->opacity * MAX_ALPHA < 1) {
|
||||
// We don't need to paint the window body itself if it's
|
||||
// completely transparent.
|
||||
goto skip;
|
||||
}
|
||||
|
||||
if (w->clip_shadow_above) {
|
||||
// Add window bounds to shadow-clip region
|
||||
pixman_region32_union(®_shadow_clip, ®_shadow_clip, ®_bound);
|
||||
} else {
|
||||
// Remove overlapping window bounds from shadow-clip region
|
||||
pixman_region32_subtract(®_shadow_clip, ®_shadow_clip, ®_bound);
|
||||
}
|
||||
|
||||
// Draw window on target
|
||||
bool is_animating = 0 <= w->animation_progress && w->animation_progress < 1.0;
|
||||
if (w->frame_opacity == 1 && !is_animating) {
|
||||
ps->backend_data->ops->compose(ps->backend_data, w->win_image,
|
||||
w->g.x, w->g.y,
|
||||
w->g.x + w->widthb, w->g.y + w->heightb,
|
||||
®_paint_in_bound, ®_visible);
|
||||
} else {
|
||||
process_window_for_painting(
|
||||
ps, w, w->win_image, 1.0, ®_bound, ®_visible,
|
||||
®_paint, ®_paint_in_bound);
|
||||
|
||||
if (w->old_win_image) {
|
||||
bool resizing =
|
||||
w->g.width != w->pending_g.width ||
|
||||
w->g.height != w->pending_g.height;
|
||||
|
||||
// Only do this if size changes as otherwise moving
|
||||
// transparent windows will flicker
|
||||
if (resizing) {
|
||||
assert(w->old_win_image);
|
||||
|
||||
process_window_for_painting(ps, w, w->old_win_image,
|
||||
1.0 - w->animation_progress,
|
||||
®_bound, ®_visible,
|
||||
®_paint, ®_paint_in_bound);
|
||||
}
|
||||
}
|
||||
}
|
||||
skip:
|
||||
pixman_region32_fini(®_bound);
|
||||
pixman_region32_fini(®_bound_no_corner);
|
||||
pixman_region32_fini(®_paint_in_bound);
|
||||
}
|
||||
pixman_region32_fini(®_paint);
|
||||
pixman_region32_fini(®_shadow_clip);
|
||||
|
||||
if (ps->o.monitor_repaint) {
|
||||
const struct color DEBUG_COLOR = {0.5, 0, 0, 0.5};
|
||||
auto reg_damage_debug = get_damage(ps, false);
|
||||
ps->backend_data->ops->fill(ps->backend_data, DEBUG_COLOR, ®_damage_debug);
|
||||
pixman_region32_fini(®_damage_debug);
|
||||
}
|
||||
|
||||
// Move the head of the damage ring
|
||||
ps->damage = ps->damage - 1;
|
||||
if (ps->damage < ps->damage_ring) {
|
||||
ps->damage = ps->damage_ring + ps->ndamage - 1;
|
||||
}
|
||||
pixman_region32_clear(ps->damage);
|
||||
|
||||
if (ps->backend_data->ops->present) {
|
||||
// Present the rendered scene
|
||||
// Vsync is done here
|
||||
ps->backend_data->ops->present(ps->backend_data, ®_damage);
|
||||
}
|
||||
|
||||
pixman_region32_fini(®_damage);
|
||||
|
||||
#ifdef DEBUG_REPAINT
|
||||
struct timespec now = get_time_timespec();
|
||||
struct timespec diff = {0};
|
||||
timespec_subtract(&diff, &now, &last_paint);
|
||||
log_trace("[ %5ld:%09ld ] ", diff.tv_sec, diff.tv_nsec);
|
||||
last_paint = now;
|
||||
log_trace("paint:");
|
||||
for (win *w = t; w; w = w->prev_trans)
|
||||
log_trace(" %#010lx", w->id);
|
||||
#endif
|
||||
}
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,294 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018, Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "driver.h"
|
||||
#include "kernel.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "x.h"
|
||||
|
||||
typedef struct session session_t;
|
||||
struct managed_win;
|
||||
|
||||
struct ev_loop;
|
||||
struct backend_operations;
|
||||
|
||||
typedef struct backend_base {
|
||||
struct backend_operations *ops;
|
||||
xcb_connection_t *c;
|
||||
xcb_window_t root;
|
||||
struct ev_loop *loop;
|
||||
|
||||
/// Whether the backend can accept new render request at the moment
|
||||
bool busy;
|
||||
// ...
|
||||
} backend_t;
|
||||
|
||||
typedef void (*backend_ready_callback_t)(void *);
|
||||
|
||||
// This mimics OpenGL's ARB_robustness extension, which enables detection of GPU context
|
||||
// resets.
|
||||
// See: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_robustness.txt, section
|
||||
// 2.6 "Graphics Reset Recovery".
|
||||
enum device_status {
|
||||
DEVICE_STATUS_NORMAL,
|
||||
DEVICE_STATUS_RESETTING,
|
||||
};
|
||||
|
||||
// When image properties are actually applied to the image, they are applied in a
|
||||
// particular order:
|
||||
//
|
||||
// Color inversion -> Dimming -> Opacity multiply -> Limit maximum brightness
|
||||
// (Corner radius could be applied in any order)
|
||||
enum image_properties {
|
||||
// Whether the color of the image is inverted
|
||||
// 1 boolean, default: false
|
||||
IMAGE_PROPERTY_INVERTED,
|
||||
// How much the image is dimmed
|
||||
// 1 double, default: 0
|
||||
IMAGE_PROPERTY_DIM_LEVEL,
|
||||
// Image opacity, i.e. an alpha value multiplied to the alpha channel
|
||||
// 1 double, default: 1
|
||||
IMAGE_PROPERTY_OPACITY,
|
||||
// The effective size of the image, the image will be tiled to fit.
|
||||
// 2 int, default: the actual size of the image
|
||||
IMAGE_PROPERTY_EFFECTIVE_SIZE,
|
||||
// Limit how bright image can be. The image brightness is estimated by averaging
|
||||
// the pixels in the image, and dimming will be applied to scale the average
|
||||
// brightness down to the max brightness value.
|
||||
// 1 double, default: 1
|
||||
IMAGE_PROPERTY_MAX_BRIGHTNESS,
|
||||
// Gives the image a rounded corner.
|
||||
// 1 double, default: 0
|
||||
IMAGE_PROPERTY_CORNER_RADIUS,
|
||||
// Border width
|
||||
// 1 int, default: 0
|
||||
IMAGE_PROPERTY_BORDER_WIDTH,
|
||||
};
|
||||
|
||||
enum image_operations {
|
||||
// Multiply the alpha channel by the argument
|
||||
IMAGE_OP_APPLY_ALPHA,
|
||||
};
|
||||
|
||||
struct gaussian_blur_args {
|
||||
int size;
|
||||
double deviation;
|
||||
};
|
||||
|
||||
struct box_blur_args {
|
||||
int size;
|
||||
};
|
||||
|
||||
struct kernel_blur_args {
|
||||
struct conv **kernels;
|
||||
int kernel_count;
|
||||
};
|
||||
|
||||
struct dual_kawase_blur_args {
|
||||
int size;
|
||||
int strength;
|
||||
};
|
||||
|
||||
struct backend_operations {
|
||||
// =========== Initialization ===========
|
||||
|
||||
/// Initialize the backend, prepare for rendering to the target window.
|
||||
/// Here is how you should choose target window:
|
||||
/// 1) if ps->overlay is not XCB_NONE, use that
|
||||
/// 2) use ps->root otherwise
|
||||
// TODO(yshui) make the target window a parameter
|
||||
backend_t *(*init)(session_t *)attr_nonnull(1);
|
||||
void (*deinit)(backend_t *backend_data) attr_nonnull(1);
|
||||
|
||||
/// Called when rendering will be stopped for an unknown amount of
|
||||
/// time (e.g. when screen is unredirected). Free some resources.
|
||||
///
|
||||
/// Optional, not yet used
|
||||
void (*pause)(backend_t *backend_data, session_t *ps);
|
||||
|
||||
/// Called before rendering is resumed
|
||||
///
|
||||
/// Optional, not yet used
|
||||
void (*resume)(backend_t *backend_data, session_t *ps);
|
||||
|
||||
/// Called when root property changed, returns the new
|
||||
/// backend_data. Even if the backend_data changed, all
|
||||
/// the existing image data returned by this backend should
|
||||
/// remain valid.
|
||||
///
|
||||
/// Optional
|
||||
void *(*root_change)(backend_t *backend_data, session_t *ps);
|
||||
|
||||
// =========== Rendering ============
|
||||
|
||||
// NOTE: general idea about reg_paint/reg_op vs reg_visible is that reg_visible is
|
||||
// merely a hint. Ignoring reg_visible entirely don't affect the correctness of
|
||||
// the operation performed. OTOH reg_paint/reg_op is part of the parameters of the
|
||||
// operation, and must be honored in order to complete the operation correctly.
|
||||
|
||||
// NOTE: due to complications introduced by use-damage and blur, the rendering API
|
||||
// is a bit weird. The idea is, `compose` and `blur` have to update a temporary
|
||||
// buffer, because `blur` requires data from an area slightly larger than the area
|
||||
// that will be visible. So the area outside the visible area has to be rendered,
|
||||
// but we have to discard the result (because the result of blurring that area
|
||||
// will be wrong). That's why we cannot render into the back buffer directly.
|
||||
// After rendering is done, `present` is called to update a portion of the actual
|
||||
// back buffer, then present it to the target (or update the target directly,
|
||||
// if not back buffered).
|
||||
|
||||
/// Called before when a new frame starts.
|
||||
///
|
||||
/// Optional
|
||||
void (*prepare)(backend_t *backend_data, const region_t *reg_damage);
|
||||
|
||||
/**
|
||||
* Paint the content of an image onto the rendering buffer
|
||||
*
|
||||
* @param backend_data the backend data
|
||||
* @param image_data the image to paint
|
||||
* @param dst_x1, dst_y1 the top left corner of the image in the target
|
||||
* @param dst_x2, dst_y2 the top right corner of the image in the target
|
||||
* @param reg_paint the clip region, in target coordinates
|
||||
* @param reg_visible the visible region, in target coordinates
|
||||
*/
|
||||
void (*compose)(backend_t *backend_data, void *image_data,
|
||||
int dst_x1, int dst_y1, int dst_x2, int dst_y2,
|
||||
const region_t *reg_paint, const region_t *reg_visible);
|
||||
|
||||
/// Fill rectangle of the rendering buffer, mostly for debug purposes, optional.
|
||||
void (*fill)(backend_t *backend_data, struct color, const region_t *clip);
|
||||
|
||||
/// Blur a given region of the rendering buffer.
|
||||
bool (*blur)(backend_t *backend_data, double opacity, void *blur_ctx,
|
||||
const region_t *reg_blur, const region_t *reg_visible)
|
||||
attr_nonnull(1, 3, 4, 5);
|
||||
|
||||
/// Update part of the back buffer with the rendering buffer, then present the
|
||||
/// back buffer onto the target window (if not back buffered, update part of the
|
||||
/// target window directly).
|
||||
///
|
||||
/// Optional, if NULL, indicates the backend doesn't have render output
|
||||
///
|
||||
/// @param region part of the target that should be updated
|
||||
void (*present)(backend_t *backend_data, const region_t *region) attr_nonnull(1, 2);
|
||||
|
||||
/**
|
||||
* Bind a X pixmap to the backend's internal image data structure.
|
||||
*
|
||||
* @param backend_data backend data
|
||||
* @param pixmap X pixmap to bind
|
||||
* @param fmt information of the pixmap's visual
|
||||
* @param owned whether the ownership of the pixmap is transfered to the backend
|
||||
* @return backend internal data structure bound with this pixmap
|
||||
*/
|
||||
void *(*bind_pixmap)(backend_t *backend_data, xcb_pixmap_t pixmap,
|
||||
struct xvisual_info fmt, bool owned);
|
||||
|
||||
/// Create a shadow image based on the parameters
|
||||
/// Default implementation: default_backend_render_shadow
|
||||
void *(*render_shadow)(backend_t *backend_data, int width, int height,
|
||||
const conv *kernel, double r, double g, double b, double a);
|
||||
|
||||
// ============ Resource management ===========
|
||||
|
||||
/// Free resources associated with an image data structure
|
||||
void (*release_image)(backend_t *backend_data, void *img_data) attr_nonnull(1, 2);
|
||||
|
||||
// =========== Query ===========
|
||||
|
||||
/// Return if image is not completely opaque.
|
||||
///
|
||||
/// This function is needed because some backend might change the content of the
|
||||
/// window (e.g. when using a custom shader with the glx backend), so only the
|
||||
/// backend knows if an image is transparent.
|
||||
bool (*is_image_transparent)(backend_t *backend_data, void *image_data)
|
||||
attr_nonnull(1, 2);
|
||||
|
||||
/// Get the age of the buffer content we are currently rendering ontop
|
||||
/// of. The buffer that has just been `present`ed has a buffer age of 1.
|
||||
/// Everytime `present` is called, buffers get older. Return -1 if the
|
||||
/// buffer is empty.
|
||||
///
|
||||
/// Optional
|
||||
int (*buffer_age)(backend_t *backend_data);
|
||||
|
||||
/// The maximum number buffer_age might return.
|
||||
int max_buffer_age;
|
||||
|
||||
// =========== Post-processing ============
|
||||
|
||||
/* TODO(yshui) Consider preserving the order of image ops.
|
||||
* Currently in both backends, the image ops are applied lazily when needed.
|
||||
* However neither backends preserve the order of image ops, they just applied all
|
||||
* pending lazy ops in a pre-determined fixed order, regardless in which order
|
||||
* they were originally applied. This might lead to inconsistencies.*/
|
||||
|
||||
/**
|
||||
* Change image properties
|
||||
*
|
||||
* @param backend_data backend data
|
||||
* @param prop the property to change
|
||||
* @param image_data an image data structure returned by the backend
|
||||
* @param args property value
|
||||
* @return whether the operation is successful
|
||||
*/
|
||||
bool (*set_image_property)(backend_t *backend_data, enum image_properties prop,
|
||||
void *image_data, void *args);
|
||||
|
||||
/**
|
||||
* Manipulate an image. Image properties are untouched.
|
||||
*
|
||||
* @param backend_data backend data
|
||||
* @param op the operation to perform
|
||||
* @param image_data an image data structure returned by the backend
|
||||
* @param reg_op the clip region, define the part of the image to be
|
||||
* operated on.
|
||||
* @param reg_visible define the part of the image that will eventually
|
||||
* be visible on target. this is a hint to the backend
|
||||
* for optimization purposes.
|
||||
* @param args extra arguments, operation specific
|
||||
* @return whether the operation is successful
|
||||
*/
|
||||
bool (*image_op)(backend_t *backend_data, enum image_operations op, void *image_data,
|
||||
const region_t *reg_op, const region_t *reg_visible, void *args);
|
||||
|
||||
/// Create another instance of the `image_data`. All `image_op` and
|
||||
/// `set_image_property` calls on the returned image should not affect the
|
||||
/// original image
|
||||
void *(*clone_image)(backend_t *base, const void *image_data,
|
||||
const region_t *reg_visible);
|
||||
|
||||
/// Create a blur context that can be used to call `blur`
|
||||
void *(*create_blur_context)(backend_t *base, enum blur_method, void *args);
|
||||
/// Destroy a blur context
|
||||
void (*destroy_blur_context)(backend_t *base, void *ctx);
|
||||
/// Get how many pixels outside of the blur area is needed for blur
|
||||
void (*get_blur_size)(void *blur_context, int *width, int *height);
|
||||
|
||||
// =========== Hooks ============
|
||||
/// Let the backend hook into the event handling queue
|
||||
/// Not implemented yet
|
||||
void (*set_ready_callback)(backend_t *, backend_ready_callback_t cb);
|
||||
/// Called right after the core has handled its events.
|
||||
/// Not implemented yet
|
||||
void (*handle_events)(backend_t *);
|
||||
// =========== Misc ============
|
||||
/// Return the driver that is been used by the backend
|
||||
enum driver (*detect_driver)(backend_t *backend_data);
|
||||
|
||||
void (*diagnostics)(backend_t *backend_data);
|
||||
|
||||
enum device_status (*device_status)(backend_t *backend_data);
|
||||
};
|
||||
|
||||
extern struct backend_operations *backend_list[];
|
||||
|
||||
void paint_all_new(session_t *ps, struct managed_win *const t, bool ignore_damage)
|
||||
attr_nonnull(1);
|
||||
@@ -0,0 +1,483 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb_image.h>
|
||||
#include <xcb/xcb_renderutil.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "backend/backend_common.h"
|
||||
#include "common.h"
|
||||
#include "config.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
/**
|
||||
* Generate a 1x1 <code>Picture</code> of a particular color.
|
||||
*/
|
||||
xcb_render_picture_t solid_picture(xcb_connection_t *c, xcb_drawable_t d, bool argb,
|
||||
double a, double r, double g, double b) {
|
||||
xcb_pixmap_t pixmap;
|
||||
xcb_render_picture_t picture;
|
||||
xcb_render_create_picture_value_list_t pa;
|
||||
xcb_render_color_t col;
|
||||
xcb_rectangle_t rect;
|
||||
|
||||
pixmap = x_create_pixmap(c, argb ? 32 : 8, d, 1, 1);
|
||||
if (!pixmap)
|
||||
return XCB_NONE;
|
||||
|
||||
pa.repeat = 1;
|
||||
picture = x_create_picture_with_standard_and_pixmap(
|
||||
c, argb ? XCB_PICT_STANDARD_ARGB_32 : XCB_PICT_STANDARD_A_8, pixmap,
|
||||
XCB_RENDER_CP_REPEAT, &pa);
|
||||
|
||||
if (!picture) {
|
||||
xcb_free_pixmap(c, pixmap);
|
||||
return XCB_NONE;
|
||||
}
|
||||
|
||||
col.alpha = (uint16_t)(a * 0xffff);
|
||||
col.red = (uint16_t)(r * 0xffff);
|
||||
col.green = (uint16_t)(g * 0xffff);
|
||||
col.blue = (uint16_t)(b * 0xffff);
|
||||
|
||||
rect.x = 0;
|
||||
rect.y = 0;
|
||||
rect.width = 1;
|
||||
rect.height = 1;
|
||||
|
||||
xcb_render_fill_rectangles(c, XCB_RENDER_PICT_OP_SRC, picture, col, 1, &rect);
|
||||
xcb_free_pixmap(c, pixmap);
|
||||
|
||||
return picture;
|
||||
}
|
||||
|
||||
xcb_image_t *
|
||||
make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, int height) {
|
||||
/*
|
||||
* We classify shadows into 4 kinds of regions
|
||||
* r = shadow radius
|
||||
* (0, 0) is the top left of the window itself
|
||||
* -r r width-r width+r
|
||||
* -r +-----+---------+-----+
|
||||
* | 1 | 2 | 1 |
|
||||
* r +-----+---------+-----+
|
||||
* | 2 | 3 | 2 |
|
||||
* height-r +-----+---------+-----+
|
||||
* | 1 | 2 | 1 |
|
||||
* height+r +-----+---------+-----+
|
||||
*/
|
||||
xcb_image_t *ximage;
|
||||
const double *shadow_sum = kernel->rsum;
|
||||
assert(shadow_sum);
|
||||
// We only support square kernels for shadow
|
||||
assert(kernel->w == kernel->h);
|
||||
int d = kernel->w;
|
||||
int r = d / 2;
|
||||
int swidth = width + r * 2, sheight = height + r * 2;
|
||||
|
||||
assert(d % 2 == 1);
|
||||
assert(d > 0);
|
||||
|
||||
ximage = xcb_image_create_native(c, to_u16_checked(swidth), to_u16_checked(sheight),
|
||||
XCB_IMAGE_FORMAT_Z_PIXMAP, 8, 0, 0, NULL);
|
||||
if (!ximage) {
|
||||
log_error("failed to create an X image");
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned char *data = ximage->data;
|
||||
long long sstride = ximage->stride;
|
||||
|
||||
// If the window body is smaller than the kernel, we do convolution directly
|
||||
if (width < r * 2 && height < r * 2) {
|
||||
for (int y = 0; y < sheight; y++) {
|
||||
for (int x = 0; x < swidth; x++) {
|
||||
double sum = sum_kernel_normalized(
|
||||
kernel, d - x - 1, d - y - 1, width, height);
|
||||
data[y * sstride + x] = (uint8_t)(sum * 255.0 * opacity);
|
||||
}
|
||||
}
|
||||
return ximage;
|
||||
}
|
||||
|
||||
if (height < r * 2) {
|
||||
// Implies width >= r * 2
|
||||
// If the window height is smaller than the kernel, we divide
|
||||
// the window like this:
|
||||
// -r r width-r width+r
|
||||
// +------+-------------+------+
|
||||
// | | | |
|
||||
// +------+-------------+------+
|
||||
for (int y = 0; y < sheight; y++) {
|
||||
for (int x = 0; x < r * 2; x++) {
|
||||
double sum = sum_kernel_normalized(kernel, d - x - 1,
|
||||
d - y - 1, d, height) *
|
||||
255.0 * opacity;
|
||||
data[y * sstride + x] = (uint8_t)sum;
|
||||
data[y * sstride + swidth - x - 1] = (uint8_t)sum;
|
||||
}
|
||||
}
|
||||
for (int y = 0; y < sheight; y++) {
|
||||
double sum = sum_kernel_normalized(kernel, 0, d - y - 1, d, height) *
|
||||
255.0 * opacity;
|
||||
memset(&data[y * sstride + r * 2], (uint8_t)sum,
|
||||
(size_t)(width - 2 * r));
|
||||
}
|
||||
return ximage;
|
||||
}
|
||||
if (width < r * 2) {
|
||||
// Similarly, for width smaller than kernel
|
||||
for (int y = 0; y < r * 2; y++) {
|
||||
for (int x = 0; x < swidth; x++) {
|
||||
double sum = sum_kernel_normalized(kernel, d - x - 1,
|
||||
d - y - 1, width, d) *
|
||||
255.0 * opacity;
|
||||
data[y * sstride + x] = (uint8_t)sum;
|
||||
data[(sheight - y - 1) * sstride + x] = (uint8_t)sum;
|
||||
}
|
||||
}
|
||||
for (int x = 0; x < swidth; x++) {
|
||||
double sum = sum_kernel_normalized(kernel, d - x - 1, 0, width, d) *
|
||||
255.0 * opacity;
|
||||
for (int y = r * 2; y < height; y++) {
|
||||
data[y * sstride + x] = (uint8_t)sum;
|
||||
}
|
||||
}
|
||||
return ximage;
|
||||
}
|
||||
|
||||
// Implies: width >= r * 2 && height >= r * 2
|
||||
|
||||
// Fill part 3
|
||||
for (int y = r; y < height + r; y++) {
|
||||
memset(data + sstride * y + r, (uint8_t)(255 * opacity), (size_t)width);
|
||||
}
|
||||
|
||||
// Part 1
|
||||
for (int y = 0; y < r * 2; y++) {
|
||||
for (int x = 0; x < r * 2; x++) {
|
||||
double tmpsum = shadow_sum[y * d + x] * opacity * 255.0;
|
||||
data[y * sstride + x] = (uint8_t)tmpsum;
|
||||
data[(sheight - y - 1) * sstride + x] = (uint8_t)tmpsum;
|
||||
data[(sheight - y - 1) * sstride + (swidth - x - 1)] = (uint8_t)tmpsum;
|
||||
data[y * sstride + (swidth - x - 1)] = (uint8_t)tmpsum;
|
||||
}
|
||||
}
|
||||
|
||||
// Part 2, top/bottom
|
||||
for (int y = 0; y < r * 2; y++) {
|
||||
double tmpsum = shadow_sum[d * y + d - 1] * opacity * 255.0;
|
||||
memset(&data[y * sstride + r * 2], (uint8_t)tmpsum, (size_t)(width - r * 2));
|
||||
memset(&data[(sheight - y - 1) * sstride + r * 2], (uint8_t)tmpsum,
|
||||
(size_t)(width - r * 2));
|
||||
}
|
||||
|
||||
// Part 2, left/right
|
||||
for (int x = 0; x < r * 2; x++) {
|
||||
double tmpsum = shadow_sum[d * (d - 1) + x] * opacity * 255.0;
|
||||
for (int y = r * 2; y < height; y++) {
|
||||
data[y * sstride + x] = (uint8_t)tmpsum;
|
||||
data[y * sstride + (swidth - x - 1)] = (uint8_t)tmpsum;
|
||||
}
|
||||
}
|
||||
|
||||
return ximage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate shadow <code>Picture</code> for a window.
|
||||
*/
|
||||
bool build_shadow(xcb_connection_t *c, xcb_drawable_t d, double opacity, const int width,
|
||||
const int height, const conv *kernel, xcb_render_picture_t shadow_pixel,
|
||||
xcb_pixmap_t *pixmap, xcb_render_picture_t *pict) {
|
||||
xcb_image_t *shadow_image = NULL;
|
||||
xcb_pixmap_t shadow_pixmap = XCB_NONE, shadow_pixmap_argb = XCB_NONE;
|
||||
xcb_render_picture_t shadow_picture = XCB_NONE, shadow_picture_argb = XCB_NONE;
|
||||
xcb_gcontext_t gc = XCB_NONE;
|
||||
|
||||
shadow_image = make_shadow(c, kernel, opacity, width, height);
|
||||
if (!shadow_image) {
|
||||
log_error("Failed to make shadow");
|
||||
return false;
|
||||
}
|
||||
|
||||
shadow_pixmap = x_create_pixmap(c, 8, d, shadow_image->width, shadow_image->height);
|
||||
shadow_pixmap_argb =
|
||||
x_create_pixmap(c, 32, d, shadow_image->width, shadow_image->height);
|
||||
|
||||
if (!shadow_pixmap || !shadow_pixmap_argb) {
|
||||
log_error("Failed to create shadow pixmaps");
|
||||
goto shadow_picture_err;
|
||||
}
|
||||
|
||||
shadow_picture = x_create_picture_with_standard_and_pixmap(
|
||||
c, XCB_PICT_STANDARD_A_8, shadow_pixmap, 0, NULL);
|
||||
shadow_picture_argb = x_create_picture_with_standard_and_pixmap(
|
||||
c, XCB_PICT_STANDARD_ARGB_32, shadow_pixmap_argb, 0, NULL);
|
||||
if (!shadow_picture || !shadow_picture_argb) {
|
||||
goto shadow_picture_err;
|
||||
}
|
||||
|
||||
gc = x_new_id(c);
|
||||
xcb_create_gc(c, gc, shadow_pixmap, 0, NULL);
|
||||
|
||||
// We need to make room for protocol metadata in the request. The metadata should
|
||||
// be 24 bytes plus padding, let's be generous and give it 1kb
|
||||
auto maximum_image_size = xcb_get_maximum_request_length(c) * 4 - 1024;
|
||||
auto maximum_row =
|
||||
to_u16_checked(clamp(maximum_image_size / shadow_image->stride, 0, UINT16_MAX));
|
||||
if (maximum_row <= 0) {
|
||||
// TODO(yshui) Upload image with XShm
|
||||
log_error("X server request size limit is too restrictive, or the shadow "
|
||||
"image is too wide for us to send a single row of the shadow "
|
||||
"image. Shadow size: %dx%d",
|
||||
width, height);
|
||||
goto shadow_picture_err;
|
||||
}
|
||||
|
||||
for (uint32_t row = 0; row < shadow_image->height; row += maximum_row) {
|
||||
auto batch_height = maximum_row;
|
||||
if (batch_height > shadow_image->height - row) {
|
||||
batch_height = to_u16_checked(shadow_image->height - row);
|
||||
}
|
||||
|
||||
uint32_t offset = row * shadow_image->stride / sizeof(*shadow_image->data);
|
||||
xcb_put_image(c, (uint8_t)shadow_image->format, shadow_pixmap, gc,
|
||||
shadow_image->width, batch_height, 0, to_i16_checked(row),
|
||||
0, shadow_image->depth, shadow_image->stride * batch_height,
|
||||
shadow_image->data + offset);
|
||||
}
|
||||
|
||||
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, shadow_pixel, shadow_picture,
|
||||
shadow_picture_argb, 0, 0, 0, 0, 0, 0, shadow_image->width,
|
||||
shadow_image->height);
|
||||
|
||||
*pixmap = shadow_pixmap_argb;
|
||||
*pict = shadow_picture_argb;
|
||||
|
||||
xcb_free_gc(c, gc);
|
||||
xcb_image_destroy(shadow_image);
|
||||
xcb_free_pixmap(c, shadow_pixmap);
|
||||
xcb_render_free_picture(c, shadow_picture);
|
||||
|
||||
return true;
|
||||
|
||||
shadow_picture_err:
|
||||
if (shadow_image) {
|
||||
xcb_image_destroy(shadow_image);
|
||||
}
|
||||
if (shadow_pixmap) {
|
||||
xcb_free_pixmap(c, shadow_pixmap);
|
||||
}
|
||||
if (shadow_pixmap_argb) {
|
||||
xcb_free_pixmap(c, shadow_pixmap_argb);
|
||||
}
|
||||
if (shadow_picture) {
|
||||
xcb_render_free_picture(c, shadow_picture);
|
||||
}
|
||||
if (shadow_picture_argb) {
|
||||
xcb_render_free_picture(c, shadow_picture_argb);
|
||||
}
|
||||
if (gc) {
|
||||
xcb_free_gc(c, gc);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void *
|
||||
default_backend_render_shadow(backend_t *backend_data, int width, int height,
|
||||
const conv *kernel, double r, double g, double b, double a) {
|
||||
xcb_pixmap_t shadow_pixel = solid_picture(backend_data->c, backend_data->root,
|
||||
true, 1, r, g, b),
|
||||
shadow = XCB_NONE;
|
||||
xcb_render_picture_t pict = XCB_NONE;
|
||||
|
||||
if (!build_shadow(backend_data->c, backend_data->root, a, width, height, kernel,
|
||||
shadow_pixel, &shadow, &pict)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
auto visual = x_get_visual_for_standard(backend_data->c, XCB_PICT_STANDARD_ARGB_32);
|
||||
void *ret = backend_data->ops->bind_pixmap(
|
||||
backend_data, shadow, x_get_visual_info(backend_data->c, visual), true);
|
||||
xcb_render_free_picture(backend_data->c, pict);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct conv **generate_box_blur_kernel(struct box_blur_args *args, int *kernel_count) {
|
||||
int r = args->size * 2 + 1;
|
||||
assert(r > 0);
|
||||
auto ret = ccalloc(2, struct conv *);
|
||||
ret[0] = cvalloc(sizeof(struct conv) + sizeof(double) * (size_t)r);
|
||||
ret[1] = cvalloc(sizeof(struct conv) + sizeof(double) * (size_t)r);
|
||||
ret[0]->w = r;
|
||||
ret[0]->h = 1;
|
||||
ret[1]->w = 1;
|
||||
ret[1]->h = r;
|
||||
for (int i = 0; i < r; i++) {
|
||||
ret[0]->data[i] = 1;
|
||||
ret[1]->data[i] = 1;
|
||||
}
|
||||
*kernel_count = 2;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct conv **
|
||||
generate_gaussian_blur_kernel(struct gaussian_blur_args *args, int *kernel_count) {
|
||||
int r = args->size * 2 + 1;
|
||||
assert(r > 0);
|
||||
auto ret = ccalloc(2, struct conv *);
|
||||
ret[0] = cvalloc(sizeof(struct conv) + sizeof(double) * (size_t)r);
|
||||
ret[1] = cvalloc(sizeof(struct conv) + sizeof(double) * (size_t)r);
|
||||
ret[0]->w = r;
|
||||
ret[0]->h = 1;
|
||||
ret[1]->w = 1;
|
||||
ret[1]->h = r;
|
||||
for (int i = 0; i <= args->size; i++) {
|
||||
ret[0]->data[i] = ret[0]->data[r - i - 1] =
|
||||
1.0 / (sqrt(2.0 * M_PI) * args->deviation) *
|
||||
exp(-(args->size - i) * (args->size - i) /
|
||||
(2 * args->deviation * args->deviation));
|
||||
ret[1]->data[i] = ret[1]->data[r - i - 1] = ret[0]->data[i];
|
||||
}
|
||||
*kernel_count = 2;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// Generate blur kernels for gaussian and box blur methods. Generated kernel is not
|
||||
/// normalized, and the center element will always be 1.
|
||||
struct conv **generate_blur_kernel(enum blur_method method, void *args, int *kernel_count) {
|
||||
switch (method) {
|
||||
case BLUR_METHOD_BOX: return generate_box_blur_kernel(args, kernel_count);
|
||||
case BLUR_METHOD_GAUSSIAN:
|
||||
return generate_gaussian_blur_kernel(args, kernel_count);
|
||||
default: break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/// Generate kernel parameters for dual-kawase blur method. Falls back on approximating
|
||||
/// standard gauss radius if strength is zero or below.
|
||||
struct dual_kawase_params *generate_dual_kawase_params(void *args) {
|
||||
struct dual_kawase_blur_args *blur_args = args;
|
||||
static const struct {
|
||||
int iterations; /// Number of down- and upsample iterations
|
||||
float offset; /// Sample offset in half-pixels
|
||||
int min_radius; /// Approximate gauss-blur with at least this
|
||||
/// radius and std-deviation
|
||||
} strength_levels[20] = {
|
||||
{.iterations = 1, .offset = 1.25f, .min_radius = 1}, // LVL 1
|
||||
{.iterations = 1, .offset = 2.25f, .min_radius = 6}, // LVL 2
|
||||
{.iterations = 2, .offset = 2.00f, .min_radius = 11}, // LVL 3
|
||||
{.iterations = 2, .offset = 3.00f, .min_radius = 17}, // LVL 4
|
||||
{.iterations = 2, .offset = 4.25f, .min_radius = 24}, // LVL 5
|
||||
{.iterations = 3, .offset = 2.50f, .min_radius = 32}, // LVL 6
|
||||
{.iterations = 3, .offset = 3.25f, .min_radius = 40}, // LVL 7
|
||||
{.iterations = 3, .offset = 4.25f, .min_radius = 51}, // LVL 8
|
||||
{.iterations = 3, .offset = 5.50f, .min_radius = 67}, // LVL 9
|
||||
{.iterations = 4, .offset = 3.25f, .min_radius = 83}, // LVL 10
|
||||
{.iterations = 4, .offset = 4.00f, .min_radius = 101}, // LVL 11
|
||||
{.iterations = 4, .offset = 5.00f, .min_radius = 123}, // LVL 12
|
||||
{.iterations = 4, .offset = 6.00f, .min_radius = 148}, // LVL 13
|
||||
{.iterations = 4, .offset = 7.25f, .min_radius = 178}, // LVL 14
|
||||
{.iterations = 4, .offset = 8.25f, .min_radius = 208}, // LVL 15
|
||||
{.iterations = 5, .offset = 4.50f, .min_radius = 236}, // LVL 16
|
||||
{.iterations = 5, .offset = 5.25f, .min_radius = 269}, // LVL 17
|
||||
{.iterations = 5, .offset = 6.25f, .min_radius = 309}, // LVL 18
|
||||
{.iterations = 5, .offset = 7.25f, .min_radius = 357}, // LVL 19
|
||||
{.iterations = 5, .offset = 8.50f, .min_radius = 417}, // LVL 20
|
||||
};
|
||||
|
||||
auto params = ccalloc(1, struct dual_kawase_params);
|
||||
params->iterations = 0;
|
||||
params->offset = 1.0f;
|
||||
|
||||
if (blur_args->strength <= 0 && blur_args->size) {
|
||||
// find highest level that approximates blur-strength with the selected
|
||||
// gaussian blur-radius
|
||||
int lvl = 1;
|
||||
while (strength_levels[lvl - 1].min_radius < blur_args->size && lvl < 20) {
|
||||
++lvl;
|
||||
}
|
||||
blur_args->strength = lvl;
|
||||
}
|
||||
if (blur_args->strength <= 0) {
|
||||
// default value
|
||||
blur_args->strength = 5;
|
||||
}
|
||||
|
||||
assert(blur_args->strength > 0 && blur_args->strength <= 20);
|
||||
params->iterations = strength_levels[blur_args->strength - 1].iterations;
|
||||
params->offset = strength_levels[blur_args->strength - 1].offset;
|
||||
|
||||
// Expand sample area to cover the smallest texture / highest selected iteration:
|
||||
// - Smallest texture dimensions are halved `iterations`-times
|
||||
// - Upsample needs pixels two-times `offset` away from the border
|
||||
// - Plus one for interpolation differences
|
||||
params->expand = (1 << params->iterations) * 2 * (int)ceil(params->offset) + 1;
|
||||
|
||||
return params;
|
||||
}
|
||||
|
||||
void *default_clone_image(backend_t *base attr_unused, const void *image_data,
|
||||
const region_t *reg_visible attr_unused) {
|
||||
auto new_img = ccalloc(1, struct backend_image);
|
||||
*new_img = *(struct backend_image *)image_data;
|
||||
new_img->inner->refcount++;
|
||||
return new_img;
|
||||
}
|
||||
|
||||
bool default_set_image_property(backend_t *base attr_unused, enum image_properties op,
|
||||
void *image_data, void *arg) {
|
||||
struct backend_image *tex = image_data;
|
||||
int *iargs = arg;
|
||||
bool *bargs = arg;
|
||||
double *dargs = arg;
|
||||
switch (op) {
|
||||
case IMAGE_PROPERTY_INVERTED: tex->color_inverted = bargs[0]; break;
|
||||
case IMAGE_PROPERTY_DIM_LEVEL: tex->dim = dargs[0]; break;
|
||||
case IMAGE_PROPERTY_OPACITY: tex->opacity = dargs[0]; break;
|
||||
case IMAGE_PROPERTY_EFFECTIVE_SIZE:
|
||||
// texture is already set to repeat, so nothing else we need to do
|
||||
tex->ewidth = iargs[0];
|
||||
tex->eheight = iargs[1];
|
||||
break;
|
||||
case IMAGE_PROPERTY_CORNER_RADIUS: tex->corner_radius = dargs[0]; break;
|
||||
case IMAGE_PROPERTY_MAX_BRIGHTNESS: tex->max_brightness = dargs[0]; break;
|
||||
case IMAGE_PROPERTY_BORDER_WIDTH: tex->border_width = *(int *)arg; break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool default_is_image_transparent(backend_t *base attr_unused, void *image_data) {
|
||||
struct backend_image *img = image_data;
|
||||
return img->opacity < 1 || img->inner->has_alpha;
|
||||
}
|
||||
|
||||
struct backend_image *default_new_backend_image(int w, int h) {
|
||||
auto ret = ccalloc(1, struct backend_image);
|
||||
ret->opacity = 1;
|
||||
ret->dim = 0;
|
||||
ret->max_brightness = 1;
|
||||
ret->eheight = h;
|
||||
ret->ewidth = w;
|
||||
ret->color_inverted = false;
|
||||
ret->corner_radius = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void init_backend_base(struct backend_base *base, session_t *ps) {
|
||||
base->c = ps->c;
|
||||
base->loop = ps->loop;
|
||||
base->root = ps->root;
|
||||
base->busy = false;
|
||||
base->ops = NULL;
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb_image.h>
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "backend.h"
|
||||
#include "config.h"
|
||||
#include "region.h"
|
||||
|
||||
typedef struct session session_t;
|
||||
typedef struct win win;
|
||||
typedef struct conv conv;
|
||||
typedef struct backend_base backend_t;
|
||||
struct backend_operations;
|
||||
|
||||
struct dual_kawase_params {
|
||||
/// Number of downsample passes
|
||||
int iterations;
|
||||
/// Pixel offset for down- and upsample
|
||||
float offset;
|
||||
/// Save area around blur target (@ref resize_width, @ref resize_height)
|
||||
int expand;
|
||||
};
|
||||
|
||||
struct backend_image_inner_base {
|
||||
int refcount;
|
||||
bool has_alpha;
|
||||
};
|
||||
|
||||
struct backend_image {
|
||||
// Backend dependent inner image data
|
||||
struct backend_image_inner_base *inner;
|
||||
double opacity;
|
||||
double dim;
|
||||
double max_brightness;
|
||||
double corner_radius;
|
||||
// Effective size of the image
|
||||
int ewidth, eheight;
|
||||
bool color_inverted;
|
||||
int border_width;
|
||||
};
|
||||
|
||||
bool build_shadow(xcb_connection_t *, xcb_drawable_t, double opacity, int width,
|
||||
int height, const conv *kernel, xcb_render_picture_t shadow_pixel,
|
||||
xcb_pixmap_t *pixmap, xcb_render_picture_t *pict);
|
||||
|
||||
xcb_render_picture_t solid_picture(xcb_connection_t *, xcb_drawable_t, bool argb,
|
||||
double a, double r, double g, double b);
|
||||
|
||||
xcb_image_t *
|
||||
make_shadow(xcb_connection_t *c, const conv *kernel, double opacity, int width, int height);
|
||||
|
||||
/// The default implementation of `is_win_transparent`, it simply looks at win::mode. So
|
||||
/// this is not suitable for backends that alter the content of windows
|
||||
bool default_is_win_transparent(void *, win *, void *);
|
||||
|
||||
/// The default implementation of `is_frame_transparent`, it uses win::frame_opacity. Same
|
||||
/// caveat as `default_is_win_transparent` applies.
|
||||
bool default_is_frame_transparent(void *, win *, void *);
|
||||
|
||||
void *
|
||||
default_backend_render_shadow(backend_t *backend_data, int width, int height,
|
||||
const conv *kernel, double r, double g, double b, double a);
|
||||
|
||||
void init_backend_base(struct backend_base *base, session_t *ps);
|
||||
|
||||
struct conv **generate_blur_kernel(enum blur_method method, void *args, int *kernel_count);
|
||||
struct dual_kawase_params *generate_dual_kawase_params(void *args);
|
||||
|
||||
void *default_clone_image(backend_t *base, const void *image_data, const region_t *reg);
|
||||
void *default_resize_image(backend_t *base, const void *image_data, uint16_t desired_width,
|
||||
uint16_t desired_height, const region_t *reg);
|
||||
bool default_is_image_transparent(backend_t *base attr_unused, void *image_data);
|
||||
bool default_set_image_property(backend_t *base attr_unused, enum image_properties op,
|
||||
void *image_data, void *arg);
|
||||
struct backend_image *default_new_backend_image(int w, int h);
|
||||
@@ -0,0 +1,82 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <xcb/randr.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "backend/driver.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "log.h"
|
||||
|
||||
/// Apply driver specified global workarounds. It's safe to call this multiple times.
|
||||
void apply_driver_workarounds(struct session *ps, enum driver driver) {
|
||||
if (driver & DRIVER_NVIDIA) {
|
||||
// setenv("__GL_YIELD", "usleep", true);
|
||||
setenv("__GL_MaxFramesAllowed", "1", true);
|
||||
ps->o.xrender_sync_fence = true;
|
||||
}
|
||||
}
|
||||
|
||||
enum driver detect_driver(xcb_connection_t *c, backend_t *backend_data, xcb_window_t window) {
|
||||
enum driver ret = 0;
|
||||
// First we try doing backend agnostic detection using RANDR
|
||||
// There's no way to query the X server about what driver is loaded, so RANDR is
|
||||
// our best shot.
|
||||
auto randr_version = xcb_randr_query_version_reply(
|
||||
c, xcb_randr_query_version(c, XCB_RANDR_MAJOR_VERSION, XCB_RANDR_MINOR_VERSION),
|
||||
NULL);
|
||||
if (randr_version &&
|
||||
(randr_version->major_version > 1 || randr_version->minor_version >= 4)) {
|
||||
auto r = xcb_randr_get_providers_reply(
|
||||
c, xcb_randr_get_providers(c, window), NULL);
|
||||
if (r == NULL) {
|
||||
log_warn("Failed to get RANDR providers");
|
||||
free(randr_version);
|
||||
return 0;
|
||||
}
|
||||
|
||||
auto providers = xcb_randr_get_providers_providers(r);
|
||||
for (auto i = 0; i < xcb_randr_get_providers_providers_length(r); i++) {
|
||||
auto r2 = xcb_randr_get_provider_info_reply(
|
||||
c, xcb_randr_get_provider_info(c, providers[i], r->timestamp), NULL);
|
||||
if (r2 == NULL) {
|
||||
continue;
|
||||
}
|
||||
if (r2->num_outputs == 0) {
|
||||
free(r2);
|
||||
continue;
|
||||
}
|
||||
|
||||
auto name_len = xcb_randr_get_provider_info_name_length(r2);
|
||||
assert(name_len >= 0);
|
||||
auto name =
|
||||
strndup(xcb_randr_get_provider_info_name(r2), (size_t)name_len);
|
||||
if (strcasestr(name, "modesetting") != NULL) {
|
||||
ret |= DRIVER_MODESETTING;
|
||||
} else if (strcasestr(name, "Radeon") != NULL) {
|
||||
// Be conservative, add both radeon drivers
|
||||
ret |= DRIVER_AMDGPU | DRIVER_RADEON;
|
||||
} else if (strcasestr(name, "NVIDIA") != NULL) {
|
||||
ret |= DRIVER_NVIDIA;
|
||||
} else if (strcasestr(name, "nouveau") != NULL) {
|
||||
ret |= DRIVER_NOUVEAU;
|
||||
} else if (strcasestr(name, "Intel") != NULL) {
|
||||
ret |= DRIVER_INTEL;
|
||||
}
|
||||
free(name);
|
||||
free(r2);
|
||||
}
|
||||
free(r);
|
||||
}
|
||||
free(randr_version);
|
||||
|
||||
// If the backend supports driver detection, use that as well
|
||||
if (backend_data && backend_data->ops->detect_driver) {
|
||||
ret |= backend_data->ops->detect_driver(backend_data);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "utils.h"
|
||||
|
||||
struct session;
|
||||
struct backend_base;
|
||||
|
||||
// A list of known driver quirks:
|
||||
// * NVIDIA driver doesn't like seeing the same pixmap under different
|
||||
// ids, so avoid naming the pixmap again when it didn't actually change.
|
||||
|
||||
/// A list of possible drivers.
|
||||
/// The driver situation is a bit complicated. There are two drivers we care about: the
|
||||
/// DDX, and the OpenGL driver. They are usually paired, but not always, since there is
|
||||
/// also the generic modesetting driver.
|
||||
/// This enum represents _both_ drivers.
|
||||
enum driver {
|
||||
DRIVER_AMDGPU = 1, // AMDGPU for DDX, radeonsi for OpenGL
|
||||
DRIVER_RADEON = 2, // ATI for DDX, mesa r600 for OpenGL
|
||||
DRIVER_FGLRX = 4,
|
||||
DRIVER_NVIDIA = 8,
|
||||
DRIVER_NOUVEAU = 16,
|
||||
DRIVER_INTEL = 32,
|
||||
DRIVER_MODESETTING = 64,
|
||||
};
|
||||
|
||||
static const char *driver_names[] = {
|
||||
"AMDGPU", "Radeon", "fglrx", "NVIDIA", "nouveau", "Intel", "modesetting",
|
||||
};
|
||||
|
||||
/// Return a list of all drivers currently in use by the X server.
|
||||
/// Note, this is a best-effort test, so no guarantee all drivers will be detected.
|
||||
enum driver detect_driver(xcb_connection_t *, struct backend_base *, xcb_window_t);
|
||||
|
||||
/// Apply driver specified global workarounds. It's safe to call this multiple times.
|
||||
void apply_driver_workarounds(struct session *ps, enum driver);
|
||||
|
||||
// Print driver names to stdout, for diagnostics
|
||||
static inline void print_drivers(enum driver drivers) {
|
||||
const char *seen_drivers[ARR_SIZE(driver_names)];
|
||||
int driver_count = 0;
|
||||
for (size_t i = 0; i < ARR_SIZE(driver_names); i++) {
|
||||
if (drivers & (1ul << i)) {
|
||||
seen_drivers[driver_count++] = driver_names[i];
|
||||
}
|
||||
}
|
||||
|
||||
if (driver_count > 0) {
|
||||
printf("%s", seen_drivers[0]);
|
||||
for (int i = 1; i < driver_count; i++) {
|
||||
printf(", %s", seen_drivers[i]);
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
@@ -0,0 +1,174 @@
|
||||
#include <uthash.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "backend/backend_common.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "uthash_extra.h"
|
||||
#include "utils.h"
|
||||
#include "x.h"
|
||||
|
||||
struct dummy_image {
|
||||
xcb_pixmap_t pixmap;
|
||||
bool transparent;
|
||||
int *refcount;
|
||||
UT_hash_handle hh;
|
||||
};
|
||||
|
||||
struct dummy_data {
|
||||
struct backend_base base;
|
||||
struct dummy_image *images;
|
||||
};
|
||||
|
||||
struct backend_base *dummy_init(struct session *ps attr_unused) {
|
||||
auto ret = (struct backend_base *)ccalloc(1, struct dummy_data);
|
||||
ret->c = ps->c;
|
||||
ret->loop = ps->loop;
|
||||
ret->root = ps->root;
|
||||
ret->busy = false;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void dummy_deinit(struct backend_base *data) {
|
||||
auto dummy = (struct dummy_data *)data;
|
||||
HASH_ITER2(dummy->images, img) {
|
||||
log_warn("Backend image for pixmap %#010x is not freed", img->pixmap);
|
||||
HASH_DEL(dummy->images, img);
|
||||
free(img->refcount);
|
||||
free(img);
|
||||
}
|
||||
free(dummy);
|
||||
}
|
||||
|
||||
static void dummy_check_image(struct backend_base *base, const struct dummy_image *img) {
|
||||
auto dummy = (struct dummy_data *)base;
|
||||
struct dummy_image *tmp = NULL;
|
||||
HASH_FIND_INT(dummy->images, &img->pixmap, tmp);
|
||||
if (!tmp) {
|
||||
log_warn("Using an invalid (possibly freed) image");
|
||||
assert(false);
|
||||
}
|
||||
assert(*tmp->refcount > 0);
|
||||
}
|
||||
|
||||
void dummy_compose(struct backend_base *base, void *image, int dst_x1 attr_unused,
|
||||
int dst_y1 attr_unused, int dst_x2 attr_unused, int dst_y2 attr_unused,
|
||||
const region_t *reg_paint attr_unused, const region_t *reg_visible attr_unused) {
|
||||
dummy_check_image(base, image);
|
||||
}
|
||||
|
||||
void dummy_fill(struct backend_base *backend_data attr_unused, struct color c attr_unused,
|
||||
const region_t *clip attr_unused) {
|
||||
}
|
||||
|
||||
bool dummy_blur(struct backend_base *backend_data attr_unused, double opacity attr_unused,
|
||||
void *blur_ctx attr_unused, const region_t *reg_blur attr_unused,
|
||||
const region_t *reg_visible attr_unused) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void *dummy_bind_pixmap(struct backend_base *base, xcb_pixmap_t pixmap,
|
||||
struct xvisual_info fmt, bool owned attr_unused) {
|
||||
auto dummy = (struct dummy_data *)base;
|
||||
struct dummy_image *img = NULL;
|
||||
HASH_FIND_INT(dummy->images, &pixmap, img);
|
||||
if (img) {
|
||||
(*img->refcount)++;
|
||||
return img;
|
||||
}
|
||||
|
||||
img = ccalloc(1, struct dummy_image);
|
||||
img->pixmap = pixmap;
|
||||
img->transparent = fmt.alpha_size != 0;
|
||||
img->refcount = ccalloc(1, int);
|
||||
*img->refcount = 1;
|
||||
|
||||
HASH_ADD_INT(dummy->images, pixmap, img);
|
||||
return (void *)img;
|
||||
}
|
||||
|
||||
void dummy_release_image(backend_t *base, void *image) {
|
||||
auto dummy = (struct dummy_data *)base;
|
||||
auto img = (struct dummy_image *)image;
|
||||
assert(*img->refcount > 0);
|
||||
(*img->refcount)--;
|
||||
if (*img->refcount == 0) {
|
||||
HASH_DEL(dummy->images, img);
|
||||
free(img->refcount);
|
||||
free(img);
|
||||
}
|
||||
}
|
||||
|
||||
bool dummy_is_image_transparent(struct backend_base *base, void *image) {
|
||||
auto img = (struct dummy_image *)image;
|
||||
dummy_check_image(base, img);
|
||||
return img->transparent;
|
||||
}
|
||||
|
||||
int dummy_buffer_age(struct backend_base *base attr_unused) {
|
||||
return 2;
|
||||
}
|
||||
|
||||
bool dummy_image_op(struct backend_base *base, enum image_operations op attr_unused,
|
||||
void *image, const region_t *reg_op attr_unused,
|
||||
const region_t *reg_visible attr_unused, void *args attr_unused) {
|
||||
dummy_check_image(base, image);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool dummy_set_image_property(struct backend_base *base, enum image_properties prop attr_unused,
|
||||
void *image, void *arg attr_unused) {
|
||||
dummy_check_image(base, image);
|
||||
return true;
|
||||
}
|
||||
|
||||
void *dummy_clone_image(struct backend_base *base, const void *image,
|
||||
const region_t *reg_visible attr_unused) {
|
||||
auto img = (const struct dummy_image *)image;
|
||||
dummy_check_image(base, img);
|
||||
(*img->refcount)++;
|
||||
return (void *)img;
|
||||
}
|
||||
|
||||
void *dummy_create_blur_context(struct backend_base *base attr_unused,
|
||||
enum blur_method method attr_unused, void *args attr_unused) {
|
||||
static int dummy_context;
|
||||
return &dummy_context;
|
||||
}
|
||||
|
||||
void dummy_destroy_blur_context(struct backend_base *base attr_unused, void *ctx attr_unused) {
|
||||
}
|
||||
|
||||
void dummy_get_blur_size(void *ctx attr_unused, int *width, int *height) {
|
||||
// These numbers are arbitrary, to make sure the reisze_region code path is
|
||||
// covered.
|
||||
*width = 5;
|
||||
*height = 5;
|
||||
}
|
||||
|
||||
struct backend_operations dummy_ops = {
|
||||
.init = dummy_init,
|
||||
.deinit = dummy_deinit,
|
||||
.compose = dummy_compose,
|
||||
.fill = dummy_fill,
|
||||
.blur = dummy_blur,
|
||||
.bind_pixmap = dummy_bind_pixmap,
|
||||
.render_shadow = default_backend_render_shadow,
|
||||
.release_image = dummy_release_image,
|
||||
.is_image_transparent = dummy_is_image_transparent,
|
||||
.buffer_age = dummy_buffer_age,
|
||||
.max_buffer_age = 5,
|
||||
|
||||
.image_op = dummy_image_op,
|
||||
.clone_image = dummy_clone_image,
|
||||
.set_image_property = dummy_set_image_property,
|
||||
.create_blur_context = dummy_create_blur_context,
|
||||
.destroy_blur_context = dummy_destroy_blur_context,
|
||||
.get_blur_size = dummy_get_blur_size,
|
||||
|
||||
};
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,238 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glext.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
|
||||
#define CASESTRRET(s) \
|
||||
case s: return #s
|
||||
|
||||
static inline GLint glGetUniformLocationChecked(GLuint p, const char *name) {
|
||||
auto ret = glGetUniformLocation(p, name);
|
||||
if (ret < 0) {
|
||||
log_info("Failed to get location of uniform '%s'. This is normal when "
|
||||
"using custom shaders.",
|
||||
name);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define bind_uniform(shader, uniform) \
|
||||
(shader)->uniform_##uniform = glGetUniformLocationChecked((shader)->prog, #uniform)
|
||||
|
||||
// Program and uniforms for window shader
|
||||
typedef struct {
|
||||
GLuint prog;
|
||||
GLint uniform_opacity;
|
||||
GLint uniform_invert_color;
|
||||
GLint uniform_tex;
|
||||
GLint uniform_dim;
|
||||
GLint uniform_brightness;
|
||||
GLint uniform_max_brightness;
|
||||
GLint uniform_corner_radius;
|
||||
GLint uniform_border_width;
|
||||
} gl_win_shader_t;
|
||||
|
||||
// Program and uniforms for brightness shader
|
||||
typedef struct {
|
||||
GLuint prog;
|
||||
} gl_brightness_shader_t;
|
||||
|
||||
// Program and uniforms for blur shader
|
||||
typedef struct {
|
||||
GLuint prog;
|
||||
GLint uniform_pixel_norm;
|
||||
GLint uniform_opacity;
|
||||
GLint texorig_loc;
|
||||
GLint scale_loc;
|
||||
} gl_blur_shader_t;
|
||||
|
||||
typedef struct {
|
||||
GLuint prog;
|
||||
GLint color_loc;
|
||||
} gl_fill_shader_t;
|
||||
|
||||
/// @brief Wrapper of a binded GLX texture.
|
||||
struct gl_texture {
|
||||
int refcount;
|
||||
bool has_alpha;
|
||||
GLuint texture;
|
||||
int width, height;
|
||||
bool y_inverted;
|
||||
|
||||
// Textures for auxiliary uses.
|
||||
GLuint auxiliary_texture[2];
|
||||
void *user_data;
|
||||
};
|
||||
|
||||
struct gl_data {
|
||||
backend_t base;
|
||||
// If we are using proprietary NVIDIA driver
|
||||
bool is_nvidia;
|
||||
// If ARB_robustness extension is present
|
||||
bool has_robustness;
|
||||
// Height and width of the root window
|
||||
int height, width;
|
||||
gl_win_shader_t win_shader;
|
||||
gl_brightness_shader_t brightness_shader;
|
||||
gl_fill_shader_t fill_shader;
|
||||
GLuint back_texture, back_fbo;
|
||||
GLuint present_prog;
|
||||
|
||||
/// Called when an gl_texture is decoupled from the texture it refers. Returns
|
||||
/// the decoupled user_data
|
||||
void *(*decouple_texture_user_data)(backend_t *base, void *user_data);
|
||||
|
||||
/// Release the user data attached to a gl_texture
|
||||
void (*release_user_data)(backend_t *base, struct gl_texture *);
|
||||
|
||||
struct log_target *logger;
|
||||
};
|
||||
|
||||
typedef struct session session_t;
|
||||
|
||||
#define GL_PROG_MAIN_INIT \
|
||||
{ .prog = 0, .unifm_opacity = -1, .unifm_invert_color = -1, .unifm_tex = -1, }
|
||||
|
||||
GLuint gl_create_shader(GLenum shader_type, const char *shader_str);
|
||||
GLuint gl_create_program(const GLuint *const shaders, int nshaders);
|
||||
GLuint gl_create_program_from_str(const char *vert_shader_str, const char *frag_shader_str);
|
||||
|
||||
/**
|
||||
* @brief Render a region with texture data.
|
||||
*/
|
||||
void gl_compose(backend_t *, void *ptex,
|
||||
int dst_x1, int dst_y1, int dst_x2, int dst_y2,
|
||||
const region_t *reg_tgt, const region_t *reg_visible);
|
||||
|
||||
void gl_resize(struct gl_data *, int width, int height);
|
||||
|
||||
bool gl_init(struct gl_data *gd, session_t *);
|
||||
void gl_deinit(struct gl_data *gd);
|
||||
|
||||
GLuint gl_new_texture(GLenum target);
|
||||
|
||||
bool gl_image_op(backend_t *base, enum image_operations op, void *image_data,
|
||||
const region_t *reg_op, const region_t *reg_visible, void *arg);
|
||||
|
||||
void gl_release_image(backend_t *base, void *image_data);
|
||||
|
||||
void *gl_clone(backend_t *base, const void *image_data, const region_t *reg_visible);
|
||||
|
||||
bool gl_blur(backend_t *base, double opacity, void *, const region_t *reg_blur,
|
||||
const region_t *reg_visible);
|
||||
void *gl_create_blur_context(backend_t *base, enum blur_method, void *args);
|
||||
void gl_destroy_blur_context(backend_t *base, void *ctx);
|
||||
void gl_get_blur_size(void *blur_context, int *width, int *height);
|
||||
|
||||
void gl_fill(backend_t *base, struct color, const region_t *clip);
|
||||
|
||||
void gl_present(backend_t *base, const region_t *);
|
||||
bool gl_read_pixel(backend_t *base, void *image_data, int x, int y, struct color *output);
|
||||
enum device_status gl_device_status(backend_t *base);
|
||||
|
||||
static inline void gl_delete_texture(GLuint texture) {
|
||||
glDeleteTextures(1, &texture);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a textual representation of an OpenGL error.
|
||||
*/
|
||||
static inline const char *gl_get_err_str(GLenum err) {
|
||||
switch (err) {
|
||||
CASESTRRET(GL_NO_ERROR);
|
||||
CASESTRRET(GL_INVALID_ENUM);
|
||||
CASESTRRET(GL_INVALID_VALUE);
|
||||
CASESTRRET(GL_INVALID_OPERATION);
|
||||
CASESTRRET(GL_INVALID_FRAMEBUFFER_OPERATION);
|
||||
CASESTRRET(GL_OUT_OF_MEMORY);
|
||||
CASESTRRET(GL_STACK_UNDERFLOW);
|
||||
CASESTRRET(GL_STACK_OVERFLOW);
|
||||
CASESTRRET(GL_FRAMEBUFFER_UNDEFINED);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER);
|
||||
CASESTRRET(GL_FRAMEBUFFER_UNSUPPORTED);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
|
||||
CASESTRRET(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check for GLX error.
|
||||
*
|
||||
* http://blog.nobel-joergensen.com/2013/01/29/debugging-opengl-using-glgeterror/
|
||||
*/
|
||||
static inline void gl_check_err_(const char *func, int line) {
|
||||
GLenum err = GL_NO_ERROR;
|
||||
|
||||
while (GL_NO_ERROR != (err = glGetError())) {
|
||||
const char *errtext = gl_get_err_str(err);
|
||||
if (errtext) {
|
||||
log_printf(tls_logger, LOG_LEVEL_ERROR, func,
|
||||
"GLX error at line %d: %s", line, errtext);
|
||||
} else {
|
||||
log_printf(tls_logger, LOG_LEVEL_ERROR, func,
|
||||
"GLX error at line %d: %d", line, err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void gl_clear_err(void) {
|
||||
while (glGetError() != GL_NO_ERROR)
|
||||
;
|
||||
}
|
||||
|
||||
#define gl_check_err() gl_check_err_(__func__, __LINE__)
|
||||
|
||||
/**
|
||||
* Check for GL framebuffer completeness.
|
||||
*/
|
||||
static inline bool gl_check_fb_complete_(const char *func, int line, GLenum fb) {
|
||||
GLenum status = glCheckFramebufferStatus(fb);
|
||||
|
||||
if (status == GL_FRAMEBUFFER_COMPLETE) {
|
||||
return true;
|
||||
}
|
||||
|
||||
const char *stattext = gl_get_err_str(status);
|
||||
if (stattext) {
|
||||
log_printf(tls_logger, LOG_LEVEL_ERROR, func,
|
||||
"Framebuffer attachment failed at line %d: %s", line, stattext);
|
||||
} else {
|
||||
log_printf(tls_logger, LOG_LEVEL_ERROR, func,
|
||||
"Framebuffer attachment failed at line %d: %d", line, status);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
#define gl_check_fb_complete(fb) gl_check_fb_complete_(__func__, __LINE__, (fb))
|
||||
|
||||
/**
|
||||
* Check if a GLX extension exists.
|
||||
*/
|
||||
static inline bool gl_has_extension(const char *ext) {
|
||||
int nexts = 0;
|
||||
glGetIntegerv(GL_NUM_EXTENSIONS, &nexts);
|
||||
for (int i = 0; i < nexts || !nexts; i++) {
|
||||
const char *exti = (const char *)glGetStringi(GL_EXTENSIONS, (GLuint)i);
|
||||
if (exti == NULL) {
|
||||
break;
|
||||
}
|
||||
if (strcmp(ext, exti) == 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
gl_clear_err();
|
||||
log_info("Missing GL extension %s.", ext);
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,654 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Compton - a compositor for X11
|
||||
*
|
||||
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
|
||||
*
|
||||
* Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
* Copyright (c) 2019 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
* See LICENSE-mit for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <X11/Xlib-xcb.h>
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <pixman.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <xcb/composite.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "backend/backend_common.h"
|
||||
#include "backend/gl/gl_common.h"
|
||||
#include "backend/gl/glx.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "log.h"
|
||||
#include "picom.h"
|
||||
#include "region.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
struct _glx_pixmap {
|
||||
GLXPixmap glpixmap;
|
||||
xcb_pixmap_t pixmap;
|
||||
bool owned;
|
||||
};
|
||||
|
||||
struct _glx_data {
|
||||
struct gl_data gl;
|
||||
Display *display;
|
||||
int screen;
|
||||
xcb_window_t target_win;
|
||||
GLXContext ctx;
|
||||
};
|
||||
|
||||
#define glXGetFBConfigAttribChecked(a, b, attr, c) \
|
||||
do { \
|
||||
if (glXGetFBConfigAttrib(a, b, attr, c)) { \
|
||||
log_info("Cannot get FBConfig attribute " #attr); \
|
||||
continue; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
struct glx_fbconfig_info *glx_find_fbconfig(Display *dpy, int screen, struct xvisual_info m) {
|
||||
log_debug("Looking for FBConfig for RGBA%d%d%d%d, depth %d", m.red_size,
|
||||
m.blue_size, m.green_size, m.alpha_size, m.visual_depth);
|
||||
|
||||
int ncfg;
|
||||
// clang-format off
|
||||
GLXFBConfig *cfg =
|
||||
glXChooseFBConfig(dpy, screen, (int[]){
|
||||
GLX_RENDER_TYPE, GLX_RGBA_BIT,
|
||||
GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
|
||||
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
|
||||
GLX_X_RENDERABLE, true,
|
||||
GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, (GLint)GLX_DONT_CARE,
|
||||
GLX_BUFFER_SIZE, m.red_size + m.green_size +
|
||||
m.blue_size + m.alpha_size,
|
||||
GLX_RED_SIZE, m.red_size,
|
||||
GLX_BLUE_SIZE, m.blue_size,
|
||||
GLX_GREEN_SIZE, m.green_size,
|
||||
GLX_ALPHA_SIZE, m.alpha_size,
|
||||
GLX_STENCIL_SIZE, 0,
|
||||
GLX_DEPTH_SIZE, 0,
|
||||
0
|
||||
}, &ncfg);
|
||||
// clang-format on
|
||||
|
||||
int texture_tgts, y_inverted, texture_fmt;
|
||||
bool found = false;
|
||||
int min_cost = INT_MAX;
|
||||
GLXFBConfig ret;
|
||||
for (int i = 0; i < ncfg; i++) {
|
||||
int depthbuf, stencil, doublebuf, bufsize;
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BUFFER_SIZE, &bufsize);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_DEPTH_SIZE, &depthbuf);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_STENCIL_SIZE, &stencil);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_DOUBLEBUFFER, &doublebuf);
|
||||
if (depthbuf + stencil + bufsize * (doublebuf + 1) >= min_cost) {
|
||||
continue;
|
||||
}
|
||||
int red, green, blue;
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_RED_SIZE, &red);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BLUE_SIZE, &blue);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_GREEN_SIZE, &green);
|
||||
if (red != m.red_size || green != m.green_size || blue != m.blue_size) {
|
||||
// Color size doesn't match, this cannot work
|
||||
continue;
|
||||
}
|
||||
|
||||
int rgb, rgba;
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGB_EXT, &rgb);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &rgba);
|
||||
if (!rgb && !rgba) {
|
||||
log_info("FBConfig is neither RGBA nor RGB, we cannot "
|
||||
"handle this setup.");
|
||||
continue;
|
||||
}
|
||||
|
||||
int visual;
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_VISUAL_ID, &visual);
|
||||
if (m.visual_depth != -1 &&
|
||||
x_get_visual_depth(XGetXCBConnection(dpy), (xcb_visualid_t)visual) !=
|
||||
m.visual_depth) {
|
||||
// FBConfig and the correspondent X Visual might not have the same
|
||||
// depth. (e.g. 32 bit FBConfig with a 24 bit Visual). This is
|
||||
// quite common, seen in both open source and proprietary drivers.
|
||||
//
|
||||
// If the FBConfig has a matching depth but its visual doesn't, we
|
||||
// still cannot use it.
|
||||
continue;
|
||||
}
|
||||
|
||||
// All check passed, we are using this one.
|
||||
found = true;
|
||||
ret = cfg[i];
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT,
|
||||
&texture_tgts);
|
||||
glXGetFBConfigAttribChecked(dpy, cfg[i], GLX_Y_INVERTED_EXT, &y_inverted);
|
||||
|
||||
// Prefer the texture format with matching alpha, with the other one as
|
||||
// fallback
|
||||
if (m.alpha_size) {
|
||||
texture_fmt = rgba ? GLX_TEXTURE_FORMAT_RGBA_EXT
|
||||
: GLX_TEXTURE_FORMAT_RGB_EXT;
|
||||
} else {
|
||||
texture_fmt =
|
||||
rgb ? GLX_TEXTURE_FORMAT_RGB_EXT : GLX_TEXTURE_FORMAT_RGBA_EXT;
|
||||
}
|
||||
min_cost = depthbuf + stencil + bufsize * (doublebuf + 1);
|
||||
}
|
||||
free(cfg);
|
||||
if (!found) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
auto info = cmalloc(struct glx_fbconfig_info);
|
||||
info->cfg = ret;
|
||||
info->texture_tgts = texture_tgts;
|
||||
info->texture_fmt = texture_fmt;
|
||||
info->y_inverted = y_inverted;
|
||||
return info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a glx_texture_t.
|
||||
*/
|
||||
static void glx_release_image(backend_t *base, struct gl_texture *tex) {
|
||||
struct _glx_data *gd = (void *)base;
|
||||
|
||||
struct _glx_pixmap *p = tex->user_data;
|
||||
// Release binding
|
||||
if (p->glpixmap && tex->texture) {
|
||||
glBindTexture(GL_TEXTURE_2D, tex->texture);
|
||||
glXReleaseTexImageEXT(gd->display, p->glpixmap, GLX_FRONT_LEFT_EXT);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
}
|
||||
|
||||
// Free GLX Pixmap
|
||||
if (p->glpixmap) {
|
||||
glXDestroyPixmap(gd->display, p->glpixmap);
|
||||
p->glpixmap = 0;
|
||||
}
|
||||
|
||||
if (p->owned) {
|
||||
xcb_free_pixmap(base->c, p->pixmap);
|
||||
p->pixmap = XCB_NONE;
|
||||
}
|
||||
|
||||
free(p);
|
||||
tex->user_data = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy GLX related resources.
|
||||
*/
|
||||
void glx_deinit(backend_t *base) {
|
||||
struct _glx_data *gd = (void *)base;
|
||||
|
||||
gl_deinit(&gd->gl);
|
||||
|
||||
// Destroy GLX context
|
||||
if (gd->ctx) {
|
||||
glXMakeCurrent(gd->display, None, NULL);
|
||||
glXDestroyContext(gd->display, gd->ctx);
|
||||
gd->ctx = 0;
|
||||
}
|
||||
|
||||
free(gd);
|
||||
}
|
||||
|
||||
static void *glx_decouple_user_data(backend_t *base attr_unused, void *ud attr_unused) {
|
||||
auto ret = cmalloc(struct _glx_pixmap);
|
||||
ret->owned = false;
|
||||
ret->glpixmap = 0;
|
||||
ret->pixmap = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool glx_set_swap_interval(int interval, Display *dpy, GLXDrawable drawable) {
|
||||
bool vsync_enabled = false;
|
||||
if (glxext.has_GLX_MESA_swap_control) {
|
||||
vsync_enabled = (glXSwapIntervalMESA((uint)interval) == 0);
|
||||
}
|
||||
if (!vsync_enabled && glxext.has_GLX_SGI_swap_control) {
|
||||
vsync_enabled = (glXSwapIntervalSGI(interval) == 0);
|
||||
}
|
||||
if (!vsync_enabled && glxext.has_GLX_EXT_swap_control) {
|
||||
// glXSwapIntervalEXT doesn't return if it's successful
|
||||
glXSwapIntervalEXT(dpy, drawable, interval);
|
||||
vsync_enabled = true;
|
||||
}
|
||||
return vsync_enabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize OpenGL.
|
||||
*/
|
||||
static backend_t *glx_init(session_t *ps) {
|
||||
bool success = false;
|
||||
glxext_init(ps->dpy, ps->scr);
|
||||
auto gd = ccalloc(1, struct _glx_data);
|
||||
init_backend_base(&gd->gl.base, ps);
|
||||
|
||||
gd->display = ps->dpy;
|
||||
gd->screen = ps->scr;
|
||||
gd->target_win = session_get_target_window(ps);
|
||||
|
||||
XVisualInfo *pvis = NULL;
|
||||
|
||||
// Check for GLX extension
|
||||
if (!ps->glx_exists) {
|
||||
log_error("No GLX extension.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
// Get XVisualInfo
|
||||
int nitems = 0;
|
||||
XVisualInfo vreq = {.visualid = ps->vis};
|
||||
pvis = XGetVisualInfo(ps->dpy, VisualIDMask, &vreq, &nitems);
|
||||
if (!pvis) {
|
||||
log_error("Failed to acquire XVisualInfo for current visual.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
// Ensure the visual is double-buffered
|
||||
int value = 0;
|
||||
if (glXGetConfig(ps->dpy, pvis, GLX_USE_GL, &value) || !value) {
|
||||
log_error("Root visual is not a GL visual.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (glXGetConfig(ps->dpy, pvis, GLX_STENCIL_SIZE, &value) || !value) {
|
||||
log_error("Root visual lacks stencil buffer.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (glXGetConfig(ps->dpy, pvis, GLX_DOUBLEBUFFER, &value) || !value) {
|
||||
log_error("Root visual is not a double buffered GL visual.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (glXGetConfig(ps->dpy, pvis, GLX_RGBA, &value) || !value) {
|
||||
log_error("Root visual is a color index visual, not supported");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!glxext.has_GLX_EXT_texture_from_pixmap) {
|
||||
log_error("GLX_EXT_texture_from_pixmap is not supported by your driver");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!glxext.has_GLX_ARB_create_context) {
|
||||
log_error("GLX_ARB_create_context is not supported by your driver");
|
||||
goto end;
|
||||
}
|
||||
|
||||
// Find a fbconfig with visualid matching the one from the target win, so we can
|
||||
// be sure that the fbconfig is compatible with our target window.
|
||||
int ncfgs;
|
||||
GLXFBConfig *cfg = glXGetFBConfigs(gd->display, gd->screen, &ncfgs);
|
||||
bool found = false;
|
||||
for (int i = 0; i < ncfgs; i++) {
|
||||
int visualid;
|
||||
glXGetFBConfigAttribChecked(gd->display, cfg[i], GLX_VISUAL_ID, &visualid);
|
||||
if ((VisualID)visualid != pvis->visualid) {
|
||||
continue;
|
||||
}
|
||||
|
||||
int *attributes = (int[]){GLX_CONTEXT_MAJOR_VERSION_ARB,
|
||||
3,
|
||||
GLX_CONTEXT_MINOR_VERSION_ARB,
|
||||
3,
|
||||
GLX_CONTEXT_PROFILE_MASK_ARB,
|
||||
GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
|
||||
0,
|
||||
0,
|
||||
0};
|
||||
if (glxext.has_GLX_ARB_create_context_robustness) {
|
||||
attributes[6] = GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB;
|
||||
attributes[7] = GLX_LOSE_CONTEXT_ON_RESET_ARB;
|
||||
}
|
||||
|
||||
gd->ctx = glXCreateContextAttribsARB(ps->dpy, cfg[i], 0, true, attributes);
|
||||
free(cfg);
|
||||
|
||||
if (!gd->ctx) {
|
||||
log_error("Failed to get GLX context.");
|
||||
goto end;
|
||||
}
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!found) {
|
||||
log_error("Couldn't find a suitable fbconfig for the target window");
|
||||
goto end;
|
||||
}
|
||||
|
||||
// Attach GLX context
|
||||
GLXDrawable tgt = gd->target_win;
|
||||
if (!glXMakeCurrent(ps->dpy, tgt, gd->ctx)) {
|
||||
log_error("Failed to attach GLX context.");
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!gl_init(&gd->gl, ps)) {
|
||||
log_error("Failed to setup OpenGL");
|
||||
goto end;
|
||||
}
|
||||
|
||||
gd->gl.decouple_texture_user_data = glx_decouple_user_data;
|
||||
gd->gl.release_user_data = glx_release_image;
|
||||
|
||||
if (ps->o.vsync) {
|
||||
if (!glx_set_swap_interval(1, ps->dpy, tgt)) {
|
||||
log_error("Failed to enable vsync.");
|
||||
}
|
||||
} else {
|
||||
glx_set_swap_interval(0, ps->dpy, tgt);
|
||||
}
|
||||
|
||||
success = true;
|
||||
|
||||
end:
|
||||
if (pvis) {
|
||||
XFree(pvis);
|
||||
}
|
||||
|
||||
if (!success) {
|
||||
glx_deinit(&gd->gl.base);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return &gd->gl.base;
|
||||
}
|
||||
|
||||
static void *
|
||||
glx_bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool owned) {
|
||||
struct _glx_data *gd = (void *)base;
|
||||
struct _glx_pixmap *glxpixmap = NULL;
|
||||
// Retrieve pixmap parameters, if they aren't provided
|
||||
if (fmt.visual_depth > OPENGL_MAX_DEPTH) {
|
||||
log_error("Requested depth %d higher than max possible depth %d.",
|
||||
fmt.visual_depth, OPENGL_MAX_DEPTH);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (fmt.visual_depth < 0) {
|
||||
log_error("Pixmap %#010x with invalid depth %d", pixmap, fmt.visual_depth);
|
||||
return false;
|
||||
}
|
||||
|
||||
auto r = xcb_get_geometry_reply(base->c, xcb_get_geometry(base->c, pixmap), NULL);
|
||||
if (!r) {
|
||||
log_error("Invalid pixmap %#010x", pixmap);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
log_trace("Binding pixmap %#010x", pixmap);
|
||||
auto wd = ccalloc(1, struct backend_image);
|
||||
wd->max_brightness = 1;
|
||||
auto inner = ccalloc(1, struct gl_texture);
|
||||
inner->width = wd->ewidth = r->width;
|
||||
inner->height = wd->eheight = r->height;
|
||||
wd->inner = (struct backend_image_inner_base *)inner;
|
||||
free(r);
|
||||
|
||||
auto fbcfg = glx_find_fbconfig(gd->display, gd->screen, fmt);
|
||||
if (!fbcfg) {
|
||||
log_error("Couldn't find FBConfig with requested visual %x", fmt.visual);
|
||||
goto err;
|
||||
}
|
||||
|
||||
// Choose a suitable texture target for our pixmap.
|
||||
// Refer to GLX_EXT_texture_om_pixmap spec to see what are the mean
|
||||
// of the bits in texture_tgts
|
||||
if (!(fbcfg->texture_tgts & GLX_TEXTURE_2D_BIT_EXT)) {
|
||||
log_error("Cannot bind pixmap to GL_TEXTURE_2D, giving up");
|
||||
goto err;
|
||||
}
|
||||
|
||||
log_debug("depth %d, rgba %d", fmt.visual_depth,
|
||||
(fbcfg->texture_fmt == GLX_TEXTURE_FORMAT_RGBA_EXT));
|
||||
|
||||
GLint attrs[] = {
|
||||
GLX_TEXTURE_FORMAT_EXT,
|
||||
fbcfg->texture_fmt,
|
||||
GLX_TEXTURE_TARGET_EXT,
|
||||
GLX_TEXTURE_2D_EXT,
|
||||
0,
|
||||
};
|
||||
|
||||
inner->y_inverted = fbcfg->y_inverted;
|
||||
|
||||
glxpixmap = cmalloc(struct _glx_pixmap);
|
||||
glxpixmap->pixmap = pixmap;
|
||||
glxpixmap->glpixmap = glXCreatePixmap(gd->display, fbcfg->cfg, pixmap, attrs);
|
||||
glxpixmap->owned = owned;
|
||||
free(fbcfg);
|
||||
|
||||
if (!glxpixmap->glpixmap) {
|
||||
log_error("Failed to create glpixmap for pixmap %#010x", pixmap);
|
||||
goto err;
|
||||
}
|
||||
|
||||
log_trace("GLXPixmap %#010lx", glxpixmap->glpixmap);
|
||||
|
||||
// Create texture
|
||||
inner->user_data = glxpixmap;
|
||||
inner->texture = gl_new_texture(GL_TEXTURE_2D);
|
||||
inner->has_alpha = fmt.alpha_size != 0;
|
||||
wd->opacity = 1;
|
||||
wd->color_inverted = false;
|
||||
wd->dim = 0;
|
||||
wd->inner->refcount = 1;
|
||||
glBindTexture(GL_TEXTURE_2D, inner->texture);
|
||||
glXBindTexImageEXT(gd->display, glxpixmap->glpixmap, GLX_FRONT_LEFT_EXT, NULL);
|
||||
glBindTexture(GL_TEXTURE_2D, 0);
|
||||
|
||||
gl_check_err();
|
||||
return wd;
|
||||
err:
|
||||
if (glxpixmap && glxpixmap->glpixmap) {
|
||||
glXDestroyPixmap(gd->display, glxpixmap->glpixmap);
|
||||
}
|
||||
free(glxpixmap);
|
||||
|
||||
if (owned) {
|
||||
xcb_free_pixmap(base->c, pixmap);
|
||||
}
|
||||
free(wd);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void glx_present(backend_t *base, const region_t *region attr_unused) {
|
||||
struct _glx_data *gd = (void *)base;
|
||||
gl_present(base, region);
|
||||
glXSwapBuffers(gd->display, gd->target_win);
|
||||
if (!gd->gl.is_nvidia) {
|
||||
glFinish();
|
||||
}
|
||||
}
|
||||
|
||||
static int glx_buffer_age(backend_t *base) {
|
||||
if (!glxext.has_GLX_EXT_buffer_age) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct _glx_data *gd = (void *)base;
|
||||
unsigned int val;
|
||||
glXQueryDrawable(gd->display, gd->target_win, GLX_BACK_BUFFER_AGE_EXT, &val);
|
||||
return (int)val ?: -1;
|
||||
}
|
||||
|
||||
static void glx_diagnostics(backend_t *base) {
|
||||
struct _glx_data *gd = (void *)base;
|
||||
bool warn_software_rendering = false;
|
||||
const char *software_renderer_names[] = {"llvmpipe", "SWR", "softpipe"};
|
||||
auto glx_vendor = glXGetClientString(gd->display, GLX_VENDOR);
|
||||
printf("* Driver vendors:\n");
|
||||
printf(" * GLX: %s\n", glx_vendor);
|
||||
printf(" * GL: %s\n", glGetString(GL_VENDOR));
|
||||
|
||||
auto gl_renderer = (const char *)glGetString(GL_RENDERER);
|
||||
printf("* GL renderer: %s\n", gl_renderer);
|
||||
if (strcmp(glx_vendor, "Mesa Project and SGI")) {
|
||||
for (size_t i = 0; i < ARR_SIZE(software_renderer_names); i++) {
|
||||
if (strstr(gl_renderer, software_renderer_names[i]) != NULL) {
|
||||
warn_software_rendering = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef GLX_MESA_query_renderer
|
||||
if (glxext.has_GLX_MESA_query_renderer) {
|
||||
unsigned int accelerated = 0;
|
||||
glXQueryCurrentRendererIntegerMESA(GLX_RENDERER_ACCELERATED_MESA, &accelerated);
|
||||
printf("* Accelerated: %d\n", accelerated);
|
||||
|
||||
// Trust GLX_MESA_query_renderer when it's available
|
||||
warn_software_rendering = (accelerated == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (warn_software_rendering) {
|
||||
printf("\n(You are using a software renderer. Unless you are doing this\n"
|
||||
"intentionally, this means you don't have a graphics driver\n"
|
||||
"properly installed. Performance will suffer. Please fix this\n"
|
||||
"before reporting your issue.)\n");
|
||||
}
|
||||
}
|
||||
|
||||
struct backend_operations glx_ops = {
|
||||
.init = glx_init,
|
||||
.deinit = glx_deinit,
|
||||
.bind_pixmap = glx_bind_pixmap,
|
||||
.release_image = gl_release_image,
|
||||
.compose = gl_compose,
|
||||
.image_op = gl_image_op,
|
||||
.set_image_property = default_set_image_property,
|
||||
.clone_image = default_clone_image,
|
||||
.blur = gl_blur,
|
||||
.is_image_transparent = default_is_image_transparent,
|
||||
.present = glx_present,
|
||||
.buffer_age = glx_buffer_age,
|
||||
.render_shadow = default_backend_render_shadow,
|
||||
.fill = gl_fill,
|
||||
.create_blur_context = gl_create_blur_context,
|
||||
.destroy_blur_context = gl_destroy_blur_context,
|
||||
.get_blur_size = gl_get_blur_size,
|
||||
.diagnostics = glx_diagnostics,
|
||||
.device_status = gl_device_status,
|
||||
.max_buffer_age = 5, // Why?
|
||||
};
|
||||
|
||||
/**
|
||||
* Check if a GLX extension exists.
|
||||
*/
|
||||
static inline bool glx_has_extension(Display *dpy, int screen, const char *ext) {
|
||||
const char *glx_exts = glXQueryExtensionsString(dpy, screen);
|
||||
if (!glx_exts) {
|
||||
log_error("Failed get GLX extension list.");
|
||||
return false;
|
||||
}
|
||||
|
||||
auto inlen = strlen(ext);
|
||||
const char *curr = glx_exts;
|
||||
bool match = false;
|
||||
while (curr && !match) {
|
||||
const char *end = strchr(curr, ' ');
|
||||
if (!end) {
|
||||
// Last extension string
|
||||
match = strcmp(ext, curr) == 0;
|
||||
} else if (curr + inlen == end) {
|
||||
// Length match, do match string
|
||||
match = strncmp(ext, curr, (unsigned long)(end - curr)) == 0;
|
||||
}
|
||||
curr = end ? end + 1 : NULL;
|
||||
}
|
||||
|
||||
if (!match) {
|
||||
log_info("Missing GLX extension %s.", ext);
|
||||
} else {
|
||||
log_info("Found GLX extension %s.", ext);
|
||||
}
|
||||
|
||||
return match;
|
||||
}
|
||||
|
||||
struct glxext_info glxext = {0};
|
||||
PFNGLXGETVIDEOSYNCSGIPROC glXGetVideoSyncSGI;
|
||||
PFNGLXWAITVIDEOSYNCSGIPROC glXWaitVideoSyncSGI;
|
||||
PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML;
|
||||
PFNGLXWAITFORMSCOMLPROC glXWaitForMscOML;
|
||||
PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
|
||||
PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI;
|
||||
PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESA;
|
||||
PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT;
|
||||
PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT;
|
||||
PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB;
|
||||
|
||||
#ifdef GLX_MESA_query_renderer
|
||||
PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glXQueryCurrentRendererIntegerMESA;
|
||||
#endif
|
||||
|
||||
void glxext_init(Display *dpy, int screen) {
|
||||
if (glxext.initialized) {
|
||||
return;
|
||||
}
|
||||
glxext.initialized = true;
|
||||
#define check_ext(name) glxext.has_##name = glx_has_extension(dpy, screen, #name)
|
||||
check_ext(GLX_SGI_video_sync);
|
||||
check_ext(GLX_SGI_swap_control);
|
||||
check_ext(GLX_OML_sync_control);
|
||||
check_ext(GLX_MESA_swap_control);
|
||||
check_ext(GLX_EXT_swap_control);
|
||||
check_ext(GLX_EXT_texture_from_pixmap);
|
||||
check_ext(GLX_ARB_create_context);
|
||||
check_ext(GLX_EXT_buffer_age);
|
||||
check_ext(GLX_ARB_create_context_robustness);
|
||||
#ifdef GLX_MESA_query_renderer
|
||||
check_ext(GLX_MESA_query_renderer);
|
||||
#endif
|
||||
#undef check_ext
|
||||
|
||||
#define lookup(name) (name = (__typeof__(name))glXGetProcAddress((GLubyte *)#name))
|
||||
// Checking if the returned function pointer is NULL is not really necessary,
|
||||
// or maybe not even useful, since glXGetProcAddress might always return
|
||||
// something. We are doing it just for completeness' sake.
|
||||
if (!lookup(glXGetVideoSyncSGI) || !lookup(glXWaitVideoSyncSGI)) {
|
||||
glxext.has_GLX_SGI_video_sync = false;
|
||||
}
|
||||
if (!lookup(glXSwapIntervalEXT)) {
|
||||
glxext.has_GLX_EXT_swap_control = false;
|
||||
}
|
||||
if (!lookup(glXSwapIntervalMESA)) {
|
||||
glxext.has_GLX_MESA_swap_control = false;
|
||||
}
|
||||
if (!lookup(glXSwapIntervalSGI)) {
|
||||
glxext.has_GLX_SGI_swap_control = false;
|
||||
}
|
||||
if (!lookup(glXWaitForMscOML) || !lookup(glXGetSyncValuesOML)) {
|
||||
glxext.has_GLX_OML_sync_control = false;
|
||||
}
|
||||
if (!lookup(glXBindTexImageEXT) || !lookup(glXReleaseTexImageEXT)) {
|
||||
glxext.has_GLX_EXT_texture_from_pixmap = false;
|
||||
}
|
||||
if (!lookup(glXCreateContextAttribsARB)) {
|
||||
glxext.has_GLX_ARB_create_context = false;
|
||||
}
|
||||
#ifdef GLX_MESA_query_renderer
|
||||
if (!lookup(glXQueryCurrentRendererIntegerMESA)) {
|
||||
glxext.has_GLX_MESA_query_renderer = false;
|
||||
}
|
||||
#endif
|
||||
#undef lookup
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
// Older version of glx.h defines function prototypes for these extensions...
|
||||
// Rename them to avoid conflicts
|
||||
#define glXSwapIntervalMESA glXSwapIntervalMESA_
|
||||
#define glXBindTexImageEXT glXBindTexImageEXT_
|
||||
#define glXReleaseTexImageEXT glXReleaseTexImageEXT
|
||||
#include <GL/glx.h>
|
||||
#undef glXSwapIntervalMESA
|
||||
#undef glXBindTexImageEXT
|
||||
#undef glXReleaseTexImageEXT
|
||||
#include <X11/Xlib.h>
|
||||
#include <xcb/xcb.h>
|
||||
#include <xcb/render.h>
|
||||
|
||||
#include "log.h"
|
||||
#include "compiler.h"
|
||||
#include "utils.h"
|
||||
#include "x.h"
|
||||
|
||||
struct glx_fbconfig_info {
|
||||
GLXFBConfig cfg;
|
||||
int texture_tgts;
|
||||
int texture_fmt;
|
||||
int y_inverted;
|
||||
};
|
||||
|
||||
/// The search criteria for glx_find_fbconfig
|
||||
struct glx_fbconfig_criteria {
|
||||
/// Bit width of the red component
|
||||
int red_size;
|
||||
/// Bit width of the green component
|
||||
int green_size;
|
||||
/// Bit width of the blue component
|
||||
int blue_size;
|
||||
/// Bit width of the alpha component
|
||||
int alpha_size;
|
||||
/// The depth of X visual
|
||||
int visual_depth;
|
||||
};
|
||||
|
||||
struct glx_fbconfig_info *glx_find_fbconfig(Display *, int screen, struct xvisual_info);
|
||||
|
||||
|
||||
struct glxext_info {
|
||||
bool initialized;
|
||||
bool has_GLX_SGI_video_sync;
|
||||
bool has_GLX_SGI_swap_control;
|
||||
bool has_GLX_OML_sync_control;
|
||||
bool has_GLX_MESA_swap_control;
|
||||
bool has_GLX_EXT_swap_control;
|
||||
bool has_GLX_EXT_texture_from_pixmap;
|
||||
bool has_GLX_ARB_create_context;
|
||||
bool has_GLX_EXT_buffer_age;
|
||||
bool has_GLX_MESA_query_renderer;
|
||||
bool has_GLX_ARB_create_context_robustness;
|
||||
};
|
||||
|
||||
extern struct glxext_info glxext;
|
||||
|
||||
extern PFNGLXGETVIDEOSYNCSGIPROC glXGetVideoSyncSGI;
|
||||
extern PFNGLXWAITVIDEOSYNCSGIPROC glXWaitVideoSyncSGI;
|
||||
extern PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML;
|
||||
extern PFNGLXWAITFORMSCOMLPROC glXWaitForMscOML;
|
||||
extern PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
|
||||
extern PFNGLXSWAPINTERVALSGIPROC glXSwapIntervalSGI;
|
||||
extern PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESA;
|
||||
extern PFNGLXBINDTEXIMAGEEXTPROC glXBindTexImageEXT;
|
||||
extern PFNGLXRELEASETEXIMAGEEXTPROC glXReleaseTexImageEXT;
|
||||
extern PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB;
|
||||
|
||||
#ifdef GLX_MESA_query_renderer
|
||||
extern PFNGLXQUERYCURRENTRENDERERINTEGERMESAPROC glXQueryCurrentRendererIntegerMESA;
|
||||
#endif
|
||||
|
||||
void glxext_init(Display *, int screen);
|
||||
@@ -0,0 +1,7 @@
|
||||
# enable xrender
|
||||
srcs += [ files('backend_common.c', 'xrender/xrender.c', 'dummy/dummy.c', 'backend.c', 'driver.c') ]
|
||||
|
||||
# enable opengl
|
||||
if get_option('opengl')
|
||||
srcs += [ files('gl/gl_common.c', 'gl/glx.c') ]
|
||||
endif
|
||||
@@ -0,0 +1,889 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <xcb/composite.h>
|
||||
#include <xcb/present.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/sync.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "backend/backend.h"
|
||||
#include "backend/backend_common.h"
|
||||
#include "common.h"
|
||||
#include "config.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "picom.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
typedef struct _xrender_data {
|
||||
backend_t base;
|
||||
/// If vsync is enabled and supported by the current system
|
||||
bool vsync;
|
||||
xcb_visualid_t default_visual;
|
||||
/// Target window
|
||||
xcb_window_t target_win;
|
||||
/// Painting target, it is either the root or the overlay
|
||||
xcb_render_picture_t target;
|
||||
/// Back buffers. Double buffer, with 1 for temporary render use
|
||||
xcb_render_picture_t back[3];
|
||||
/// The back buffer that is for temporary use
|
||||
/// Age of each back buffer.
|
||||
int buffer_age[3];
|
||||
/// The back buffer we should be painting into
|
||||
int curr_back;
|
||||
/// The corresponding pixmap to the back buffer
|
||||
xcb_pixmap_t back_pixmap[3];
|
||||
/// Pictures of pixel of different alpha value, used as a mask to
|
||||
/// paint transparent images
|
||||
xcb_render_picture_t alpha_pict[256];
|
||||
|
||||
// XXX don't know if these are really needed
|
||||
|
||||
/// 1x1 white picture
|
||||
xcb_render_picture_t white_pixel;
|
||||
/// 1x1 black picture
|
||||
xcb_render_picture_t black_pixel;
|
||||
|
||||
/// Width and height of the target pixmap
|
||||
int target_width, target_height;
|
||||
|
||||
xcb_special_event_t *present_event;
|
||||
} xrender_data;
|
||||
|
||||
struct _xrender_blur_context {
|
||||
enum blur_method method;
|
||||
/// Blur kernels converted to X format
|
||||
struct x_convolution_kernel **x_blur_kernel;
|
||||
|
||||
int resize_width, resize_height;
|
||||
|
||||
/// Number of blur kernels
|
||||
int x_blur_kernel_count;
|
||||
};
|
||||
|
||||
struct _xrender_image_data_inner {
|
||||
// struct backend_image_inner_base
|
||||
int refcount;
|
||||
bool has_alpha;
|
||||
|
||||
// Pixmap that the client window draws to,
|
||||
// it will contain the content of client window.
|
||||
xcb_pixmap_t pixmap;
|
||||
// A Picture links to the Pixmap
|
||||
xcb_render_picture_t pict;
|
||||
int width, height;
|
||||
xcb_visualid_t visual;
|
||||
uint8_t depth;
|
||||
// Whether we own this image, e.g. we allocated it;
|
||||
// or not, e.g. this is a named pixmap of a X window.
|
||||
bool owned;
|
||||
};
|
||||
|
||||
struct xrender_rounded_rectangle_cache {
|
||||
int refcount;
|
||||
// A cached picture of a rounded rectangle. Xorg rasterizes shapes on CPU so it's
|
||||
// exceedingly slow.
|
||||
xcb_render_picture_t p;
|
||||
};
|
||||
|
||||
struct xrender_image {
|
||||
struct backend_image base;
|
||||
|
||||
struct xrender_rounded_rectangle_cache *rounded_rectangle;
|
||||
};
|
||||
|
||||
/// Make a picture of size width x height, which has a rounded rectangle of corner_radius
|
||||
/// rendered in it.
|
||||
struct xrender_rounded_rectangle_cache *
|
||||
make_rounded_corner_cache(xcb_connection_t *c, xcb_render_picture_t src,
|
||||
xcb_drawable_t root, int width, int height, int corner_radius) {
|
||||
auto picture = x_create_picture_with_standard(c, root, width, height,
|
||||
XCB_PICT_STANDARD_ARGB_32, 0, NULL);
|
||||
if (picture == XCB_NONE) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int inner_height = height - 2 * corner_radius;
|
||||
int cap_height = corner_radius;
|
||||
if (inner_height < 0) {
|
||||
cap_height = height / 2;
|
||||
inner_height = 0;
|
||||
}
|
||||
auto points = ccalloc(cap_height * 4 + 4, xcb_render_pointfix_t);
|
||||
int point_count = 0;
|
||||
|
||||
#define ADD_POINT(px, py) \
|
||||
assert(point_count < cap_height * 4 + 4); \
|
||||
points[point_count].x = DOUBLE_TO_XFIXED(px); \
|
||||
points[point_count].y = DOUBLE_TO_XFIXED(py); \
|
||||
point_count += 1;
|
||||
|
||||
// The top cap
|
||||
for (int i = 0; i <= cap_height; i++) {
|
||||
double y = corner_radius - i;
|
||||
double delta = sqrt(corner_radius * corner_radius - y * y);
|
||||
double left = corner_radius - delta;
|
||||
double right = width - corner_radius + delta;
|
||||
if (left >= right) {
|
||||
continue;
|
||||
}
|
||||
ADD_POINT(left, i);
|
||||
ADD_POINT(right, i);
|
||||
}
|
||||
|
||||
// The middle rectangle
|
||||
if (inner_height > 0) {
|
||||
ADD_POINT(0, cap_height + inner_height);
|
||||
ADD_POINT(width, cap_height + inner_height);
|
||||
}
|
||||
|
||||
// The bottom cap
|
||||
for (int i = cap_height + inner_height + 1; i <= height; i++) {
|
||||
double y = corner_radius - (height - i);
|
||||
double delta = sqrt(corner_radius * corner_radius - y * y);
|
||||
double left = corner_radius - delta;
|
||||
double right = width - corner_radius + delta;
|
||||
if (left >= right) {
|
||||
break;
|
||||
}
|
||||
ADD_POINT(left, i);
|
||||
ADD_POINT(right, i);
|
||||
}
|
||||
#undef ADD_POINT
|
||||
|
||||
XCB_AWAIT_VOID(xcb_render_tri_strip, c, XCB_RENDER_PICT_OP_SRC, src, picture,
|
||||
x_get_pictfmt_for_standard(c, XCB_PICT_STANDARD_A_8), 0, 0,
|
||||
(uint32_t)point_count, points);
|
||||
free(points);
|
||||
auto ret = ccalloc(1, struct xrender_rounded_rectangle_cache);
|
||||
ret->p = picture;
|
||||
ret->refcount = 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void compose_impl(struct _xrender_data *xd, struct xrender_image *xrimg,
|
||||
int dst_x1, int dst_y1, int dst_x2, int dst_y2,
|
||||
const region_t *reg_paint, const region_t *reg_visible,
|
||||
xcb_render_picture_t result) {
|
||||
const struct backend_image *img = &xrimg->base;
|
||||
auto alpha_pict = xd->alpha_pict[(int)(img->opacity * MAX_ALPHA)];
|
||||
auto inner = (struct _xrender_image_data_inner *)img->inner;
|
||||
region_t reg;
|
||||
|
||||
bool has_alpha = inner->has_alpha || img->opacity != 1;
|
||||
const auto tmpw = to_u16_checked(dst_x2 - dst_x1);
|
||||
const auto tmph = to_u16_checked(dst_y2 - dst_y1);
|
||||
const auto tmpew = to_u16_checked(dst_x2 - dst_x1);
|
||||
const auto tmpeh = to_u16_checked(dst_y2 - dst_y1);
|
||||
const xcb_render_color_t dim_color = {
|
||||
.red = 0, .green = 0, .blue = 0, .alpha = (uint16_t)(0xffff * img->dim)};
|
||||
|
||||
// Clip region of rendered_pict might be set during rendering, clear it to
|
||||
// make sure we get everything into the buffer
|
||||
x_clear_picture_clip_region(xd->base.c, inner->pict);
|
||||
|
||||
pixman_region32_init(®);
|
||||
pixman_region32_intersect(®, (region_t *)reg_paint, (region_t *)reg_visible);
|
||||
x_set_picture_clip_region(xd->base.c, result, 0, 0, ®);
|
||||
#define DOUBLE_TO_XFIXED(value) ((xcb_render_fixed_t)(((double)(value)) * 65536))
|
||||
{
|
||||
const xcb_render_transform_t transform = {
|
||||
DOUBLE_TO_XFIXED((double)img->ewidth / (double)tmpew), DOUBLE_TO_XFIXED(0.0), DOUBLE_TO_XFIXED(0.0),
|
||||
DOUBLE_TO_XFIXED(0.0), DOUBLE_TO_XFIXED((double)img->eheight / (double)tmpeh), DOUBLE_TO_XFIXED(0.0),
|
||||
DOUBLE_TO_XFIXED(0.0), DOUBLE_TO_XFIXED(0.0), DOUBLE_TO_XFIXED(1.0),
|
||||
};
|
||||
xcb_render_set_picture_transform(xd->base.c, inner->pict, transform);
|
||||
xcb_render_set_picture_filter(xd->base.c, inner->pict, 7, "nearest", 0, NULL);
|
||||
}
|
||||
#undef DOUBLE_TO_XFIXED
|
||||
|
||||
if (img->corner_radius != 0 && xrimg->rounded_rectangle == NULL) {
|
||||
xrimg->rounded_rectangle = make_rounded_corner_cache(
|
||||
xd->base.c, xd->white_pixel, xd->base.root, inner->width,
|
||||
inner->height, (int)img->corner_radius);
|
||||
}
|
||||
if (((img->color_inverted || img->dim != 0) && has_alpha) || img->corner_radius != 0) {
|
||||
// Apply image properties using a temporary image, because the source
|
||||
// image is transparent. Otherwise the properties can be applied directly
|
||||
// on the target image.
|
||||
auto tmp_pict =
|
||||
x_create_picture_with_visual(xd->base.c, xd->base.root, inner->width,
|
||||
inner->height, inner->visual, 0, NULL);
|
||||
|
||||
// Set clip region translated to source coordinate
|
||||
x_set_picture_clip_region(xd->base.c, tmp_pict, to_i16_checked(-dst_x1),
|
||||
to_i16_checked(-dst_y1), ®);
|
||||
// Copy source -> tmp
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_OVER, inner->pict,
|
||||
XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph);
|
||||
if (img->color_inverted) {
|
||||
if (inner->has_alpha) {
|
||||
auto tmp_pict2 = x_create_picture_with_visual(
|
||||
xd->base.c, xd->base.root, tmpw, tmph, inner->visual,
|
||||
0, NULL);
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_OVER,
|
||||
tmp_pict, XCB_NONE, tmp_pict2, 0, 0,
|
||||
0, 0, 0, 0, tmpw, tmph);
|
||||
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE,
|
||||
xd->white_pixel, XCB_NONE, tmp_pict,
|
||||
0, 0, 0, 0, 0, 0, tmpw, tmph);
|
||||
xcb_render_composite(
|
||||
xd->base.c, XCB_RENDER_PICT_OP_IN_REVERSE, tmp_pict2,
|
||||
XCB_NONE, tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph);
|
||||
xcb_render_free_picture(xd->base.c, tmp_pict2);
|
||||
} else {
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE,
|
||||
xd->white_pixel, XCB_NONE, tmp_pict,
|
||||
0, 0, 0, 0, 0, 0, tmpw, tmph);
|
||||
}
|
||||
}
|
||||
if (img->dim != 0) {
|
||||
// Dim the actually content of window
|
||||
xcb_rectangle_t rect = {
|
||||
.x = 0,
|
||||
.y = 0,
|
||||
.width = tmpw,
|
||||
.height = tmph,
|
||||
};
|
||||
|
||||
xcb_render_fill_rectangles(xd->base.c, XCB_RENDER_PICT_OP_OVER,
|
||||
tmp_pict, dim_color, 1, &rect);
|
||||
}
|
||||
|
||||
if (img->corner_radius != 0 && xrimg->rounded_rectangle != NULL) {
|
||||
// Clip tmp_pict with a rounded rectangle
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_IN_REVERSE,
|
||||
xrimg->rounded_rectangle->p, XCB_NONE,
|
||||
tmp_pict, 0, 0, 0, 0, 0, 0, tmpw, tmph);
|
||||
}
|
||||
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_OVER, tmp_pict,
|
||||
alpha_pict, result, 0, 0, 0, 0, to_i16_checked(dst_x1),
|
||||
to_i16_checked(dst_y1), tmpew, tmpeh);
|
||||
xcb_render_free_picture(xd->base.c, tmp_pict);
|
||||
} else {
|
||||
uint8_t op = (has_alpha ? XCB_RENDER_PICT_OP_OVER : XCB_RENDER_PICT_OP_SRC);
|
||||
|
||||
xcb_render_composite(xd->base.c, op, inner->pict, alpha_pict, result, 0,
|
||||
0, 0, 0, to_i16_checked(dst_x1),
|
||||
to_i16_checked(dst_y1), tmpew, tmpeh);
|
||||
if (img->dim != 0 || img->color_inverted) {
|
||||
// Apply properties, if we reach here, then has_alpha == false
|
||||
assert(!has_alpha);
|
||||
if (img->color_inverted) {
|
||||
xcb_render_composite(xd->base.c, XCB_RENDER_PICT_OP_DIFFERENCE,
|
||||
xd->white_pixel, XCB_NONE, result, 0,
|
||||
0, 0, 0, to_i16_checked(dst_x1),
|
||||
to_i16_checked(dst_y1), tmpew, tmpeh);
|
||||
}
|
||||
|
||||
if (img->dim != 0) {
|
||||
// Dim the actually content of window
|
||||
xcb_rectangle_t rect = {
|
||||
.x = to_i16_checked(dst_x1),
|
||||
.y = to_i16_checked(dst_y1),
|
||||
.width = tmpew,
|
||||
.height = tmpeh,
|
||||
};
|
||||
|
||||
xcb_render_fill_rectangles(xd->base.c, XCB_RENDER_PICT_OP_OVER,
|
||||
result, dim_color, 1, &rect);
|
||||
}
|
||||
}
|
||||
}
|
||||
pixman_region32_fini(®);
|
||||
}
|
||||
|
||||
static void compose(backend_t *base, void *img_data,
|
||||
int dst_x1, int dst_y1, int dst_x2, int dst_y2,
|
||||
const region_t *reg_paint, const region_t *reg_visible) {
|
||||
// TODO(dccsillag): use dst_{x,y}2
|
||||
struct _xrender_data *xd = (void *)base;
|
||||
return compose_impl(xd, img_data, dst_x1, dst_y1, dst_x2, dst_y2, reg_paint, reg_visible, xd->back[2]);
|
||||
}
|
||||
|
||||
static void fill(backend_t *base, struct color c, const region_t *clip) {
|
||||
struct _xrender_data *xd = (void *)base;
|
||||
const rect_t *extent = pixman_region32_extents((region_t *)clip);
|
||||
x_set_picture_clip_region(base->c, xd->back[2], 0, 0, clip);
|
||||
// color is in X fixed point representation
|
||||
xcb_render_fill_rectangles(
|
||||
base->c, XCB_RENDER_PICT_OP_OVER, xd->back[2],
|
||||
(xcb_render_color_t){.red = (uint16_t)(c.red * 0xffff),
|
||||
.green = (uint16_t)(c.green * 0xffff),
|
||||
.blue = (uint16_t)(c.blue * 0xffff),
|
||||
.alpha = (uint16_t)(c.alpha * 0xffff)},
|
||||
1,
|
||||
(xcb_rectangle_t[]){{.x = to_i16_checked(extent->x1),
|
||||
.y = to_i16_checked(extent->y1),
|
||||
.width = to_u16_checked(extent->x2 - extent->x1),
|
||||
.height = to_u16_checked(extent->y2 - extent->y1)}});
|
||||
}
|
||||
|
||||
static bool blur(backend_t *backend_data, double opacity, void *ctx_,
|
||||
const region_t *reg_blur, const region_t *reg_visible) {
|
||||
struct _xrender_blur_context *bctx = ctx_;
|
||||
if (bctx->method == BLUR_METHOD_NONE) {
|
||||
return true;
|
||||
}
|
||||
|
||||
struct _xrender_data *xd = (void *)backend_data;
|
||||
xcb_connection_t *c = xd->base.c;
|
||||
region_t reg_op;
|
||||
pixman_region32_init(®_op);
|
||||
pixman_region32_intersect(®_op, (region_t *)reg_blur, (region_t *)reg_visible);
|
||||
if (!pixman_region32_not_empty(®_op)) {
|
||||
pixman_region32_fini(®_op);
|
||||
return true;
|
||||
}
|
||||
|
||||
region_t reg_op_resized =
|
||||
resize_region(®_op, bctx->resize_width, bctx->resize_height);
|
||||
|
||||
const pixman_box32_t *extent_resized = pixman_region32_extents(®_op_resized);
|
||||
const auto height_resized = to_u16_checked(extent_resized->y2 - extent_resized->y1);
|
||||
const auto width_resized = to_u16_checked(extent_resized->x2 - extent_resized->x1);
|
||||
static const char *filter0 = "Nearest"; // The "null" filter
|
||||
static const char *filter = "convolution";
|
||||
|
||||
// Create a buffer for storing blurred picture, make it just big enough
|
||||
// for the blur region
|
||||
const uint32_t pic_attrs_mask = XCB_RENDER_CP_REPEAT;
|
||||
const xcb_render_create_picture_value_list_t pic_attrs = {.repeat = XCB_RENDER_REPEAT_PAD};
|
||||
xcb_render_picture_t tmp_picture[2] = {
|
||||
x_create_picture_with_visual(xd->base.c, xd->base.root, width_resized, height_resized,
|
||||
xd->default_visual, pic_attrs_mask, &pic_attrs),
|
||||
x_create_picture_with_visual(xd->base.c, xd->base.root, width_resized, height_resized,
|
||||
xd->default_visual, pic_attrs_mask, &pic_attrs)};
|
||||
|
||||
if (!tmp_picture[0] || !tmp_picture[1]) {
|
||||
log_error("Failed to build intermediate Picture.");
|
||||
pixman_region32_fini(®_op);
|
||||
pixman_region32_fini(®_op_resized);
|
||||
return false;
|
||||
}
|
||||
|
||||
region_t clip;
|
||||
pixman_region32_init(&clip);
|
||||
pixman_region32_copy(&clip, ®_op_resized);
|
||||
pixman_region32_translate(&clip, -extent_resized->x1, -extent_resized->y1);
|
||||
x_set_picture_clip_region(c, tmp_picture[0], 0, 0, &clip);
|
||||
x_set_picture_clip_region(c, tmp_picture[1], 0, 0, &clip);
|
||||
pixman_region32_fini(&clip);
|
||||
|
||||
xcb_render_picture_t src_pict = xd->back[2], dst_pict = tmp_picture[0];
|
||||
auto alpha_pict = xd->alpha_pict[(int)(opacity * MAX_ALPHA)];
|
||||
int current = 0;
|
||||
x_set_picture_clip_region(c, src_pict, 0, 0, ®_op_resized);
|
||||
|
||||
// For more than 1 pass, we do:
|
||||
// back -(pass 1)-> tmp0 -(pass 2)-> tmp1 ...
|
||||
// -(pass n-1)-> tmp0 or tmp1 -(pass n)-> back
|
||||
// For 1 pass, we do
|
||||
// back -(pass 1)-> tmp0 -(copy)-> target_buffer
|
||||
int i;
|
||||
for (i = 0; i < bctx->x_blur_kernel_count; i++) {
|
||||
// Copy from source picture to destination. The filter must
|
||||
// be applied on source picture, to get the nearby pixels outside the
|
||||
// window.
|
||||
xcb_render_set_picture_filter(c, src_pict, to_u16_checked(strlen(filter)),
|
||||
filter,
|
||||
to_u32_checked(bctx->x_blur_kernel[i]->size),
|
||||
bctx->x_blur_kernel[i]->kernel);
|
||||
|
||||
if (i == 0) {
|
||||
// First pass, back buffer -> tmp picture
|
||||
// (we do this even if this is also the last pass, because we
|
||||
// cannot do back buffer -> back buffer)
|
||||
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, src_pict, XCB_NONE,
|
||||
dst_pict, to_i16_checked(extent_resized->x1),
|
||||
to_i16_checked(extent_resized->y1), 0, 0, 0,
|
||||
0, width_resized, height_resized);
|
||||
} else if (i < bctx->x_blur_kernel_count - 1) {
|
||||
// This is not the last pass or the first pass,
|
||||
// tmp picture 1 -> tmp picture 2
|
||||
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, src_pict,
|
||||
XCB_NONE, dst_pict, 0, 0, 0, 0, 0, 0,
|
||||
width_resized, height_resized);
|
||||
} else {
|
||||
x_set_picture_clip_region(c, xd->back[2], 0, 0, ®_op);
|
||||
// This is the last pass, and we are doing more than 1 pass
|
||||
xcb_render_composite(c, XCB_RENDER_PICT_OP_OVER, src_pict,
|
||||
alpha_pict, xd->back[2], 0, 0, 0, 0,
|
||||
to_i16_checked(extent_resized->x1),
|
||||
to_i16_checked(extent_resized->y1),
|
||||
width_resized, height_resized);
|
||||
}
|
||||
|
||||
// reset filter
|
||||
xcb_render_set_picture_filter(
|
||||
c, src_pict, to_u16_checked(strlen(filter0)), filter0, 0, NULL);
|
||||
|
||||
src_pict = tmp_picture[current];
|
||||
dst_pict = tmp_picture[!current];
|
||||
current = !current;
|
||||
}
|
||||
|
||||
// There is only 1 pass
|
||||
if (i == 1) {
|
||||
x_set_picture_clip_region(c, xd->back[2], 0, 0, ®_op);
|
||||
xcb_render_composite(
|
||||
c, XCB_RENDER_PICT_OP_OVER, src_pict, alpha_pict, xd->back[2], 0, 0,
|
||||
0, 0, to_i16_checked(extent_resized->x1),
|
||||
to_i16_checked(extent_resized->y1), width_resized, height_resized);
|
||||
}
|
||||
|
||||
xcb_render_free_picture(c, tmp_picture[0]);
|
||||
xcb_render_free_picture(c, tmp_picture[1]);
|
||||
pixman_region32_fini(®_op);
|
||||
pixman_region32_fini(®_op_resized);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void *
|
||||
bind_pixmap(backend_t *base, xcb_pixmap_t pixmap, struct xvisual_info fmt, bool owned) {
|
||||
xcb_generic_error_t *e;
|
||||
auto r = xcb_get_geometry_reply(base->c, xcb_get_geometry(base->c, pixmap), &e);
|
||||
if (!r) {
|
||||
log_error("Invalid pixmap: %#010x", pixmap);
|
||||
x_print_error(e->full_sequence, e->major_code, e->minor_code, e->error_code);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
auto img = ccalloc(1, struct xrender_image);
|
||||
auto inner = ccalloc(1, struct _xrender_image_data_inner);
|
||||
inner->depth = (uint8_t)fmt.visual_depth;
|
||||
inner->width = img->base.ewidth = r->width;
|
||||
inner->height = img->base.eheight = r->height;
|
||||
inner->pixmap = pixmap;
|
||||
inner->has_alpha = fmt.alpha_size != 0;
|
||||
inner->pict =
|
||||
x_create_picture_with_visual_and_pixmap(base->c, fmt.visual, pixmap, 0, NULL);
|
||||
inner->owned = owned;
|
||||
inner->visual = fmt.visual;
|
||||
inner->refcount = 1;
|
||||
|
||||
img->base.inner = (struct backend_image_inner_base *)inner;
|
||||
img->base.opacity = 1;
|
||||
img->rounded_rectangle = NULL;
|
||||
free(r);
|
||||
|
||||
if (inner->pict == XCB_NONE) {
|
||||
free(inner);
|
||||
free(img);
|
||||
return NULL;
|
||||
}
|
||||
return img;
|
||||
}
|
||||
static void release_image_inner(backend_t *base, struct _xrender_image_data_inner *inner) {
|
||||
xcb_render_free_picture(base->c, inner->pict);
|
||||
if (inner->owned) {
|
||||
xcb_free_pixmap(base->c, inner->pixmap);
|
||||
}
|
||||
free(inner);
|
||||
}
|
||||
|
||||
static void
|
||||
release_rounded_corner_cache(backend_t *base, struct xrender_rounded_rectangle_cache *cache) {
|
||||
if (!cache) {
|
||||
return;
|
||||
}
|
||||
|
||||
assert(cache->refcount > 0);
|
||||
cache->refcount--;
|
||||
if (cache->refcount == 0) {
|
||||
xcb_free_pixmap(base->c, cache->p);
|
||||
free(cache);
|
||||
}
|
||||
}
|
||||
|
||||
static void release_image(backend_t *base, void *image) {
|
||||
struct xrender_image *img = image;
|
||||
release_rounded_corner_cache(base, img->rounded_rectangle);
|
||||
img->rounded_rectangle = NULL;
|
||||
img->base.inner->refcount -= 1;
|
||||
if (img->base.inner->refcount == 0) {
|
||||
release_image_inner(base, (void *)img->base.inner);
|
||||
}
|
||||
free(img);
|
||||
}
|
||||
|
||||
static void deinit(backend_t *backend_data) {
|
||||
struct _xrender_data *xd = (void *)backend_data;
|
||||
for (int i = 0; i < 256; i++) {
|
||||
xcb_render_free_picture(xd->base.c, xd->alpha_pict[i]);
|
||||
}
|
||||
xcb_render_free_picture(xd->base.c, xd->target);
|
||||
for (int i = 0; i < 2; i++) {
|
||||
xcb_render_free_picture(xd->base.c, xd->back[i]);
|
||||
xcb_free_pixmap(xd->base.c, xd->back_pixmap[i]);
|
||||
}
|
||||
if (xd->present_event) {
|
||||
xcb_unregister_for_special_event(xd->base.c, xd->present_event);
|
||||
}
|
||||
xcb_render_free_picture(xd->base.c, xd->white_pixel);
|
||||
xcb_render_free_picture(xd->base.c, xd->black_pixel);
|
||||
free(xd);
|
||||
}
|
||||
|
||||
static void present(backend_t *base, const region_t *region) {
|
||||
struct _xrender_data *xd = (void *)base;
|
||||
const rect_t *extent = pixman_region32_extents((region_t *)region);
|
||||
int16_t orig_x = to_i16_checked(extent->x1), orig_y = to_i16_checked(extent->y1);
|
||||
uint16_t region_width = to_u16_checked(extent->x2 - extent->x1),
|
||||
region_height = to_u16_checked(extent->y2 - extent->y1);
|
||||
|
||||
// compose() sets clip region on the back buffer, so clear it first
|
||||
x_clear_picture_clip_region(base->c, xd->back[xd->curr_back]);
|
||||
|
||||
// limit the region of update
|
||||
x_set_picture_clip_region(base->c, xd->back[2], 0, 0, region);
|
||||
|
||||
if (xd->vsync) {
|
||||
// Update the back buffer first, then present
|
||||
xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, xd->back[2],
|
||||
XCB_NONE, xd->back[xd->curr_back], orig_x, orig_y, 0,
|
||||
0, orig_x, orig_y, region_width, region_height);
|
||||
|
||||
// Make sure we got reply from PresentPixmap before waiting for events,
|
||||
// to avoid deadlock
|
||||
auto e = xcb_request_check(
|
||||
base->c, xcb_present_pixmap_checked(
|
||||
xd->base.c, xd->target_win,
|
||||
xd->back_pixmap[xd->curr_back], 0, XCB_NONE, XCB_NONE, 0,
|
||||
0, XCB_NONE, XCB_NONE, XCB_NONE, 0, 0, 0, 0, 0, NULL));
|
||||
if (e) {
|
||||
log_error("Failed to present pixmap");
|
||||
free(e);
|
||||
return;
|
||||
}
|
||||
// TODO(yshui) don't block wait for present completion
|
||||
xcb_present_generic_event_t *pev =
|
||||
(void *)xcb_wait_for_special_event(base->c, xd->present_event);
|
||||
if (!pev) {
|
||||
// We don't know what happened, maybe X died
|
||||
// But reset buffer age, so in case we do recover, we will
|
||||
// render correctly.
|
||||
xd->buffer_age[0] = xd->buffer_age[1] = -1;
|
||||
return;
|
||||
}
|
||||
assert(pev->evtype == XCB_PRESENT_COMPLETE_NOTIFY);
|
||||
xcb_present_complete_notify_event_t *pcev = (void *)pev;
|
||||
// log_trace("Present complete: %d %ld", pcev->mode, pcev->msc);
|
||||
xd->buffer_age[xd->curr_back] = 1;
|
||||
|
||||
// buffer_age < 0 means that back buffer is empty
|
||||
if (xd->buffer_age[1 - xd->curr_back] > 0) {
|
||||
xd->buffer_age[1 - xd->curr_back]++;
|
||||
}
|
||||
if (pcev->mode == XCB_PRESENT_COMPLETE_MODE_FLIP) {
|
||||
// We cannot use the pixmap we used anymore
|
||||
xd->curr_back = 1 - xd->curr_back;
|
||||
}
|
||||
free(pev);
|
||||
} else {
|
||||
// No vsync needed, draw into the target picture directly
|
||||
xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, xd->back[2],
|
||||
XCB_NONE, xd->target, orig_x, orig_y, 0, 0, orig_x,
|
||||
orig_y, region_width, region_height);
|
||||
}
|
||||
}
|
||||
|
||||
static int buffer_age(backend_t *backend_data) {
|
||||
struct _xrender_data *xd = (void *)backend_data;
|
||||
if (!xd->vsync) {
|
||||
// Only the target picture really holds the screen content, and its
|
||||
// content is always up to date. So buffer age is always 1.
|
||||
return 1;
|
||||
}
|
||||
return xd->buffer_age[xd->curr_back];
|
||||
}
|
||||
|
||||
static struct _xrender_image_data_inner *
|
||||
new_inner(backend_t *base, int w, int h, xcb_visualid_t visual, uint8_t depth) {
|
||||
auto new_inner = ccalloc(1, struct _xrender_image_data_inner);
|
||||
new_inner->pixmap = x_create_pixmap(base->c, depth, base->root, w, h);
|
||||
if (new_inner->pixmap == XCB_NONE) {
|
||||
log_error("Failed to create pixmap for copy");
|
||||
free(new_inner);
|
||||
return NULL;
|
||||
}
|
||||
new_inner->pict = x_create_picture_with_visual_and_pixmap(
|
||||
base->c, visual, new_inner->pixmap, 0, NULL);
|
||||
if (new_inner->pict == XCB_NONE) {
|
||||
log_error("Failed to create picture for copy");
|
||||
xcb_free_pixmap(base->c, new_inner->pixmap);
|
||||
free(new_inner);
|
||||
return NULL;
|
||||
}
|
||||
new_inner->width = w;
|
||||
new_inner->height = h;
|
||||
new_inner->visual = visual;
|
||||
new_inner->depth = depth;
|
||||
new_inner->refcount = 1;
|
||||
new_inner->owned = true;
|
||||
return new_inner;
|
||||
}
|
||||
|
||||
static bool decouple_image(backend_t *base, struct backend_image *img, const region_t *reg) {
|
||||
if (img->inner->refcount == 1) {
|
||||
return true;
|
||||
}
|
||||
auto inner = (struct _xrender_image_data_inner *)img->inner;
|
||||
// Force new pixmap to a 32-bit ARGB visual to allow for transparent frames around
|
||||
// non-transparent windows
|
||||
auto visual = (inner->depth == 32)
|
||||
? inner->visual
|
||||
: x_get_visual_for_standard(base->c, XCB_PICT_STANDARD_ARGB_32);
|
||||
auto inner2 = new_inner(base, inner->width, inner->height, visual, 32);
|
||||
if (!inner2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
x_set_picture_clip_region(base->c, inner->pict, 0, 0, reg);
|
||||
xcb_render_composite(base->c, XCB_RENDER_PICT_OP_SRC, inner->pict, XCB_NONE,
|
||||
inner2->pict, 0, 0, 0, 0, 0, 0, to_u16_checked(inner->width),
|
||||
to_u16_checked(inner->height));
|
||||
|
||||
img->inner = (struct backend_image_inner_base *)inner2;
|
||||
inner->refcount--;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool image_op(backend_t *base, enum image_operations op, void *image,
|
||||
const region_t *reg_op, const region_t *reg_visible, void *arg) {
|
||||
struct _xrender_data *xd = (void *)base;
|
||||
struct backend_image *img = image;
|
||||
region_t reg;
|
||||
double *dargs = arg;
|
||||
|
||||
pixman_region32_init(®);
|
||||
pixman_region32_intersect(®, (region_t *)reg_op, (region_t *)reg_visible);
|
||||
|
||||
switch (op) {
|
||||
case IMAGE_OP_APPLY_ALPHA:
|
||||
assert(reg_op);
|
||||
|
||||
if (!pixman_region32_not_empty(®)) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (dargs[0] == 1) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (!decouple_image(base, img, reg_visible)) {
|
||||
pixman_region32_fini(®);
|
||||
return false;
|
||||
}
|
||||
|
||||
auto inner = (struct _xrender_image_data_inner *)img->inner;
|
||||
auto alpha_pict = xd->alpha_pict[(int)((1 - dargs[0]) * MAX_ALPHA)];
|
||||
x_set_picture_clip_region(base->c, inner->pict, 0, 0, ®);
|
||||
xcb_render_composite(base->c, XCB_RENDER_PICT_OP_OUT_REVERSE, alpha_pict,
|
||||
XCB_NONE, inner->pict, 0, 0, 0, 0, 0, 0,
|
||||
to_u16_checked(inner->width),
|
||||
to_u16_checked(inner->height));
|
||||
inner->has_alpha = true;
|
||||
break;
|
||||
}
|
||||
pixman_region32_fini(®);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void *
|
||||
create_blur_context(backend_t *base attr_unused, enum blur_method method, void *args) {
|
||||
auto ret = ccalloc(1, struct _xrender_blur_context);
|
||||
if (!method || method >= BLUR_METHOD_INVALID) {
|
||||
ret->method = BLUR_METHOD_NONE;
|
||||
return ret;
|
||||
}
|
||||
if (method == BLUR_METHOD_DUAL_KAWASE) {
|
||||
log_warn("Blur method 'dual_kawase' is not compatible with the 'xrender' "
|
||||
"backend.");
|
||||
ret->method = BLUR_METHOD_NONE;
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret->method = BLUR_METHOD_KERNEL;
|
||||
struct conv **kernels;
|
||||
int kernel_count;
|
||||
if (method == BLUR_METHOD_KERNEL) {
|
||||
kernels = ((struct kernel_blur_args *)args)->kernels;
|
||||
kernel_count = ((struct kernel_blur_args *)args)->kernel_count;
|
||||
} else {
|
||||
kernels = generate_blur_kernel(method, args, &kernel_count);
|
||||
}
|
||||
|
||||
ret->x_blur_kernel = ccalloc(kernel_count, struct x_convolution_kernel *);
|
||||
for (int i = 0; i < kernel_count; i++) {
|
||||
int center = kernels[i]->h * kernels[i]->w / 2;
|
||||
x_create_convolution_kernel(kernels[i], kernels[i]->data[center],
|
||||
&ret->x_blur_kernel[i]);
|
||||
ret->resize_width += kernels[i]->w / 2;
|
||||
ret->resize_height += kernels[i]->h / 2;
|
||||
}
|
||||
ret->x_blur_kernel_count = kernel_count;
|
||||
|
||||
if (method != BLUR_METHOD_KERNEL) {
|
||||
// Kernels generated by generate_blur_kernel, so we need to free them.
|
||||
for (int i = 0; i < kernel_count; i++) {
|
||||
free(kernels[i]);
|
||||
}
|
||||
free(kernels);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void destroy_blur_context(backend_t *base attr_unused, void *ctx_) {
|
||||
struct _xrender_blur_context *ctx = ctx_;
|
||||
for (int i = 0; i < ctx->x_blur_kernel_count; i++) {
|
||||
free(ctx->x_blur_kernel[i]);
|
||||
}
|
||||
free(ctx->x_blur_kernel);
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
static void get_blur_size(void *blur_context, int *width, int *height) {
|
||||
struct _xrender_blur_context *ctx = blur_context;
|
||||
*width = ctx->resize_width;
|
||||
*height = ctx->resize_height;
|
||||
}
|
||||
|
||||
static backend_t *backend_xrender_init(session_t *ps) {
|
||||
auto xd = ccalloc(1, struct _xrender_data);
|
||||
init_backend_base(&xd->base, ps);
|
||||
|
||||
for (int i = 0; i <= MAX_ALPHA; ++i) {
|
||||
double o = (double)i / (double)MAX_ALPHA;
|
||||
xd->alpha_pict[i] = solid_picture(ps->c, ps->root, false, o, 0, 0, 0);
|
||||
assert(xd->alpha_pict[i] != XCB_NONE);
|
||||
}
|
||||
|
||||
xd->target_width = ps->root_width;
|
||||
xd->target_height = ps->root_height;
|
||||
xd->default_visual = ps->vis;
|
||||
xd->black_pixel = solid_picture(ps->c, ps->root, true, 1, 0, 0, 0);
|
||||
xd->white_pixel = solid_picture(ps->c, ps->root, true, 1, 1, 1, 1);
|
||||
|
||||
xd->target_win = session_get_target_window(ps);
|
||||
xcb_render_create_picture_value_list_t pa = {
|
||||
.subwindowmode = XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS,
|
||||
};
|
||||
xd->target = x_create_picture_with_visual_and_pixmap(
|
||||
ps->c, ps->vis, xd->target_win, XCB_RENDER_CP_SUBWINDOW_MODE, &pa);
|
||||
|
||||
auto pictfmt = x_get_pictform_for_visual(ps->c, ps->vis);
|
||||
if (!pictfmt) {
|
||||
log_fatal("Default visual is invalid");
|
||||
abort();
|
||||
}
|
||||
|
||||
xd->vsync = ps->o.vsync;
|
||||
if (ps->present_exists) {
|
||||
auto eid = x_new_id(ps->c);
|
||||
auto e =
|
||||
xcb_request_check(ps->c, xcb_present_select_input_checked(
|
||||
ps->c, eid, xd->target_win,
|
||||
XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY));
|
||||
if (e) {
|
||||
log_error("Cannot select present input, vsync will be disabled");
|
||||
xd->vsync = false;
|
||||
free(e);
|
||||
}
|
||||
|
||||
xd->present_event =
|
||||
xcb_register_for_special_xge(ps->c, &xcb_present_id, eid, NULL);
|
||||
if (!xd->present_event) {
|
||||
log_error("Cannot register for special XGE, vsync will be "
|
||||
"disabled");
|
||||
xd->vsync = false;
|
||||
}
|
||||
} else {
|
||||
xd->vsync = false;
|
||||
}
|
||||
|
||||
// We might need to do double buffering for vsync, and buffer 0 and 1 are for
|
||||
// double buffering.
|
||||
int first_buffer_index = xd->vsync ? 0 : 2;
|
||||
for (int i = first_buffer_index; i < 3; i++) {
|
||||
xd->back_pixmap[i] = x_create_pixmap(ps->c, pictfmt->depth, ps->root,
|
||||
to_u16_checked(ps->root_width),
|
||||
to_u16_checked(ps->root_height));
|
||||
const uint32_t pic_attrs_mask = XCB_RENDER_CP_REPEAT;
|
||||
const xcb_render_create_picture_value_list_t pic_attrs = {
|
||||
.repeat = XCB_RENDER_REPEAT_PAD};
|
||||
xd->back[i] = x_create_picture_with_pictfmt_and_pixmap(
|
||||
ps->c, pictfmt, xd->back_pixmap[i], pic_attrs_mask, &pic_attrs);
|
||||
xd->buffer_age[i] = -1;
|
||||
if (xd->back_pixmap[i] == XCB_NONE || xd->back[i] == XCB_NONE) {
|
||||
log_error("Cannot create pixmap for rendering");
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
xd->curr_back = 0;
|
||||
|
||||
return &xd->base;
|
||||
err:
|
||||
deinit(&xd->base);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *clone_image(backend_t *base attr_unused, const void *image_data,
|
||||
const region_t *reg_visible attr_unused) {
|
||||
auto new_img = ccalloc(1, struct xrender_image);
|
||||
*new_img = *(struct xrender_image *)image_data;
|
||||
new_img->base.inner->refcount++;
|
||||
if (new_img->rounded_rectangle) {
|
||||
new_img->rounded_rectangle->refcount++;
|
||||
}
|
||||
return new_img;
|
||||
}
|
||||
|
||||
static bool
|
||||
set_image_property(backend_t *base, enum image_properties op, void *image, void *args) {
|
||||
auto xrimg = (struct xrender_image *)image;
|
||||
if (op == IMAGE_PROPERTY_CORNER_RADIUS &&
|
||||
((double *)args)[0] != xrimg->base.corner_radius) {
|
||||
// Free cached rounded rectangle if corner radius changed
|
||||
release_rounded_corner_cache(base, xrimg->rounded_rectangle);
|
||||
xrimg->rounded_rectangle = NULL;
|
||||
}
|
||||
return default_set_image_property(base, op, image, args);
|
||||
}
|
||||
|
||||
struct backend_operations xrender_ops = {
|
||||
.init = backend_xrender_init,
|
||||
.deinit = deinit,
|
||||
.blur = blur,
|
||||
.present = present,
|
||||
.compose = compose,
|
||||
.fill = fill,
|
||||
.bind_pixmap = bind_pixmap,
|
||||
.release_image = release_image,
|
||||
.render_shadow = default_backend_render_shadow,
|
||||
//.prepare_win = prepare_win,
|
||||
//.release_win = release_win,
|
||||
.is_image_transparent = default_is_image_transparent,
|
||||
.buffer_age = buffer_age,
|
||||
.max_buffer_age = 2,
|
||||
|
||||
.image_op = image_op,
|
||||
.clone_image = clone_image,
|
||||
.set_image_property = set_image_property,
|
||||
.create_blur_context = create_blur_context,
|
||||
.destroy_blur_context = destroy_blur_context,
|
||||
.get_blur_size = get_blur_size,
|
||||
};
|
||||
|
||||
// vim: set noet sw=8 ts=8:
|
||||
+1674
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,26 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Compton - a compositor for X11
|
||||
*
|
||||
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
|
||||
*
|
||||
* Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
* See LICENSE-mit for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct _c2_lptr c2_lptr_t;
|
||||
typedef struct session session_t;
|
||||
struct managed_win;
|
||||
|
||||
c2_lptr_t *c2_parse(c2_lptr_t **pcondlst, const char *pattern, void *data);
|
||||
|
||||
c2_lptr_t *c2_free_lptr(c2_lptr_t *lp);
|
||||
|
||||
bool c2_match(session_t *ps, const struct managed_win *w, const c2_lptr_t *condlst, void **pdata);
|
||||
|
||||
bool c2_list_postprocess(session_t *ps, c2_lptr_t *list);
|
||||
@@ -0,0 +1,95 @@
|
||||
#include <uthash.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "utils.h"
|
||||
#include "cache.h"
|
||||
|
||||
struct cache_entry {
|
||||
char *key;
|
||||
void *value;
|
||||
UT_hash_handle hh;
|
||||
};
|
||||
|
||||
struct cache {
|
||||
cache_getter_t getter;
|
||||
cache_free_t free;
|
||||
void *user_data;
|
||||
struct cache_entry *entries;
|
||||
};
|
||||
|
||||
void cache_set(struct cache *c, const char *key, void *data) {
|
||||
struct cache_entry *e = NULL;
|
||||
HASH_FIND_STR(c->entries, key, e);
|
||||
CHECK(!e);
|
||||
|
||||
e = ccalloc(1, struct cache_entry);
|
||||
e->key = strdup(key);
|
||||
e->value = data;
|
||||
HASH_ADD_STR(c->entries, key, e);
|
||||
}
|
||||
|
||||
void *cache_get(struct cache *c, const char *key, int *err) {
|
||||
struct cache_entry *e;
|
||||
HASH_FIND_STR(c->entries, key, e);
|
||||
if (e) {
|
||||
return e->value;
|
||||
}
|
||||
|
||||
int tmperr;
|
||||
if (!err) {
|
||||
err = &tmperr;
|
||||
}
|
||||
|
||||
*err = 0;
|
||||
e = ccalloc(1, struct cache_entry);
|
||||
e->key = strdup(key);
|
||||
e->value = c->getter(c->user_data, key, err);
|
||||
if (*err) {
|
||||
free(e->key);
|
||||
free(e);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
HASH_ADD_STR(c->entries, key, e);
|
||||
return e->value;
|
||||
}
|
||||
|
||||
static inline void _cache_invalidate(struct cache *c, struct cache_entry *e) {
|
||||
if (c->free) {
|
||||
c->free(c->user_data, e->value);
|
||||
}
|
||||
free(e->key);
|
||||
HASH_DEL(c->entries, e);
|
||||
free(e);
|
||||
}
|
||||
|
||||
void cache_invalidate(struct cache *c, const char *key) {
|
||||
struct cache_entry *e;
|
||||
HASH_FIND_STR(c->entries, key, e);
|
||||
|
||||
if (e) {
|
||||
_cache_invalidate(c, e);
|
||||
}
|
||||
}
|
||||
|
||||
void cache_invalidate_all(struct cache *c) {
|
||||
struct cache_entry *e, *tmpe;
|
||||
HASH_ITER(hh, c->entries, e, tmpe) {
|
||||
_cache_invalidate(c, e);
|
||||
}
|
||||
}
|
||||
|
||||
void *cache_free(struct cache *c) {
|
||||
void *ret = c->user_data;
|
||||
cache_invalidate_all(c);
|
||||
free(c);
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct cache *new_cache(void *ud, cache_getter_t getter, cache_free_t f) {
|
||||
auto c = ccalloc(1, struct cache);
|
||||
c->user_data = ud;
|
||||
c->getter = getter;
|
||||
c->free = f;
|
||||
return c;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#pragma once
|
||||
|
||||
struct cache;
|
||||
|
||||
typedef void *(*cache_getter_t)(void *user_data, const char *key, int *err);
|
||||
typedef void (*cache_free_t)(void *user_data, void *data);
|
||||
|
||||
/// Create a cache with `getter`, and a free function `f` which is used to free the cache
|
||||
/// value when they are invalidated.
|
||||
///
|
||||
/// `user_data` will be passed to `getter` and `f` when they are called.
|
||||
struct cache *new_cache(void *user_data, cache_getter_t getter, cache_free_t f);
|
||||
|
||||
/// Fetch a value from the cache. If the value doesn't present in the cache yet, the
|
||||
/// getter will be called, and the returned value will be stored into the cache.
|
||||
void *cache_get(struct cache *, const char *key, int *err);
|
||||
|
||||
/// Invalidate a value in the cache.
|
||||
void cache_invalidate(struct cache *, const char *key);
|
||||
|
||||
/// Invalidate all values in the cache.
|
||||
void cache_invalidate_all(struct cache *);
|
||||
|
||||
/// Invalidate all values in the cache and free it. Returns the user data passed to
|
||||
/// `new_cache`
|
||||
void *cache_free(struct cache *);
|
||||
|
||||
/// Insert a key-value pair into the cache. Only used for internal testing. Takes
|
||||
/// ownership of `data`
|
||||
///
|
||||
/// If `key` already exists in the cache, this function will abort the program.
|
||||
void cache_set(struct cache *c, const char *key, void *data);
|
||||
@@ -0,0 +1,534 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Compton - a compositor for X11
|
||||
*
|
||||
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
|
||||
*
|
||||
* Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
* Copyright (c) 2018, Yuxuan Shui <yshuiv7@gmail.com>
|
||||
*
|
||||
* See LICENSE-mit for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
// === Options ===
|
||||
|
||||
// Debug options, enable them using -D in CFLAGS
|
||||
// #define DEBUG_REPAINT 1
|
||||
// #define DEBUG_EVENTS 1
|
||||
// #define DEBUG_RESTACK 1
|
||||
// #define DEBUG_WINMATCH 1
|
||||
// #define DEBUG_C2 1
|
||||
// #define DEBUG_GLX_DEBUG_CONTEXT 1
|
||||
|
||||
#define MAX_ALPHA (255)
|
||||
|
||||
// === Includes ===
|
||||
|
||||
// For some special functions
|
||||
#include <assert.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
|
||||
#include <X11/Xlib.h>
|
||||
#include <ev.h>
|
||||
#include <pixman.h>
|
||||
#include <xcb/xproto.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/sync.h>
|
||||
|
||||
#include "uthash_extra.h"
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include "backend/gl/glx.h"
|
||||
#endif
|
||||
|
||||
// X resource checker
|
||||
#ifdef DEBUG_XRC
|
||||
#include "xrescheck.h"
|
||||
#endif
|
||||
|
||||
// FIXME This list of includes should get shorter
|
||||
#include "backend/backend.h"
|
||||
#include "backend/driver.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "utils.h"
|
||||
#include "list.h"
|
||||
#include "render.h"
|
||||
#include "win_defs.h"
|
||||
#include "x.h"
|
||||
|
||||
// === Constants ===0
|
||||
|
||||
#define NS_PER_SEC 1000000000L
|
||||
#define US_PER_SEC 1000000L
|
||||
#define MS_PER_SEC 1000
|
||||
|
||||
/// @brief Maximum OpenGL FBConfig depth.
|
||||
#define OPENGL_MAX_DEPTH 32
|
||||
|
||||
/// @brief Maximum OpenGL buffer age.
|
||||
#define CGLX_MAX_BUFFER_AGE 5
|
||||
|
||||
// Window flags
|
||||
|
||||
// === Types ===
|
||||
typedef struct glx_fbconfig glx_fbconfig_t;
|
||||
struct glx_session;
|
||||
struct atom;
|
||||
struct conv;
|
||||
|
||||
typedef struct _ignore {
|
||||
struct _ignore *next;
|
||||
unsigned long sequence;
|
||||
} ignore_t;
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
#ifdef DEBUG_GLX_DEBUG_CONTEXT
|
||||
typedef GLXContext (*f_glXCreateContextAttribsARB)(Display *dpy, GLXFBConfig config,
|
||||
GLXContext share_context, Bool direct,
|
||||
const int *attrib_list);
|
||||
typedef void (*GLDEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity,
|
||||
GLsizei length, const GLchar *message, GLvoid *userParam);
|
||||
typedef void (*f_DebugMessageCallback)(GLDEBUGPROC, void *userParam);
|
||||
#endif
|
||||
|
||||
typedef struct glx_prog_main {
|
||||
/// GLSL program.
|
||||
GLuint prog;
|
||||
/// Location of uniform "opacity" in window GLSL program.
|
||||
GLint unifm_opacity;
|
||||
/// Location of uniform "invert_color" in blur GLSL program.
|
||||
GLint unifm_invert_color;
|
||||
/// Location of uniform "tex" in window GLSL program.
|
||||
GLint unifm_tex;
|
||||
/// Location of uniform "time" in window GLSL program.
|
||||
GLint unifm_time;
|
||||
} glx_prog_main_t;
|
||||
|
||||
#define GLX_PROG_MAIN_INIT \
|
||||
{ \
|
||||
.prog = 0, .unifm_opacity = -1, .unifm_invert_color = -1, \
|
||||
.unifm_tex = -1, .unifm_time = -1 \
|
||||
}
|
||||
|
||||
#else
|
||||
struct glx_prog_main {};
|
||||
#endif
|
||||
|
||||
#define PAINT_INIT \
|
||||
{ .pixmap = XCB_NONE, .pict = XCB_NONE }
|
||||
|
||||
/// Linked list type of atoms.
|
||||
typedef struct _latom {
|
||||
xcb_atom_t atom;
|
||||
struct _latom *next;
|
||||
} latom_t;
|
||||
|
||||
/// Structure containing all necessary data for a session.
|
||||
typedef struct session {
|
||||
// === Event handlers ===
|
||||
/// ev_io for X connection
|
||||
ev_io xiow;
|
||||
/// Timeout for delayed unredirection.
|
||||
ev_timer unredir_timer;
|
||||
/// Timer for fading
|
||||
ev_timer fade_timer;
|
||||
/// Timer for animations
|
||||
ev_timer animation_timer;
|
||||
/// Use an ev_idle callback for drawing
|
||||
/// So we only start drawing when events are processed
|
||||
ev_idle draw_idle;
|
||||
/// Called everytime we have timeouts or new data on socket,
|
||||
/// so we can be sure if xcb read from X socket at anytime during event
|
||||
/// handling, we will not left any event unhandled in the queue
|
||||
ev_prepare event_check;
|
||||
/// Signal handler for SIGUSR1
|
||||
ev_signal usr1_signal;
|
||||
/// Signal handler for SIGINT
|
||||
ev_signal int_signal;
|
||||
/// backend data
|
||||
backend_t *backend_data;
|
||||
/// backend blur context
|
||||
void *backend_blur_context;
|
||||
/// graphic drivers used
|
||||
enum driver drivers;
|
||||
/// file watch handle
|
||||
void *file_watch_handle;
|
||||
/// libev mainloop
|
||||
struct ev_loop *loop;
|
||||
|
||||
// === Display related ===
|
||||
/// Whether the X server is grabbed by us
|
||||
bool server_grabbed;
|
||||
/// Display in use.
|
||||
Display *dpy;
|
||||
/// Previous handler of X errors
|
||||
XErrorHandler previous_xerror_handler;
|
||||
/// Default screen.
|
||||
int scr;
|
||||
/// XCB connection.
|
||||
xcb_connection_t *c;
|
||||
/// Default visual.
|
||||
xcb_visualid_t vis;
|
||||
/// Default depth.
|
||||
int depth;
|
||||
/// Root window.
|
||||
xcb_window_t root;
|
||||
/// Height of root window.
|
||||
int root_height;
|
||||
/// Width of root window.
|
||||
int root_width;
|
||||
/// Current desktop number of root window
|
||||
int root_desktop_num;
|
||||
/// Desktop switch direction
|
||||
int root_desktop_switch_direction;
|
||||
// Damage of root window.
|
||||
// Damage root_damage;
|
||||
/// X Composite overlay window.
|
||||
xcb_window_t overlay;
|
||||
/// The target window for debug mode
|
||||
xcb_window_t debug_window;
|
||||
/// Whether the root tile is filled by us.
|
||||
bool root_tile_fill;
|
||||
/// Picture of the root window background.
|
||||
paint_t root_tile_paint;
|
||||
/// The backend data the root pixmap bound to
|
||||
void *root_image;
|
||||
/// A region of the size of the screen.
|
||||
region_t screen_reg;
|
||||
/// Picture of root window. Destination of painting in no-DBE painting
|
||||
/// mode.
|
||||
xcb_render_picture_t root_picture;
|
||||
/// A Picture acting as the painting target.
|
||||
xcb_render_picture_t tgt_picture;
|
||||
/// Temporary buffer to paint to before sending to display.
|
||||
paint_t tgt_buffer;
|
||||
/// Window ID of the window we register as a symbol.
|
||||
xcb_window_t reg_win;
|
||||
#ifdef CONFIG_OPENGL
|
||||
/// Pointer to GLX data.
|
||||
struct glx_session *psglx;
|
||||
/// Custom GLX program used for painting window.
|
||||
// XXX should be in struct glx_session
|
||||
glx_prog_main_t glx_prog_win;
|
||||
struct glx_fbconfig_info *argb_fbconfig;
|
||||
#endif
|
||||
/// Sync fence to sync draw operations
|
||||
xcb_sync_fence_t sync_fence;
|
||||
/// Whether we are rendering the first frame after screen is redirected
|
||||
bool first_frame;
|
||||
|
||||
// === Operation related ===
|
||||
/// Flags related to the root window
|
||||
uint64_t root_flags;
|
||||
/// Program options.
|
||||
options_t o;
|
||||
/// Whether we have hit unredirection timeout.
|
||||
bool tmout_unredir_hit;
|
||||
/// Whether we need to redraw the screen
|
||||
bool redraw_needed;
|
||||
|
||||
/// Cache a xfixes region so we don't need to allocate it everytime.
|
||||
/// A workaround for yshui/picom#301
|
||||
xcb_xfixes_region_t damaged_region;
|
||||
/// The region needs to painted on next paint.
|
||||
region_t *damage;
|
||||
/// The region damaged on the last paint.
|
||||
region_t *damage_ring;
|
||||
/// Number of damage regions we track
|
||||
int ndamage;
|
||||
/// Whether all windows are currently redirected.
|
||||
bool redirected;
|
||||
/// Pre-generated alpha pictures.
|
||||
xcb_render_picture_t *alpha_picts;
|
||||
/// Time of last fading. In milliseconds.
|
||||
long long fade_time;
|
||||
/// Time of last window animation step. In milliseconds.
|
||||
long animation_time; // TODO(dccsillag) turn into `long long`, like fade_time
|
||||
/// Head pointer of the error ignore linked list.
|
||||
ignore_t *ignore_head;
|
||||
/// Pointer to the <code>next</code> member of tail element of the error
|
||||
/// ignore linked list.
|
||||
ignore_t **ignore_tail;
|
||||
// Cached blur convolution kernels.
|
||||
struct x_convolution_kernel **blur_kerns_cache;
|
||||
/// If we should quit
|
||||
bool quit:1;
|
||||
// TODO(yshui) use separate flags for dfferent kinds of updates so we don't
|
||||
// waste our time.
|
||||
/// Whether there are pending updates, like window creation, etc.
|
||||
bool pending_updates:1;
|
||||
|
||||
// === Expose event related ===
|
||||
/// Pointer to an array of <code>XRectangle</code>-s of exposed region.
|
||||
/// XXX why do we need this array?
|
||||
rect_t *expose_rects;
|
||||
/// Number of <code>XRectangle</code>-s in <code>expose_rects</code>.
|
||||
int size_expose;
|
||||
/// Index of the next free slot in <code>expose_rects</code>.
|
||||
int n_expose;
|
||||
|
||||
// === Window related ===
|
||||
/// A hash table of all windows.
|
||||
struct win *windows;
|
||||
/// Windows in their stacking order
|
||||
struct list_node window_stack;
|
||||
/// Pointer to <code>win</code> of current active window. Used by
|
||||
/// EWMH <code>_NET_ACTIVE_WINDOW</code> focus detection. In theory,
|
||||
/// it's more reliable to store the window ID directly here, just in
|
||||
/// case the WM does something extraordinary, but caching the pointer
|
||||
/// means another layer of complexity.
|
||||
struct managed_win *active_win;
|
||||
/// Window ID of leader window of currently active window. Used for
|
||||
/// subsidiary window detection.
|
||||
xcb_window_t active_leader;
|
||||
|
||||
// === Shadow/dimming related ===
|
||||
/// 1x1 black Picture.
|
||||
xcb_render_picture_t black_picture;
|
||||
/// 1x1 Picture of the shadow color.
|
||||
xcb_render_picture_t cshadow_picture;
|
||||
/// 1x1 white Picture.
|
||||
xcb_render_picture_t white_picture;
|
||||
/// Gaussian map of shadow.
|
||||
struct conv *gaussian_map;
|
||||
// for shadow precomputation
|
||||
/// A region in which shadow is not painted on.
|
||||
region_t shadow_exclude_reg;
|
||||
|
||||
// === Software-optimization-related ===
|
||||
/// Nanosecond offset of the first painting.
|
||||
long paint_tm_offset;
|
||||
|
||||
#ifdef CONFIG_VSYNC_DRM
|
||||
// === DRM VSync related ===
|
||||
/// File descriptor of DRI device file. Used for DRM VSync.
|
||||
int drm_fd;
|
||||
#endif
|
||||
|
||||
// === X extension related ===
|
||||
/// Event base number for X Fixes extension.
|
||||
int xfixes_event;
|
||||
/// Error base number for X Fixes extension.
|
||||
int xfixes_error;
|
||||
/// Event base number for X Damage extension.
|
||||
int damage_event;
|
||||
/// Error base number for X Damage extension.
|
||||
int damage_error;
|
||||
/// Event base number for X Render extension.
|
||||
int render_event;
|
||||
/// Error base number for X Render extension.
|
||||
int render_error;
|
||||
/// Event base number for X Composite extension.
|
||||
int composite_event;
|
||||
/// Error base number for X Composite extension.
|
||||
int composite_error;
|
||||
/// Major opcode for X Composite extension.
|
||||
int composite_opcode;
|
||||
/// Whether X Shape extension exists.
|
||||
bool shape_exists;
|
||||
/// Event base number for X Shape extension.
|
||||
int shape_event;
|
||||
/// Error base number for X Shape extension.
|
||||
int shape_error;
|
||||
/// Whether X RandR extension exists.
|
||||
bool randr_exists;
|
||||
/// Event base number for X RandR extension.
|
||||
int randr_event;
|
||||
/// Error base number for X RandR extension.
|
||||
int randr_error;
|
||||
/// Whether X Present extension exists.
|
||||
bool present_exists;
|
||||
/// Whether X GLX extension exists.
|
||||
bool glx_exists;
|
||||
/// Event base number for X GLX extension.
|
||||
int glx_event;
|
||||
/// Error base number for X GLX extension.
|
||||
int glx_error;
|
||||
/// Whether X Xinerama extension exists.
|
||||
bool xinerama_exists;
|
||||
/// Xinerama screen regions.
|
||||
region_t *xinerama_scr_regs;
|
||||
/// Number of Xinerama screens.
|
||||
int xinerama_nscrs;
|
||||
/// Whether X Sync extension exists.
|
||||
bool xsync_exists;
|
||||
/// Event base number for X Sync extension.
|
||||
int xsync_event;
|
||||
/// Error base number for X Sync extension.
|
||||
int xsync_error;
|
||||
/// Whether X Render convolution filter exists.
|
||||
bool xrfilter_convolution_exists;
|
||||
|
||||
// === Atoms ===
|
||||
struct atom *atoms;
|
||||
/// Array of atoms of all possible window types.
|
||||
xcb_atom_t atoms_wintypes[NUM_WINTYPES];
|
||||
/// Linked list of additional atoms to track.
|
||||
latom_t *track_atom_lst;
|
||||
|
||||
#ifdef CONFIG_DBUS
|
||||
// === DBus related ===
|
||||
void *dbus_data;
|
||||
#endif
|
||||
|
||||
int (*vsync_wait)(session_t *);
|
||||
} session_t;
|
||||
|
||||
/// Enumeration for window event hints.
|
||||
typedef enum { WIN_EVMODE_UNKNOWN, WIN_EVMODE_FRAME, WIN_EVMODE_CLIENT } win_evmode_t;
|
||||
|
||||
extern const char *const WINTYPES[NUM_WINTYPES];
|
||||
extern session_t *ps_g;
|
||||
|
||||
void ev_xcb_error(session_t *ps, xcb_generic_error_t *err);
|
||||
|
||||
// === Functions ===
|
||||
|
||||
/**
|
||||
* Subtracting two struct timespec values.
|
||||
*
|
||||
* Taken from glibc manual.
|
||||
*
|
||||
* Subtract the `struct timespec' values X and Y,
|
||||
* storing the result in RESULT.
|
||||
* Return 1 if the difference is negative, otherwise 0.
|
||||
*/
|
||||
static inline int
|
||||
timespec_subtract(struct timespec *result, struct timespec *x, struct timespec *y) {
|
||||
/* Perform the carry for the later subtraction by updating y. */
|
||||
if (x->tv_nsec < y->tv_nsec) {
|
||||
long nsec = (y->tv_nsec - x->tv_nsec) / NS_PER_SEC + 1;
|
||||
y->tv_nsec -= NS_PER_SEC * nsec;
|
||||
y->tv_sec += nsec;
|
||||
}
|
||||
|
||||
if (x->tv_nsec - y->tv_nsec > NS_PER_SEC) {
|
||||
long nsec = (x->tv_nsec - y->tv_nsec) / NS_PER_SEC;
|
||||
y->tv_nsec += NS_PER_SEC * nsec;
|
||||
y->tv_sec -= nsec;
|
||||
}
|
||||
|
||||
/* Compute the time remaining to wait.
|
||||
tv_nsec is certainly positive. */
|
||||
result->tv_sec = x->tv_sec - y->tv_sec;
|
||||
result->tv_nsec = x->tv_nsec - y->tv_nsec;
|
||||
|
||||
/* Return 1 if result is negative. */
|
||||
return x->tv_sec < y->tv_sec;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current time in struct timeval.
|
||||
*/
|
||||
static inline struct timeval get_time_timeval(void) {
|
||||
struct timeval tv = {0, 0};
|
||||
|
||||
gettimeofday(&tv, NULL);
|
||||
|
||||
// Return a time of all 0 if the call fails
|
||||
return tv;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current time in struct timespec.
|
||||
*
|
||||
* Note its starting time is unspecified.
|
||||
*/
|
||||
static inline struct timespec get_time_timespec(void) {
|
||||
struct timespec tm = {0, 0};
|
||||
|
||||
clock_gettime(CLOCK_MONOTONIC, &tm);
|
||||
|
||||
// Return a time of all 0 if the call fails
|
||||
return tm;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the painting target window.
|
||||
*/
|
||||
static inline xcb_window_t get_tgt_window(session_t *ps) {
|
||||
return ps->overlay != XCB_NONE ? ps->overlay : ps->root;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if current backend uses GLX.
|
||||
*/
|
||||
static inline bool bkend_use_glx(session_t *ps) {
|
||||
return BKEND_GLX == ps->o.backend || BKEND_XR_GLX_HYBRID == ps->o.backend;
|
||||
}
|
||||
|
||||
static void set_ignore(session_t *ps, unsigned long sequence) {
|
||||
if (ps->o.show_all_xerrors)
|
||||
return;
|
||||
|
||||
auto i = cmalloc(ignore_t);
|
||||
if (!i)
|
||||
return;
|
||||
|
||||
i->sequence = sequence;
|
||||
i->next = 0;
|
||||
*ps->ignore_tail = i;
|
||||
ps->ignore_tail = &i->next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignore X errors caused by given X request.
|
||||
*/
|
||||
static inline void set_ignore_cookie(session_t *ps, xcb_void_cookie_t cookie) {
|
||||
set_ignore(ps, cookie.sequence);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine if a window has a specific property.
|
||||
*
|
||||
* @param ps current session
|
||||
* @param w window to check
|
||||
* @param atom atom of property to check
|
||||
* @return true if it has the attribute, false otherwise
|
||||
*/
|
||||
static inline bool wid_has_prop(const session_t *ps, xcb_window_t w, xcb_atom_t atom) {
|
||||
auto r = xcb_get_property_reply(
|
||||
ps->c, xcb_get_property(ps->c, 0, w, atom, XCB_GET_PROPERTY_TYPE_ANY, 0, 0), NULL);
|
||||
if (!r) {
|
||||
return false;
|
||||
}
|
||||
|
||||
auto rtype = r->type;
|
||||
free(r);
|
||||
|
||||
if (rtype != XCB_NONE) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void force_repaint(session_t *ps);
|
||||
|
||||
/** @name DBus handling
|
||||
*/
|
||||
///@{
|
||||
#ifdef CONFIG_DBUS
|
||||
/** @name DBus hooks
|
||||
*/
|
||||
///@{
|
||||
void opts_set_no_fading_openclose(session_t *ps, bool newval);
|
||||
//!@}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Set a <code>bool</code> array of all wintypes to true.
|
||||
*/
|
||||
static inline void wintype_arr_enable(bool arr[]) {
|
||||
wintype_t i;
|
||||
|
||||
for (i = 0; i < NUM_WINTYPES; ++i) {
|
||||
arr[i] = true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
|
||||
#ifdef HAS_STDC_PREDEF_H
|
||||
#include <stdc-predef.h>
|
||||
#endif
|
||||
|
||||
// clang-format off
|
||||
#define auto __auto_type
|
||||
#define likely(x) __builtin_expect(!!(x), 1)
|
||||
#define unlikely(x) __builtin_expect(!!(x), 0)
|
||||
#define likely_if(x) if (likely(x))
|
||||
#define unlikely_if(x) if (unlikely(x))
|
||||
|
||||
#ifndef __has_attribute
|
||||
# if __GNUC__ >= 4
|
||||
# define __has_attribute(x) 1
|
||||
# else
|
||||
# define __has_attribute(x) 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if __has_attribute(const)
|
||||
# define attr_const __attribute__((const))
|
||||
#else
|
||||
# define attr_const
|
||||
#endif
|
||||
|
||||
#if __has_attribute(format)
|
||||
# define attr_printf(a, b) __attribute__((format(printf, a, b)))
|
||||
#else
|
||||
# define attr_printf(a, b)
|
||||
#endif
|
||||
|
||||
#if __has_attribute(pure)
|
||||
# define attr_pure __attribute__((pure))
|
||||
#else
|
||||
# define attr_pure
|
||||
#endif
|
||||
|
||||
#if __has_attribute(unused)
|
||||
# define attr_unused __attribute__((unused))
|
||||
#else
|
||||
# define attr_unused
|
||||
#endif
|
||||
|
||||
#if __has_attribute(warn_unused_result)
|
||||
# define attr_warn_unused_result __attribute__((warn_unused_result))
|
||||
#else
|
||||
# define attr_warn_unused_result
|
||||
#endif
|
||||
// An alias for conveninence
|
||||
#define must_use attr_warn_unused_result
|
||||
|
||||
#if __has_attribute(nonnull)
|
||||
# define attr_nonnull(...) __attribute__((nonnull(__VA_ARGS__)))
|
||||
# define attr_nonnull_all __attribute__((nonnull))
|
||||
#else
|
||||
# define attr_nonnull(...)
|
||||
# define attr_nonnull_all
|
||||
#endif
|
||||
|
||||
#if __has_attribute(returns_nonnull)
|
||||
# define attr_ret_nonnull __attribute__((returns_nonnull))
|
||||
#else
|
||||
# define attr_ret_nonnull
|
||||
#endif
|
||||
|
||||
#if __has_attribute(deprecated)
|
||||
# define attr_deprecated __attribute__((deprecated))
|
||||
#else
|
||||
# define attr_deprecated
|
||||
#endif
|
||||
|
||||
#if __has_attribute(malloc)
|
||||
# define attr_malloc __attribute__((malloc))
|
||||
#else
|
||||
# define attr_malloc
|
||||
#endif
|
||||
|
||||
#if __has_attribute(fallthrough)
|
||||
# define fallthrough() __attribute__((fallthrough))
|
||||
#else
|
||||
# define fallthrough()
|
||||
#endif
|
||||
|
||||
#if __STDC_VERSION__ >= 201112L
|
||||
# define attr_noret _Noreturn
|
||||
#else
|
||||
# if __has_attribute(noreturn)
|
||||
# define attr_noret __attribute__((noreturn))
|
||||
# else
|
||||
# define attr_noret
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
# define unreachable __builtin_unreachable()
|
||||
#else
|
||||
# define unreachable do {} while(0)
|
||||
#endif
|
||||
|
||||
#ifndef __has_include
|
||||
# define __has_include(x) 0
|
||||
#endif
|
||||
|
||||
#if !defined(__STDC_NO_THREADS__) && __has_include(<threads.h>)
|
||||
# include <threads.h>
|
||||
#elif __STDC_VERSION__ >= 201112L
|
||||
# define thread_local _Thread_local
|
||||
#elif defined(__GNUC__) || defined(__clang__)
|
||||
# define thread_local __thread
|
||||
#else
|
||||
# define thread_local _Pragma("GCC error \"No thread local storage support\"") __error__
|
||||
#endif
|
||||
// clang-format on
|
||||
|
||||
typedef unsigned long ulong;
|
||||
typedef unsigned int uint;
|
||||
|
||||
static inline int attr_const popcntul(unsigned long a) {
|
||||
return __builtin_popcountl(a);
|
||||
}
|
||||
@@ -0,0 +1,651 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
// Copyright (c) 2013 Richard Grenville <pyxlcy@gmail.com>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <xcb/render.h> // for xcb_render_fixed_t, XXX
|
||||
|
||||
#include "c2.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "string_utils.h"
|
||||
#include "types.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
|
||||
#include "config.h"
|
||||
|
||||
/**
|
||||
* Parse a long number.
|
||||
*/
|
||||
bool parse_long(const char *s, long *dest) {
|
||||
const char *endptr = NULL;
|
||||
long val = strtol(s, (char **)&endptr, 0);
|
||||
if (!endptr || endptr == s) {
|
||||
log_error("Invalid number: %s", s);
|
||||
return false;
|
||||
}
|
||||
while (isspace((unsigned char)*endptr))
|
||||
++endptr;
|
||||
if (*endptr) {
|
||||
log_error("Trailing characters: %s", s);
|
||||
return false;
|
||||
}
|
||||
*dest = val;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an int number.
|
||||
*/
|
||||
bool parse_int(const char *s, int *dest) {
|
||||
long val;
|
||||
if (!parse_long(s, &val)) {
|
||||
return false;
|
||||
}
|
||||
if (val > INT_MAX || val < INT_MIN) {
|
||||
log_error("Number exceeded int limits: %ld", val);
|
||||
return false;
|
||||
}
|
||||
*dest = (int)val;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a floating-point number in from a string,
|
||||
* also strips the trailing space and comma after the number.
|
||||
*
|
||||
* @param[in] src string to parse
|
||||
* @param[out] dest return the number parsed from the string
|
||||
* @return pointer to the last character parsed
|
||||
*/
|
||||
const char *parse_readnum(const char *src, double *dest) {
|
||||
const char *pc = NULL;
|
||||
double val = strtod_simple(src, &pc);
|
||||
if (!pc || pc == src) {
|
||||
log_error("No number found: %s", src);
|
||||
return src;
|
||||
}
|
||||
while (*pc && (isspace((unsigned char)*pc) || *pc == ',')) {
|
||||
++pc;
|
||||
}
|
||||
*dest = val;
|
||||
return pc;
|
||||
}
|
||||
|
||||
enum blur_method parse_blur_method(const char *src) {
|
||||
if (strcmp(src, "kernel") == 0) {
|
||||
return BLUR_METHOD_KERNEL;
|
||||
} else if (strcmp(src, "box") == 0) {
|
||||
return BLUR_METHOD_BOX;
|
||||
} else if (strcmp(src, "gaussian") == 0) {
|
||||
return BLUR_METHOD_GAUSSIAN;
|
||||
} else if (strcmp(src, "dual_kawase") == 0) {
|
||||
return BLUR_METHOD_DUAL_KAWASE;
|
||||
} else if (strcmp(src, "kawase") == 0) {
|
||||
log_warn("Blur method 'kawase' has been renamed to 'dual_kawase'. "
|
||||
"Interpreted as 'dual_kawase', but this will stop working "
|
||||
"soon.");
|
||||
return BLUR_METHOD_DUAL_KAWASE;
|
||||
} else if (strcmp(src, "none") == 0) {
|
||||
return BLUR_METHOD_NONE;
|
||||
}
|
||||
return BLUR_METHOD_INVALID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a matrix.
|
||||
*
|
||||
* @param[in] src the blur kernel string
|
||||
* @param[out] endptr return where the end of kernel is in the string
|
||||
* @param[out] hasneg whether the kernel has negative values
|
||||
*/
|
||||
conv *parse_blur_kern(const char *src, const char **endptr, bool *hasneg) {
|
||||
int width = 0, height = 0;
|
||||
*hasneg = false;
|
||||
|
||||
const char *pc = NULL;
|
||||
|
||||
// Get matrix width and height
|
||||
double val = 0.0;
|
||||
if (src == (pc = parse_readnum(src, &val)))
|
||||
goto err1;
|
||||
src = pc;
|
||||
width = (int)val;
|
||||
if (src == (pc = parse_readnum(src, &val)))
|
||||
goto err1;
|
||||
src = pc;
|
||||
height = (int)val;
|
||||
|
||||
// Validate matrix width and height
|
||||
if (width <= 0 || height <= 0) {
|
||||
log_error("Blue kernel width/height can't be negative.");
|
||||
goto err1;
|
||||
}
|
||||
if (!(width % 2 && height % 2)) {
|
||||
log_error("Blur kernel width/height must be odd.");
|
||||
goto err1;
|
||||
}
|
||||
if (width > 16 || height > 16)
|
||||
log_warn("Blur kernel width/height too large, may slow down"
|
||||
"rendering, and/or consume lots of memory");
|
||||
|
||||
// Allocate memory
|
||||
conv *matrix = cvalloc(sizeof(conv) + (size_t)(width * height) * sizeof(double));
|
||||
|
||||
// Read elements
|
||||
int skip = height / 2 * width + width / 2;
|
||||
for (int i = 0; i < width * height; ++i) {
|
||||
// Ignore the center element
|
||||
if (i == skip) {
|
||||
matrix->data[i] = 1;
|
||||
continue;
|
||||
}
|
||||
if (src == (pc = parse_readnum(src, &val))) {
|
||||
goto err2;
|
||||
}
|
||||
src = pc;
|
||||
if (val < 0) {
|
||||
*hasneg = true;
|
||||
}
|
||||
matrix->data[i] = val;
|
||||
}
|
||||
|
||||
// Detect trailing characters
|
||||
for (; *pc && *pc != ';'; pc++) {
|
||||
if (!isspace((unsigned char)*pc) && *pc != ',') {
|
||||
// TODO(yshui) isspace is locale aware, be careful
|
||||
log_error("Trailing characters in blur kernel string.");
|
||||
goto err2;
|
||||
}
|
||||
}
|
||||
|
||||
// Jump over spaces after ';'
|
||||
if (*pc == ';') {
|
||||
pc++;
|
||||
while (*pc && isspace((unsigned char)*pc)) {
|
||||
++pc;
|
||||
}
|
||||
}
|
||||
|
||||
// Require an end of string if endptr is not provided, otherwise
|
||||
// copy end pointer to endptr
|
||||
if (endptr) {
|
||||
*endptr = pc;
|
||||
} else if (*pc) {
|
||||
log_error("Only one blur kernel expected.");
|
||||
goto err2;
|
||||
}
|
||||
|
||||
// Fill in width and height
|
||||
matrix->w = width;
|
||||
matrix->h = height;
|
||||
return matrix;
|
||||
|
||||
err2:
|
||||
free(matrix);
|
||||
err1:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a list of convolution kernels.
|
||||
*
|
||||
* @param[in] src string to parse
|
||||
* @param[out] hasneg whether any of the kernels have negative values
|
||||
* @return the kernels
|
||||
*/
|
||||
struct conv **parse_blur_kern_lst(const char *src, bool *hasneg, int *count) {
|
||||
// TODO(yshui) just return a predefined kernels, not parse predefined strings...
|
||||
static const struct {
|
||||
const char *name;
|
||||
const char *kern_str;
|
||||
} CONV_KERN_PREDEF[] = {
|
||||
{"3x3box", "3,3,1,1,1,1,1,1,1,1,"},
|
||||
{"5x5box", "5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,"},
|
||||
{"7x7box", "7,7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,"
|
||||
"1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,"},
|
||||
{"3x3gaussian", "3,3,0.243117,0.493069,0.243117,0.493069,0.493069,0.243117,0."
|
||||
"493069,0.243117,"},
|
||||
{"5x5gaussian", "5,5,0.003493,0.029143,0.059106,0.029143,0.003493,0.029143,0."
|
||||
"243117,0.493069,0.243117,0.029143,0.059106,0.493069,0."
|
||||
"493069,0.059106,0.029143,0.243117,0.493069,0.243117,0."
|
||||
"029143,0.003493,0.029143,0.059106,0.029143,0.003493,"},
|
||||
{"7x7gaussian", "7,7,0.000003,0.000102,0.000849,0.001723,0.000849,0.000102,0."
|
||||
"000003,0.000102,0.003493,0.029143,0.059106,0.029143,0."
|
||||
"003493,0.000102,0.000849,0.029143,0.243117,0.493069,0."
|
||||
"243117,0.029143,0.000849,0.001723,0.059106,0.493069,0."
|
||||
"493069,0.059106,0.001723,0.000849,0.029143,0.243117,0."
|
||||
"493069,0.243117,0.029143,0.000849,0.000102,0.003493,0."
|
||||
"029143,0.059106,0.029143,0.003493,0.000102,0.000003,0."
|
||||
"000102,0.000849,0.001723,0.000849,0.000102,0.000003,"},
|
||||
{"9x9gaussian",
|
||||
"9,9,0.000000,0.000000,0.000001,0.000006,0.000012,0.000006,0.000001,0."
|
||||
"000000,0.000000,0.000000,0.000003,0.000102,0.000849,0.001723,0.000849,0."
|
||||
"000102,0.000003,0.000000,0.000001,0.000102,0.003493,0.029143,0.059106,0."
|
||||
"029143,0.003493,0.000102,0.000001,0.000006,0.000849,0.029143,0.243117,0."
|
||||
"493069,0.243117,0.029143,0.000849,0.000006,0.000012,0.001723,0.059106,0."
|
||||
"493069,0.493069,0.059106,0.001723,0.000012,0.000006,0.000849,0.029143,0."
|
||||
"243117,0.493069,0.243117,0.029143,0.000849,0.000006,0.000001,0.000102,0."
|
||||
"003493,0.029143,0.059106,0.029143,0.003493,0.000102,0.000001,0.000000,0."
|
||||
"000003,0.000102,0.000849,0.001723,0.000849,0.000102,0.000003,0.000000,0."
|
||||
"000000,0.000000,0.000001,0.000006,0.000012,0.000006,0.000001,0.000000,0."
|
||||
"000000,"},
|
||||
{"11x11gaussian",
|
||||
"11,11,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0."
|
||||
"000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000001,0."
|
||||
"000006,0.000012,0.000006,0.000001,0.000000,0.000000,0.000000,0.000000,0."
|
||||
"000000,0.000003,0.000102,0.000849,0.001723,0.000849,0.000102,0.000003,0."
|
||||
"000000,0.000000,0.000000,0.000001,0.000102,0.003493,0.029143,0.059106,0."
|
||||
"029143,0.003493,0.000102,0.000001,0.000000,0.000000,0.000006,0.000849,0."
|
||||
"029143,0.243117,0.493069,0.243117,0.029143,0.000849,0.000006,0.000000,0."
|
||||
"000000,0.000012,0.001723,0.059106,0.493069,0.493069,0.059106,0.001723,0."
|
||||
"000012,0.000000,0.000000,0.000006,0.000849,0.029143,0.243117,0.493069,0."
|
||||
"243117,0.029143,0.000849,0.000006,0.000000,0.000000,0.000001,0.000102,0."
|
||||
"003493,0.029143,0.059106,0.029143,0.003493,0.000102,0.000001,0.000000,0."
|
||||
"000000,0.000000,0.000003,0.000102,0.000849,0.001723,0.000849,0.000102,0."
|
||||
"000003,0.000000,0.000000,0.000000,0.000000,0.000000,0.000001,0.000006,0."
|
||||
"000012,0.000006,0.000001,0.000000,0.000000,0.000000,0.000000,0.000000,0."
|
||||
"000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0.000000,0."
|
||||
"000000,"},
|
||||
};
|
||||
|
||||
*count = 0;
|
||||
*hasneg = false;
|
||||
for (unsigned int i = 0;
|
||||
i < sizeof(CONV_KERN_PREDEF) / sizeof(CONV_KERN_PREDEF[0]); ++i) {
|
||||
if (!strcmp(CONV_KERN_PREDEF[i].name, src))
|
||||
return parse_blur_kern_lst(CONV_KERN_PREDEF[i].kern_str, hasneg, count);
|
||||
}
|
||||
|
||||
int nkernels = 1;
|
||||
for (int i = 0; src[i]; i++) {
|
||||
if (src[i] == ';') {
|
||||
nkernels++;
|
||||
}
|
||||
}
|
||||
|
||||
struct conv **ret = ccalloc(nkernels, struct conv *);
|
||||
|
||||
int i = 0;
|
||||
const char *pc = src;
|
||||
|
||||
// Continue parsing until the end of source string
|
||||
i = 0;
|
||||
while (pc && *pc) {
|
||||
bool tmp_hasneg;
|
||||
assert(i < nkernels);
|
||||
ret[i] = parse_blur_kern(pc, &pc, &tmp_hasneg);
|
||||
if (!ret[i]) {
|
||||
for (int j = 0; j < i; j++) {
|
||||
free(ret[j]);
|
||||
}
|
||||
free(ret);
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
*hasneg |= tmp_hasneg;
|
||||
}
|
||||
|
||||
if (i > 1) {
|
||||
log_warn("You are seeing this message because you are using "
|
||||
"multipass blur. Please report an issue to us so we know "
|
||||
"multipass blur is actually been used. Otherwise it might be "
|
||||
"removed in future releases");
|
||||
}
|
||||
|
||||
*count = i;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a X geometry.
|
||||
*
|
||||
* ps->root_width and ps->root_height must be valid
|
||||
*/
|
||||
bool parse_geometry(session_t *ps, const char *src, region_t *dest) {
|
||||
pixman_region32_clear(dest);
|
||||
if (!src) {
|
||||
return true;
|
||||
}
|
||||
if (!ps->root_width || !ps->root_height) {
|
||||
return true;
|
||||
}
|
||||
|
||||
long x = 0, y = 0;
|
||||
long width = ps->root_width, height = ps->root_height;
|
||||
long val = 0L;
|
||||
char *endptr = NULL;
|
||||
|
||||
src = skip_space(src);
|
||||
if (!*src) {
|
||||
goto parse_geometry_end;
|
||||
}
|
||||
|
||||
// Parse width
|
||||
// Must be base 10, because "0x0..." may appear
|
||||
if (*src != '+' && *src != '-') {
|
||||
val = strtol(src, &endptr, 10);
|
||||
assert(endptr);
|
||||
if (src != endptr) {
|
||||
if (val < 0) {
|
||||
log_error("Invalid width: %s", src);
|
||||
return false;
|
||||
}
|
||||
width = val;
|
||||
src = endptr;
|
||||
}
|
||||
src = skip_space(src);
|
||||
}
|
||||
|
||||
// Parse height
|
||||
if (*src == 'x') {
|
||||
++src;
|
||||
val = strtol(src, &endptr, 10);
|
||||
assert(endptr);
|
||||
if (src != endptr) {
|
||||
if (val < 0) {
|
||||
log_error("Invalid height: %s", src);
|
||||
return false;
|
||||
}
|
||||
height = val;
|
||||
src = endptr;
|
||||
}
|
||||
src = skip_space(src);
|
||||
}
|
||||
|
||||
// Parse x
|
||||
if (*src == '+' || *src == '-') {
|
||||
val = strtol(src, &endptr, 10);
|
||||
if (endptr && src != endptr) {
|
||||
x = val;
|
||||
if (*src == '-') {
|
||||
x += ps->root_width - width;
|
||||
}
|
||||
src = endptr;
|
||||
}
|
||||
src = skip_space(src);
|
||||
}
|
||||
|
||||
// Parse y
|
||||
if (*src == '+' || *src == '-') {
|
||||
val = strtol(src, &endptr, 10);
|
||||
if (endptr && src != endptr) {
|
||||
y = val;
|
||||
if (*src == '-') {
|
||||
y += ps->root_height - height;
|
||||
}
|
||||
src = endptr;
|
||||
}
|
||||
src = skip_space(src);
|
||||
}
|
||||
|
||||
if (*src) {
|
||||
log_error("Trailing characters: %s", src);
|
||||
return false;
|
||||
}
|
||||
|
||||
parse_geometry_end:
|
||||
if (x < INT_MIN || x > INT_MAX || y < INT_MIN || y > INT_MAX) {
|
||||
log_error("Geometry coordinates exceeded limits: %s", src);
|
||||
return false;
|
||||
}
|
||||
if (width > UINT_MAX || height > UINT_MAX) {
|
||||
// less than 0 is checked for earlier
|
||||
log_error("Geometry size exceeded limits: %s", src);
|
||||
return false;
|
||||
}
|
||||
pixman_region32_union_rect(dest, dest, (int)x, (int)y, (uint)width, (uint)height);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a list of opacity rules.
|
||||
*/
|
||||
bool parse_rule_opacity(c2_lptr_t **res, const char *src) {
|
||||
// Find opacity value
|
||||
char *endptr = NULL;
|
||||
long val = strtol(src, &endptr, 0);
|
||||
if (!endptr || endptr == src) {
|
||||
log_error("No opacity specified: %s", src);
|
||||
return false;
|
||||
}
|
||||
if (val > 100 || val < 0) {
|
||||
log_error("Opacity %ld invalid: %s", val, src);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Skip over spaces
|
||||
while (*endptr && isspace((unsigned char)*endptr))
|
||||
++endptr;
|
||||
if (':' != *endptr) {
|
||||
log_error("Opacity terminator not found: %s", src);
|
||||
return false;
|
||||
}
|
||||
++endptr;
|
||||
|
||||
// Parse pattern
|
||||
// I hope 1-100 is acceptable for (void *)
|
||||
return c2_parse(res, endptr, (void *)val);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a pattern to a condition linked list.
|
||||
*/
|
||||
bool condlst_add(c2_lptr_t **pcondlst, const char *pattern) {
|
||||
if (!pattern)
|
||||
return false;
|
||||
|
||||
if (!c2_parse(pcondlst, pattern, NULL))
|
||||
exit(1);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void set_default_winopts(options_t *opt, win_option_mask_t *mask, bool shadow_enable,
|
||||
bool fading_enable, bool blur_enable) {
|
||||
// Apply default wintype options.
|
||||
if (!mask[WINTYPE_DESKTOP].shadow) {
|
||||
// Desktop windows are always drawn without shadow by default.
|
||||
mask[WINTYPE_DESKTOP].shadow = true;
|
||||
opt->wintype_option[WINTYPE_DESKTOP].shadow = false;
|
||||
}
|
||||
|
||||
// Focused/unfocused state only apply to a few window types, all other windows
|
||||
// are always considered focused.
|
||||
const wintype_t nofocus_type[] = {WINTYPE_UNKNOWN, WINTYPE_NORMAL, WINTYPE_UTILITY};
|
||||
for (unsigned long i = 0; i < ARR_SIZE(nofocus_type); i++) {
|
||||
if (!mask[nofocus_type[i]].focus) {
|
||||
mask[nofocus_type[i]].focus = true;
|
||||
opt->wintype_option[nofocus_type[i]].focus = false;
|
||||
}
|
||||
}
|
||||
for (unsigned long i = 0; i < NUM_WINTYPES; i++) {
|
||||
if (!mask[i].shadow) {
|
||||
mask[i].shadow = true;
|
||||
opt->wintype_option[i].shadow = shadow_enable;
|
||||
}
|
||||
if (!mask[i].fade) {
|
||||
mask[i].fade = true;
|
||||
opt->wintype_option[i].fade = fading_enable;
|
||||
}
|
||||
if (!mask[i].focus) {
|
||||
mask[i].focus = true;
|
||||
opt->wintype_option[i].focus = true;
|
||||
}
|
||||
if (!mask[i].blur_background) {
|
||||
mask[i].blur_background = true;
|
||||
opt->wintype_option[i].blur_background = blur_enable;
|
||||
}
|
||||
if (!mask[i].full_shadow) {
|
||||
mask[i].full_shadow = true;
|
||||
opt->wintype_option[i].full_shadow = false;
|
||||
}
|
||||
if (!mask[i].redir_ignore) {
|
||||
mask[i].redir_ignore = true;
|
||||
opt->wintype_option[i].redir_ignore = false;
|
||||
}
|
||||
if (!mask[i].opacity) {
|
||||
mask[i].opacity = true;
|
||||
// Opacity is not set to a concrete number here because the
|
||||
// opacity logic is complicated, and needs an "unset" state
|
||||
opt->wintype_option[i].opacity = NAN;
|
||||
}
|
||||
if (!mask[i].animation) {
|
||||
mask[i].animation = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
opt->wintype_option[i].animation = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (!mask[i].animation_unmap) {
|
||||
mask[i].animation_unmap = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
opt->wintype_option[i].animation_unmap = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (!mask[i].animation_workspace_in) {
|
||||
mask[i].animation_workspace_in = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
opt->wintype_option[i].animation_workspace_in = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (!mask[i].animation_workspace_out) {
|
||||
mask[i].animation_workspace_out = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
opt->wintype_option[i].animation_workspace_out = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (!mask[i].clip_shadow_above) {
|
||||
mask[i].clip_shadow_above = true;
|
||||
opt->wintype_option[i].clip_shadow_above = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum open_window_animation parse_open_window_animation(const char *src) {
|
||||
if (strcmp(src, "none") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_NONE;
|
||||
}else if (strcmp(src, "auto") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_AUTO;
|
||||
} else if (strcmp(src, "fly-in") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_FLYIN;
|
||||
} else if (strcmp(src, "zoom") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_ZOOM;
|
||||
} else if (strcmp(src, "squeeze") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_SQUEEZE;
|
||||
} else if (strcmp(src, "slide-up") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_SLIDE_UP;
|
||||
} else if (strcmp(src, "slide-down") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_SLIDE_DOWN;
|
||||
} else if (strcmp(src, "slide-left") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_SLIDE_LEFT;
|
||||
} else if (strcmp(src, "slide-right") == 0) {
|
||||
return OPEN_WINDOW_ANIMATION_SLIDE_RIGHT;
|
||||
}
|
||||
return OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
|
||||
char *parse_config(options_t *opt, const char *config_file, bool *shadow_enable,
|
||||
bool *fading_enable, bool *hasneg, win_option_mask_t *winopt_mask) {
|
||||
// clang-format off
|
||||
*opt = (struct options){
|
||||
.backend = BKEND_XRENDER,
|
||||
.glx_no_stencil = false,
|
||||
.mark_wmwin_focused = false,
|
||||
.mark_ovredir_focused = false,
|
||||
.detect_rounded_corners = false,
|
||||
.resize_damage = 0,
|
||||
.unredir_if_possible = false,
|
||||
.unredir_if_possible_blacklist = NULL,
|
||||
.unredir_if_possible_delay = 0,
|
||||
.redirected_force = UNSET,
|
||||
.stoppaint_force = UNSET,
|
||||
.dbus = false,
|
||||
.benchmark = 0,
|
||||
.benchmark_wid = XCB_NONE,
|
||||
.logpath = NULL,
|
||||
|
||||
.use_damage = true,
|
||||
|
||||
.shadow_red = 0.0,
|
||||
.shadow_green = 0.0,
|
||||
.shadow_blue = 0.0,
|
||||
.shadow_radius = 18,
|
||||
.shadow_offset_x = -15,
|
||||
.shadow_offset_y = -15,
|
||||
.shadow_opacity = .75,
|
||||
.shadow_blacklist = NULL,
|
||||
.shadow_ignore_shaped = false,
|
||||
.xinerama_shadow_crop = false,
|
||||
.shadow_clip_list = NULL,
|
||||
|
||||
.corner_radius = 0,
|
||||
|
||||
.fade_in_step = 0.028,
|
||||
.fade_out_step = 0.03,
|
||||
.fade_delta = 10,
|
||||
.no_fading_openclose = false,
|
||||
.no_fading_destroyed_argb = false,
|
||||
.fade_blacklist = NULL,
|
||||
|
||||
.animations = false,
|
||||
.animation_for_open_window = OPEN_WINDOW_ANIMATION_NONE,
|
||||
.animation_for_transient_window = OPEN_WINDOW_ANIMATION_NONE,
|
||||
.animation_for_unmap_window = OPEN_WINDOW_ANIMATION_AUTO,
|
||||
.animation_for_workspace_switch_in = OPEN_WINDOW_ANIMATION_AUTO,
|
||||
.animation_for_workspace_switch_out = OPEN_WINDOW_ANIMATION_AUTO,
|
||||
.animation_stiffness = 200.0,
|
||||
.animation_window_mass = 1.0,
|
||||
.animation_dampening = 25,
|
||||
.animation_delta = 10,
|
||||
.animation_force_steps = false,
|
||||
.animation_clamping = true,
|
||||
.animation_blacklist = NULL,
|
||||
|
||||
.inactive_opacity = 1.0,
|
||||
.inactive_opacity_override = false,
|
||||
.active_opacity = 1.0,
|
||||
.frame_opacity = 1.0,
|
||||
.detect_client_opacity = false,
|
||||
|
||||
.blur_method = BLUR_METHOD_NONE,
|
||||
.blur_radius = 3,
|
||||
.blur_deviation = 0.84089642,
|
||||
.blur_strength = 5,
|
||||
.blur_background_frame = false,
|
||||
.blur_background_fixed = false,
|
||||
.blur_background_blacklist = NULL,
|
||||
.blur_kerns = NULL,
|
||||
.blur_kernel_count = 0,
|
||||
.inactive_dim = 0.0,
|
||||
.inactive_dim_fixed = false,
|
||||
.invert_color_list = NULL,
|
||||
.opacity_rules = NULL,
|
||||
.max_brightness = 1.0,
|
||||
|
||||
.use_ewmh_active_win = false,
|
||||
.focus_blacklist = NULL,
|
||||
.detect_transient = false,
|
||||
.detect_client_leader = false,
|
||||
.no_ewmh_fullscreen = false,
|
||||
|
||||
.track_leader = false,
|
||||
|
||||
.rounded_corners_blacklist = NULL
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
char *ret = NULL;
|
||||
#ifdef CONFIG_LIBCONFIG
|
||||
ret = parse_config_libconfig(opt, config_file, shadow_enable, fading_enable,
|
||||
hasneg, winopt_mask);
|
||||
#else
|
||||
(void)config_file;
|
||||
(void)shadow_enable;
|
||||
(void)fading_enable;
|
||||
(void)hasneg;
|
||||
(void)winopt_mask;
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,378 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
// Copyright (c) 2013 Richard Grenville <pyxlcy@gmail.com>
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
|
||||
/// Common functions and definitions for configuration parsing
|
||||
/// Used for command line arguments and config files
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <xcb/render.h> // for xcb_render_fixed_t, XXX
|
||||
#include <xcb/xcb.h>
|
||||
#include <xcb/xfixes.h>
|
||||
|
||||
#ifdef CONFIG_LIBCONFIG
|
||||
#include <libconfig.h>
|
||||
#endif
|
||||
|
||||
#include "compiler.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "types.h"
|
||||
#include "win_defs.h"
|
||||
|
||||
typedef struct session session_t;
|
||||
|
||||
/// @brief Possible backends
|
||||
enum backend {
|
||||
BKEND_XRENDER,
|
||||
BKEND_GLX,
|
||||
BKEND_XR_GLX_HYBRID,
|
||||
BKEND_DUMMY,
|
||||
NUM_BKEND,
|
||||
};
|
||||
|
||||
enum open_window_animation {
|
||||
OPEN_WINDOW_ANIMATION_NONE = 0,
|
||||
OPEN_WINDOW_ANIMATION_AUTO,
|
||||
OPEN_WINDOW_ANIMATION_FLYIN,
|
||||
OPEN_WINDOW_ANIMATION_ZOOM,
|
||||
OPEN_WINDOW_ANIMATION_SQUEEZE,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_UP,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_DOWN,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_LEFT,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_RIGHT,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_IN,
|
||||
OPEN_WINDOW_ANIMATION_SLIDE_OUT,
|
||||
OPEN_WINDOW_ANIMATION_INVALID,
|
||||
};
|
||||
|
||||
typedef struct win_option_mask {
|
||||
bool shadow : 1;
|
||||
bool fade : 1;
|
||||
bool focus : 1;
|
||||
bool blur_background : 1;
|
||||
bool full_shadow : 1;
|
||||
bool redir_ignore : 1;
|
||||
bool opacity : 1;
|
||||
bool clip_shadow_above : 1;
|
||||
enum open_window_animation animation;
|
||||
enum open_window_animation animation_unmap;
|
||||
enum open_window_animation animation_workspace_in;
|
||||
enum open_window_animation animation_workspace_out;
|
||||
} win_option_mask_t;
|
||||
|
||||
typedef struct win_option {
|
||||
bool shadow;
|
||||
bool fade;
|
||||
bool focus;
|
||||
bool blur_background;
|
||||
bool full_shadow;
|
||||
bool redir_ignore;
|
||||
double opacity;
|
||||
bool clip_shadow_above;
|
||||
enum open_window_animation animation;
|
||||
enum open_window_animation animation_unmap;
|
||||
enum open_window_animation animation_workspace_in;
|
||||
enum open_window_animation animation_workspace_out;
|
||||
} win_option_t;
|
||||
|
||||
enum blur_method {
|
||||
BLUR_METHOD_NONE = 0,
|
||||
BLUR_METHOD_KERNEL,
|
||||
BLUR_METHOD_BOX,
|
||||
BLUR_METHOD_GAUSSIAN,
|
||||
BLUR_METHOD_DUAL_KAWASE,
|
||||
BLUR_METHOD_INVALID,
|
||||
};
|
||||
|
||||
typedef struct _c2_lptr c2_lptr_t;
|
||||
|
||||
/// Structure representing all options.
|
||||
typedef struct options {
|
||||
// === Debugging ===
|
||||
bool monitor_repaint;
|
||||
bool print_diagnostics;
|
||||
/// Render to a separate window instead of taking over the screen
|
||||
bool debug_mode;
|
||||
// === General ===
|
||||
/// Use the experimental new backends?
|
||||
bool experimental_backends;
|
||||
/// Path to write PID to.
|
||||
char *write_pid_path;
|
||||
/// The backend in use.
|
||||
enum backend backend;
|
||||
/// Whether to sync X drawing with X Sync fence to avoid certain delay
|
||||
/// issues with GLX backend.
|
||||
bool xrender_sync_fence;
|
||||
/// Whether to avoid using stencil buffer under GLX backend. Might be
|
||||
/// unsafe.
|
||||
bool glx_no_stencil;
|
||||
/// Whether to avoid rebinding pixmap on window damage.
|
||||
bool glx_no_rebind_pixmap;
|
||||
/// Custom fragment shader for painting windows, as a string.
|
||||
char *glx_fshader_win_str;
|
||||
/// Whether to detect rounded corners.
|
||||
bool detect_rounded_corners;
|
||||
/// Force painting of window content with blending.
|
||||
bool force_win_blend;
|
||||
/// Resize damage for a specific number of pixels.
|
||||
int resize_damage;
|
||||
/// Whether to unredirect all windows if a full-screen opaque window
|
||||
/// is detected.
|
||||
bool unredir_if_possible;
|
||||
/// List of conditions of windows to ignore as a full-screen window
|
||||
/// when determining if a window could be unredirected.
|
||||
c2_lptr_t *unredir_if_possible_blacklist;
|
||||
/// Delay before unredirecting screen, in milliseconds.
|
||||
long unredir_if_possible_delay;
|
||||
/// Forced redirection setting through D-Bus.
|
||||
switch_t redirected_force;
|
||||
/// Whether to stop painting. Controlled through D-Bus.
|
||||
switch_t stoppaint_force;
|
||||
/// Whether to enable D-Bus support.
|
||||
bool dbus;
|
||||
/// Path to log file.
|
||||
char *logpath;
|
||||
/// Number of cycles to paint in benchmark mode. 0 for disabled.
|
||||
int benchmark;
|
||||
/// Window to constantly repaint in benchmark mode. 0 for full-screen.
|
||||
xcb_window_t benchmark_wid;
|
||||
/// A list of conditions of windows not to paint.
|
||||
c2_lptr_t *paint_blacklist;
|
||||
/// Whether to show all X errors.
|
||||
bool show_all_xerrors;
|
||||
/// Whether to avoid acquiring X Selection.
|
||||
bool no_x_selection;
|
||||
/// Window type option override.
|
||||
win_option_t wintype_option[NUM_WINTYPES];
|
||||
|
||||
// === VSync & software optimization ===
|
||||
/// VSync method to use;
|
||||
bool vsync;
|
||||
/// Whether to use glFinish() instead of glFlush() for (possibly) better
|
||||
/// VSync yet probably higher CPU usage.
|
||||
bool vsync_use_glfinish;
|
||||
/// Whether use damage information to help limit the area to paint
|
||||
bool use_damage;
|
||||
|
||||
// === Shadow ===
|
||||
/// Red, green and blue tone of the shadow.
|
||||
double shadow_red, shadow_green, shadow_blue;
|
||||
int shadow_radius;
|
||||
int shadow_offset_x, shadow_offset_y;
|
||||
double shadow_opacity;
|
||||
/// argument string to shadow-exclude-reg option
|
||||
char *shadow_exclude_reg_str;
|
||||
/// Shadow blacklist. A linked list of conditions.
|
||||
c2_lptr_t *shadow_blacklist;
|
||||
/// Whether bounding-shaped window should be ignored.
|
||||
bool shadow_ignore_shaped;
|
||||
/// Whether to crop shadow to the very Xinerama screen.
|
||||
bool xinerama_shadow_crop;
|
||||
/// Don't draw shadow over these windows. A linked list of conditions.
|
||||
c2_lptr_t *shadow_clip_list;
|
||||
|
||||
// === Fading ===
|
||||
/// How much to fade in in a single fading step.
|
||||
double fade_in_step;
|
||||
/// How much to fade out in a single fading step.
|
||||
double fade_out_step;
|
||||
/// Fading time delta. In milliseconds.
|
||||
int fade_delta;
|
||||
/// Whether to disable fading on window open/close.
|
||||
bool no_fading_openclose;
|
||||
/// Whether to disable fading on ARGB managed destroyed windows.
|
||||
bool no_fading_destroyed_argb;
|
||||
/// Fading blacklist. A linked list of conditions.
|
||||
c2_lptr_t *fade_blacklist;
|
||||
|
||||
// === Animations ===
|
||||
/// Whether to do window animations
|
||||
bool animations;
|
||||
/// Which animation to run when opening a window
|
||||
enum open_window_animation animation_for_open_window;
|
||||
/// Which animation to run when opening a transient window
|
||||
enum open_window_animation animation_for_transient_window;
|
||||
/// Which animation to run when unmapping (e.g. minimizing) a window
|
||||
enum open_window_animation animation_for_unmap_window;
|
||||
/// Which animation to run when switching workspace
|
||||
/// IMPORTANT: will only work if window manager updates
|
||||
/// _NET_CURRENT_DESKTOP before doing the hide/show of windows
|
||||
enum open_window_animation animation_for_workspace_switch_in;
|
||||
enum open_window_animation animation_for_workspace_switch_out;
|
||||
/// Spring stiffness for animation
|
||||
double animation_stiffness;
|
||||
/// Window mass for animation
|
||||
double animation_window_mass;
|
||||
/// Animation dampening
|
||||
double animation_dampening;
|
||||
/// Animation delta. In milliseconds.
|
||||
double animation_delta;
|
||||
/// Whether to force animations to not miss a beat
|
||||
bool animation_force_steps;
|
||||
/// Whether to clamp animations
|
||||
bool animation_clamping;
|
||||
/// Animation blacklist. A linked list of conditions.
|
||||
c2_lptr_t *animation_blacklist;
|
||||
/// TODO: open/close animations
|
||||
|
||||
// === Opacity ===
|
||||
/// Default opacity for inactive windows.
|
||||
/// 32-bit integer with the format of _NET_WM_WINDOW_OPACITY.
|
||||
double inactive_opacity;
|
||||
/// Default opacity for inactive windows.
|
||||
double active_opacity;
|
||||
/// Whether inactive_opacity overrides the opacity set by window
|
||||
/// attributes.
|
||||
bool inactive_opacity_override;
|
||||
/// Frame opacity. Relative to window opacity, also affects shadow
|
||||
/// opacity.
|
||||
double frame_opacity;
|
||||
/// Whether to detect _NET_WM_WINDOW_OPACITY on client windows. Used on window
|
||||
/// managers that don't pass _NET_WM_WINDOW_OPACITY to frame windows.
|
||||
bool detect_client_opacity;
|
||||
|
||||
// === Other window processing ===
|
||||
/// Blur method for background of semi-transparent windows
|
||||
enum blur_method blur_method;
|
||||
// Size of the blur kernel
|
||||
int blur_radius;
|
||||
// Standard deviation for the gaussian blur
|
||||
double blur_deviation;
|
||||
// Strength of the dual_kawase blur
|
||||
int blur_strength;
|
||||
/// Whether to blur background when the window frame is not opaque.
|
||||
/// Implies blur_background.
|
||||
bool blur_background_frame;
|
||||
/// Whether to use fixed blur strength instead of adjusting according
|
||||
/// to window opacity.
|
||||
bool blur_background_fixed;
|
||||
/// Background blur blacklist. A linked list of conditions.
|
||||
c2_lptr_t *blur_background_blacklist;
|
||||
/// Blur convolution kernel.
|
||||
struct conv **blur_kerns;
|
||||
/// Number of convolution kernels
|
||||
int blur_kernel_count;
|
||||
/// How much to dim an inactive window. 0.0 - 1.0, 0 to disable.
|
||||
double inactive_dim;
|
||||
/// Whether to use fixed inactive dim opacity, instead of deciding
|
||||
/// based on window opacity.
|
||||
bool inactive_dim_fixed;
|
||||
/// Conditions of windows to have inverted colors.
|
||||
c2_lptr_t *invert_color_list;
|
||||
/// Rules to change window opacity.
|
||||
c2_lptr_t *opacity_rules;
|
||||
/// Limit window brightness
|
||||
double max_brightness;
|
||||
// Radius of rounded window corners
|
||||
int corner_radius;
|
||||
/// Rounded corners blacklist. A linked list of conditions.
|
||||
c2_lptr_t *rounded_corners_blacklist;
|
||||
|
||||
// === Focus related ===
|
||||
/// Whether to try to detect WM windows and mark them as focused.
|
||||
bool mark_wmwin_focused;
|
||||
/// Whether to mark override-redirect windows as focused.
|
||||
bool mark_ovredir_focused;
|
||||
/// Whether to use EWMH _NET_ACTIVE_WINDOW to find active window.
|
||||
bool use_ewmh_active_win;
|
||||
/// A list of windows always to be considered focused.
|
||||
c2_lptr_t *focus_blacklist;
|
||||
/// Whether to do window grouping with <code>WM_TRANSIENT_FOR</code>.
|
||||
bool detect_transient;
|
||||
/// Whether to do window grouping with <code>WM_CLIENT_LEADER</code>.
|
||||
bool detect_client_leader;
|
||||
|
||||
// === Calculated ===
|
||||
/// Whether we need to track window leaders.
|
||||
bool track_leader;
|
||||
|
||||
// Don't use EWMH to detect fullscreen applications
|
||||
bool no_ewmh_fullscreen;
|
||||
|
||||
// Make transparent windows clip other windows, instead of blending on top of
|
||||
// them
|
||||
bool transparent_clipping;
|
||||
} options_t;
|
||||
|
||||
extern const char *const BACKEND_STRS[NUM_BKEND + 1];
|
||||
|
||||
bool must_use parse_long(const char *, long *);
|
||||
bool must_use parse_int(const char *, int *);
|
||||
struct conv **must_use parse_blur_kern_lst(const char *, bool *hasneg, int *count);
|
||||
bool must_use parse_geometry(session_t *, const char *, region_t *);
|
||||
bool must_use parse_rule_opacity(c2_lptr_t **, const char *);
|
||||
enum blur_method must_use parse_blur_method(const char *src);
|
||||
enum open_window_animation must_use parse_open_window_animation(const char *src);
|
||||
|
||||
/**
|
||||
* Add a pattern to a condition linked list.
|
||||
*/
|
||||
bool condlst_add(c2_lptr_t **, const char *);
|
||||
|
||||
#ifdef CONFIG_LIBCONFIG
|
||||
/// Parse a configuration file
|
||||
/// Returns the actually config_file name used, allocated on heap
|
||||
/// Outputs:
|
||||
/// shadow_enable = whether shaodw is enabled globally
|
||||
/// fading_enable = whether fading is enabled globally
|
||||
/// win_option_mask = whether option overrides for specific window type is set for given
|
||||
/// options
|
||||
/// hasneg = whether the convolution kernel has negative values
|
||||
char *
|
||||
parse_config_libconfig(options_t *, const char *config_file, bool *shadow_enable,
|
||||
bool *fading_enable, bool *hasneg, win_option_mask_t *winopt_mask);
|
||||
#endif
|
||||
|
||||
void set_default_winopts(options_t *, win_option_mask_t *, bool shadow_enable,
|
||||
bool fading_enable, bool blur_enable);
|
||||
/// Parse a configuration file is that is enabled, also initialize the winopt_mask with
|
||||
/// default values
|
||||
/// Outputs and returns:
|
||||
/// same as parse_config_libconfig
|
||||
char *parse_config(options_t *, const char *config_file, bool *shadow_enable,
|
||||
bool *fading_enable, bool *hasneg, win_option_mask_t *winopt_mask);
|
||||
|
||||
/**
|
||||
* Parse a backend option argument.
|
||||
*/
|
||||
static inline attr_pure enum backend parse_backend(const char *str) {
|
||||
for (enum backend i = 0; BACKEND_STRS[i]; ++i) {
|
||||
if (!strcasecmp(str, BACKEND_STRS[i])) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// Keep compatibility with an old revision containing a spelling mistake...
|
||||
if (!strcasecmp(str, "xr_glx_hybird")) {
|
||||
log_warn("backend xr_glx_hybird should be xr_glx_hybrid, the misspelt "
|
||||
"version will be removed soon.");
|
||||
return BKEND_XR_GLX_HYBRID;
|
||||
}
|
||||
// cju wants to use dashes
|
||||
if (!strcasecmp(str, "xr-glx-hybrid")) {
|
||||
log_warn("backend xr-glx-hybrid should be xr_glx_hybrid, the alternative "
|
||||
"version will be removed soon.");
|
||||
return BKEND_XR_GLX_HYBRID;
|
||||
}
|
||||
log_error("Invalid backend argument: %s", str);
|
||||
return NUM_BKEND;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a VSync option argument.
|
||||
*/
|
||||
static inline bool parse_vsync(const char *str) {
|
||||
if (strcmp(str, "no") == 0 || strcmp(str, "none") == 0 ||
|
||||
strcmp(str, "false") == 0 || strcmp(str, "nah") == 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,767 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// Copyright (c) 2012-2014 Richard Grenville <pyxlcy@gmail.com>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <libconfig.h>
|
||||
#include <libgen.h>
|
||||
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "err.h"
|
||||
#include "log.h"
|
||||
#include "options.h"
|
||||
#include "string_utils.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
|
||||
#pragma GCC diagnostic error "-Wunused-parameter"
|
||||
|
||||
/**
|
||||
* Wrapper of libconfig's <code>config_lookup_int</code>.
|
||||
*
|
||||
* So it takes a pointer to bool.
|
||||
*/
|
||||
static inline int lcfg_lookup_bool(const config_t *config, const char *path, bool *value) {
|
||||
int ival;
|
||||
|
||||
int ret = config_lookup_bool(config, path, &ival);
|
||||
if (ret) {
|
||||
*value = ival;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
const char *xdg_config_home(void) {
|
||||
char *xdgh = getenv("XDG_CONFIG_HOME");
|
||||
char *home = getenv("HOME");
|
||||
const char *default_dir = "/.config";
|
||||
|
||||
if (!xdgh) {
|
||||
if (!home) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
xdgh = cvalloc(strlen(home) + strlen(default_dir) + 1);
|
||||
|
||||
strcpy(xdgh, home);
|
||||
strcat(xdgh, default_dir);
|
||||
} else {
|
||||
xdgh = strdup(xdgh);
|
||||
}
|
||||
|
||||
return xdgh;
|
||||
}
|
||||
|
||||
char **xdg_config_dirs(void) {
|
||||
char *xdgd = getenv("XDG_CONFIG_DIRS");
|
||||
size_t count = 0;
|
||||
|
||||
if (!xdgd) {
|
||||
xdgd = "/etc/xdg";
|
||||
}
|
||||
|
||||
for (int i = 0; xdgd[i]; i++) {
|
||||
if (xdgd[i] == ':') {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Store the string and the result pointers together so they can be
|
||||
// freed together
|
||||
char **dir_list = cvalloc(sizeof(char *) * (count + 2) + strlen(xdgd) + 1);
|
||||
auto dirs = strcpy((char *)dir_list + sizeof(char *) * (count + 2), xdgd);
|
||||
auto path = dirs;
|
||||
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
dir_list[i] = path;
|
||||
path = strchr(path, ':');
|
||||
*path = '\0';
|
||||
path++;
|
||||
}
|
||||
dir_list[count] = path;
|
||||
|
||||
size_t fill = 0;
|
||||
for (size_t i = 0; i <= count; i++) {
|
||||
if (dir_list[i][0] == '/') {
|
||||
dir_list[fill] = dir_list[i];
|
||||
fill++;
|
||||
}
|
||||
}
|
||||
|
||||
dir_list[fill] = NULL;
|
||||
|
||||
return dir_list;
|
||||
}
|
||||
|
||||
TEST_CASE(xdg_config_dirs) {
|
||||
auto old_var = getenv("XDG_CONFIG_DIRS");
|
||||
if (old_var) {
|
||||
old_var = strdup(old_var);
|
||||
}
|
||||
unsetenv("XDG_CONFIG_DIRS");
|
||||
|
||||
auto result = xdg_config_dirs();
|
||||
TEST_STREQUAL(result[0], "/etc/xdg");
|
||||
TEST_EQUAL(result[1], NULL);
|
||||
free(result);
|
||||
|
||||
setenv("XDG_CONFIG_DIRS", ".:.:/etc/xdg:.:/:", 1);
|
||||
result = xdg_config_dirs();
|
||||
TEST_STREQUAL(result[0], "/etc/xdg");
|
||||
TEST_STREQUAL(result[1], "/");
|
||||
TEST_EQUAL(result[2], NULL);
|
||||
free(result);
|
||||
|
||||
setenv("XDG_CONFIG_DIRS", ":", 1);
|
||||
result = xdg_config_dirs();
|
||||
TEST_EQUAL(result[0], NULL);
|
||||
free(result);
|
||||
|
||||
if (old_var) {
|
||||
setenv("XDG_CONFIG_DIRS", old_var, 1);
|
||||
free(old_var);
|
||||
}
|
||||
}
|
||||
|
||||
/// Search for config file under a base directory
|
||||
FILE *open_config_file_at(const char *base, char **out_path) {
|
||||
static const char *config_paths[] = {"/picom.conf", "/picom/picom.conf",
|
||||
"/compton.conf", "/compton/compton.conf"};
|
||||
for (size_t i = 0; i < ARR_SIZE(config_paths); i++) {
|
||||
char *path = mstrjoin(base, config_paths[i]);
|
||||
FILE *ret = fopen(path, "r");
|
||||
if (ret && out_path) {
|
||||
*out_path = path;
|
||||
} else {
|
||||
free(path);
|
||||
}
|
||||
if (ret) {
|
||||
if (strstr(config_paths[i], "compton")) {
|
||||
log_warn("This compositor has been renamed to \"picom\", "
|
||||
"the old config file paths is deprecated. "
|
||||
"Please replace the \"compton\"s in the path "
|
||||
"with \"picom\"");
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a file stream of the configuration file to read.
|
||||
*
|
||||
* Follows the XDG specification to search for the configuration file.
|
||||
*/
|
||||
FILE *open_config_file(const char *cpath, char **ppath) {
|
||||
static const char config_filename_legacy[] = "/.compton.conf";
|
||||
|
||||
if (cpath) {
|
||||
FILE *ret = fopen(cpath, "r");
|
||||
if (ret && ppath)
|
||||
*ppath = strdup(cpath);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// First search for config file in user config directory
|
||||
auto config_home = xdg_config_home();
|
||||
auto ret = open_config_file_at(config_home, ppath);
|
||||
free((void *)config_home);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Fall back to legacy config file in user home directory
|
||||
const char *home = getenv("HOME");
|
||||
if (home && strlen(home)) {
|
||||
auto path = mstrjoin(home, config_filename_legacy);
|
||||
ret = fopen(path, "r");
|
||||
if (ret && ppath) {
|
||||
*ppath = path;
|
||||
} else {
|
||||
free(path);
|
||||
}
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
// Fall back to config file in system config directory
|
||||
auto config_dirs = xdg_config_dirs();
|
||||
for (int i = 0; config_dirs[i]; i++) {
|
||||
ret = open_config_file_at(config_dirs[i], ppath);
|
||||
if (ret) {
|
||||
free(config_dirs);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
free(config_dirs);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a condition list in configuration file.
|
||||
*/
|
||||
void parse_cfg_condlst(const config_t *pcfg, c2_lptr_t **pcondlst, const char *name) {
|
||||
config_setting_t *setting = config_lookup(pcfg, name);
|
||||
if (setting) {
|
||||
// Parse an array of options
|
||||
if (config_setting_is_array(setting)) {
|
||||
int i = config_setting_length(setting);
|
||||
while (i--)
|
||||
condlst_add(pcondlst,
|
||||
config_setting_get_string_elem(setting, i));
|
||||
}
|
||||
// Treat it as a single pattern if it's a string
|
||||
else if (CONFIG_TYPE_STRING == config_setting_type(setting)) {
|
||||
condlst_add(pcondlst, config_setting_get_string(setting));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an opacity rule list in configuration file.
|
||||
*/
|
||||
static inline void
|
||||
parse_cfg_condlst_opct(options_t *opt, const config_t *pcfg, const char *name) {
|
||||
config_setting_t *setting = config_lookup(pcfg, name);
|
||||
if (setting) {
|
||||
// Parse an array of options
|
||||
if (config_setting_is_array(setting)) {
|
||||
int i = config_setting_length(setting);
|
||||
while (i--)
|
||||
if (!parse_rule_opacity(
|
||||
&opt->opacity_rules,
|
||||
config_setting_get_string_elem(setting, i)))
|
||||
exit(1);
|
||||
}
|
||||
// Treat it as a single pattern if it's a string
|
||||
else if (config_setting_type(setting) == CONFIG_TYPE_STRING) {
|
||||
if (!parse_rule_opacity(&opt->opacity_rules,
|
||||
config_setting_get_string(setting)))
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void parse_wintype_config(const config_t *cfg, const char *member_name,
|
||||
win_option_t *o, win_option_mask_t *mask) {
|
||||
char *str = mstrjoin("wintypes.", member_name);
|
||||
const config_setting_t *setting = config_lookup(cfg, str);
|
||||
free(str);
|
||||
|
||||
int ival = 0;
|
||||
const char *sval = NULL;
|
||||
|
||||
if (setting) {
|
||||
if (config_setting_lookup_bool(setting, "shadow", &ival)) {
|
||||
o->shadow = ival;
|
||||
mask->shadow = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "fade", &ival)) {
|
||||
o->fade = ival;
|
||||
mask->fade = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "focus", &ival)) {
|
||||
o->focus = ival;
|
||||
mask->focus = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "blur-background", &ival)) {
|
||||
o->blur_background = ival;
|
||||
mask->blur_background = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "full-shadow", &ival)) {
|
||||
o->full_shadow = ival;
|
||||
mask->full_shadow = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "redir-ignore", &ival)) {
|
||||
o->redir_ignore = ival;
|
||||
mask->redir_ignore = true;
|
||||
}
|
||||
if (config_setting_lookup_bool(setting, "clip-shadow-above", &ival)) {
|
||||
o->clip_shadow_above = ival;
|
||||
mask->clip_shadow_above = true;
|
||||
}
|
||||
if (config_setting_lookup_string(setting, "animation", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID)
|
||||
animation = OPEN_WINDOW_ANIMATION_NONE;
|
||||
|
||||
o->animation = animation;
|
||||
mask->animation = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (config_setting_lookup_string(setting, "animation-unmap", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID)
|
||||
animation = OPEN_WINDOW_ANIMATION_NONE;
|
||||
|
||||
o->animation_unmap = animation;
|
||||
mask->animation_unmap = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (config_setting_lookup_string(setting, "animation-workspace-in", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID)
|
||||
animation = OPEN_WINDOW_ANIMATION_NONE;
|
||||
|
||||
o->animation_workspace_in = animation;
|
||||
mask->animation_workspace_in = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
if (config_setting_lookup_string(setting, "animation-workspace-out", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID)
|
||||
animation = OPEN_WINDOW_ANIMATION_NONE;
|
||||
|
||||
o->animation_workspace_out = animation;
|
||||
mask->animation_workspace_out = OPEN_WINDOW_ANIMATION_INVALID;
|
||||
}
|
||||
|
||||
double fval;
|
||||
if (config_setting_lookup_float(setting, "opacity", &fval)) {
|
||||
o->opacity = normalize_d(fval);
|
||||
mask->opacity = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a configuration file from default location.
|
||||
*
|
||||
* Returns the actually config_file name
|
||||
*/
|
||||
char *parse_config_libconfig(options_t *opt, const char *config_file, bool *shadow_enable,
|
||||
bool *fading_enable, bool *conv_kern_hasneg,
|
||||
win_option_mask_t *winopt_mask) {
|
||||
|
||||
const char *deprecation_message =
|
||||
"option has been deprecated. Please remove it from your configuration file. "
|
||||
"If you encounter any problems without this feature, please feel free to "
|
||||
"open a bug report";
|
||||
char *path = NULL;
|
||||
FILE *f;
|
||||
config_t cfg;
|
||||
int ival = 0;
|
||||
bool bval;
|
||||
double dval = 0.0;
|
||||
// libconfig manages string memory itself, so no need to manually free
|
||||
// anything
|
||||
const char *sval = NULL;
|
||||
|
||||
f = open_config_file(config_file, &path);
|
||||
if (!f) {
|
||||
free(path);
|
||||
if (config_file) {
|
||||
log_fatal("Failed to read configuration file \"%s\".", config_file);
|
||||
return ERR_PTR(-1);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
config_init(&cfg);
|
||||
#ifdef CONFIG_OPTION_ALLOW_OVERRIDES
|
||||
config_set_options(&cfg, CONFIG_OPTION_ALLOW_OVERRIDES);
|
||||
#endif
|
||||
{
|
||||
// dirname() could modify the original string, thus we must pass a
|
||||
// copy
|
||||
char *path2 = strdup(path);
|
||||
char *parent = dirname(path2);
|
||||
|
||||
if (parent)
|
||||
config_set_include_dir(&cfg, parent);
|
||||
|
||||
free(path2);
|
||||
}
|
||||
|
||||
{
|
||||
int read_result = config_read(&cfg, f);
|
||||
fclose(f);
|
||||
f = NULL;
|
||||
if (read_result == CONFIG_FALSE) {
|
||||
log_fatal("Error when reading configuration file \"%s\", line "
|
||||
"%d: %s",
|
||||
path, config_error_line(&cfg), config_error_text(&cfg));
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
config_set_auto_convert(&cfg, 1);
|
||||
|
||||
// Get options from the configuration file. We don't do range checking
|
||||
// right now. It will be done later
|
||||
|
||||
// --dbus
|
||||
lcfg_lookup_bool(&cfg, "dbus", &opt->dbus);
|
||||
|
||||
// -D (fade_delta)
|
||||
if (config_lookup_int(&cfg, "fade-delta", &ival)) {
|
||||
opt->fade_delta = ival;
|
||||
}
|
||||
// -I (fade_in_step)
|
||||
if (config_lookup_float(&cfg, "fade-in-step", &dval)) {
|
||||
opt->fade_in_step = normalize_d(dval);
|
||||
}
|
||||
// -O (fade_out_step)
|
||||
if (config_lookup_float(&cfg, "fade-out-step", &dval)) {
|
||||
opt->fade_out_step = normalize_d(dval);
|
||||
}
|
||||
// -r (shadow_radius)
|
||||
config_lookup_int(&cfg, "shadow-radius", &opt->shadow_radius);
|
||||
// -o (shadow_opacity)
|
||||
config_lookup_float(&cfg, "shadow-opacity", &opt->shadow_opacity);
|
||||
// -l (shadow_offset_x)
|
||||
config_lookup_int(&cfg, "shadow-offset-x", &opt->shadow_offset_x);
|
||||
// -t (shadow_offset_y)
|
||||
config_lookup_int(&cfg, "shadow-offset-y", &opt->shadow_offset_y);
|
||||
// -i (inactive_opacity)
|
||||
if (config_lookup_float(&cfg, "inactive-opacity", &dval)) {
|
||||
opt->inactive_opacity = normalize_d(dval);
|
||||
}
|
||||
// --active_opacity
|
||||
if (config_lookup_float(&cfg, "active-opacity", &dval)) {
|
||||
opt->active_opacity = normalize_d(dval);
|
||||
}
|
||||
// --corner-radius
|
||||
config_lookup_int(&cfg, "corner-radius", &opt->corner_radius);
|
||||
// --rounded-corners-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->rounded_corners_blacklist, "rounded-corners-exclude");
|
||||
// -e (frame_opacity)
|
||||
config_lookup_float(&cfg, "frame-opacity", &opt->frame_opacity);
|
||||
// -c (shadow_enable)
|
||||
lcfg_lookup_bool(&cfg, "shadow", shadow_enable);
|
||||
// -m (menu_opacity)
|
||||
if (config_lookup_float(&cfg, "menu-opacity", &dval)) {
|
||||
log_warn("Option `menu-opacity` is deprecated, and will be removed."
|
||||
"Please use the wintype option `opacity` of `popup_menu`"
|
||||
"and `dropdown_menu` instead.");
|
||||
opt->wintype_option[WINTYPE_DROPDOWN_MENU].opacity = dval;
|
||||
opt->wintype_option[WINTYPE_POPUP_MENU].opacity = dval;
|
||||
winopt_mask[WINTYPE_DROPDOWN_MENU].opacity = true;
|
||||
winopt_mask[WINTYPE_POPUP_MENU].opacity = true;
|
||||
}
|
||||
// -f (fading_enable)
|
||||
if (config_lookup_bool(&cfg, "fading", &ival))
|
||||
*fading_enable = ival;
|
||||
// --no-fading-open-close
|
||||
lcfg_lookup_bool(&cfg, "no-fading-openclose", &opt->no_fading_openclose);
|
||||
// --no-fading-destroyed-argb
|
||||
lcfg_lookup_bool(&cfg, "no-fading-destroyed-argb", &opt->no_fading_destroyed_argb);
|
||||
// --shadow-red
|
||||
config_lookup_float(&cfg, "shadow-red", &opt->shadow_red);
|
||||
// --shadow-green
|
||||
config_lookup_float(&cfg, "shadow-green", &opt->shadow_green);
|
||||
// --shadow-blue
|
||||
config_lookup_float(&cfg, "shadow-blue", &opt->shadow_blue);
|
||||
// --shadow-color
|
||||
if (config_lookup_string(&cfg, "shadow-color", &sval)) {
|
||||
struct color rgb;
|
||||
rgb = hex_to_rgb(sval);
|
||||
opt->shadow_red = rgb.red;
|
||||
opt->shadow_green = rgb.green;
|
||||
opt->shadow_blue = rgb.blue;
|
||||
}
|
||||
// --shadow-exclude-reg
|
||||
if (config_lookup_string(&cfg, "shadow-exclude-reg", &sval))
|
||||
opt->shadow_exclude_reg_str = strdup(sval);
|
||||
// --inactive-opacity-override
|
||||
lcfg_lookup_bool(&cfg, "inactive-opacity-override", &opt->inactive_opacity_override);
|
||||
// --inactive-dim
|
||||
config_lookup_float(&cfg, "inactive-dim", &opt->inactive_dim);
|
||||
// --mark-wmwin-focused
|
||||
lcfg_lookup_bool(&cfg, "mark-wmwin-focused", &opt->mark_wmwin_focused);
|
||||
// --mark-ovredir-focused
|
||||
lcfg_lookup_bool(&cfg, "mark-ovredir-focused", &opt->mark_ovredir_focused);
|
||||
// --shadow-ignore-shaped
|
||||
lcfg_lookup_bool(&cfg, "shadow-ignore-shaped", &opt->shadow_ignore_shaped);
|
||||
// --detect-rounded-corners
|
||||
lcfg_lookup_bool(&cfg, "detect-rounded-corners", &opt->detect_rounded_corners);
|
||||
// --xinerama-shadow-crop
|
||||
lcfg_lookup_bool(&cfg, "xinerama-shadow-crop", &opt->xinerama_shadow_crop);
|
||||
// --detect-client-opacity
|
||||
lcfg_lookup_bool(&cfg, "detect-client-opacity", &opt->detect_client_opacity);
|
||||
// --refresh-rate
|
||||
if (config_lookup_int(&cfg, "refresh-rate", &ival)) {
|
||||
log_warn("The refresh-rate %s", deprecation_message);
|
||||
}
|
||||
// --vsync
|
||||
if (config_lookup_string(&cfg, "vsync", &sval)) {
|
||||
bool parsed_vsync = parse_vsync(sval);
|
||||
log_error("vsync option will take a boolean from now on. \"%s\" in "
|
||||
"your configuration should be changed to \"%s\"",
|
||||
sval, parsed_vsync ? "true" : "false");
|
||||
goto err;
|
||||
}
|
||||
lcfg_lookup_bool(&cfg, "vsync", &opt->vsync);
|
||||
// --backend
|
||||
if (config_lookup_string(&cfg, "backend", &sval)) {
|
||||
opt->backend = parse_backend(sval);
|
||||
if (opt->backend >= NUM_BKEND) {
|
||||
log_fatal("Cannot parse backend");
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
// --log-level
|
||||
if (config_lookup_string(&cfg, "log-level", &sval)) {
|
||||
auto level = string_to_log_level(sval);
|
||||
if (level == LOG_LEVEL_INVALID) {
|
||||
log_warn("Invalid log level, defaults to WARN");
|
||||
} else {
|
||||
log_set_level_tls(level);
|
||||
}
|
||||
}
|
||||
// --log-file
|
||||
if (config_lookup_string(&cfg, "log-file", &sval)) {
|
||||
if (*sval != '/') {
|
||||
log_warn("The log-file in your configuration file is not an "
|
||||
"absolute path");
|
||||
}
|
||||
opt->logpath = strdup(sval);
|
||||
}
|
||||
// --sw-opti
|
||||
if (lcfg_lookup_bool(&cfg, "sw-opti", &bval)) {
|
||||
log_warn("The sw-opti %s", deprecation_message);
|
||||
}
|
||||
// --use-ewmh-active-win
|
||||
lcfg_lookup_bool(&cfg, "use-ewmh-active-win", &opt->use_ewmh_active_win);
|
||||
// --unredir-if-possible
|
||||
lcfg_lookup_bool(&cfg, "unredir-if-possible", &opt->unredir_if_possible);
|
||||
// --unredir-if-possible-delay
|
||||
if (config_lookup_int(&cfg, "unredir-if-possible-delay", &ival)) {
|
||||
if (ival < 0) {
|
||||
log_warn("Invalid unredir-if-possible-delay %d", ival);
|
||||
} else {
|
||||
opt->unredir_if_possible_delay = ival;
|
||||
}
|
||||
}
|
||||
// --inactive-dim-fixed
|
||||
lcfg_lookup_bool(&cfg, "inactive-dim-fixed", &opt->inactive_dim_fixed);
|
||||
// --detect-transient
|
||||
lcfg_lookup_bool(&cfg, "detect-transient", &opt->detect_transient);
|
||||
// --detect-client-leader
|
||||
lcfg_lookup_bool(&cfg, "detect-client-leader", &opt->detect_client_leader);
|
||||
// --no-ewmh-fullscreen
|
||||
lcfg_lookup_bool(&cfg, "no-ewmh-fullscreen", &opt->no_ewmh_fullscreen);
|
||||
// --transparent-clipping
|
||||
lcfg_lookup_bool(&cfg, "transparent-clipping", &opt->transparent_clipping);
|
||||
// --shadow-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->shadow_blacklist, "shadow-exclude");
|
||||
// --clip-shadow-above
|
||||
parse_cfg_condlst(&cfg, &opt->shadow_clip_list, "clip-shadow-above");
|
||||
// --fade-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->fade_blacklist, "fade-exclude");
|
||||
// --animations
|
||||
lcfg_lookup_bool(&cfg, "animations", &opt->animations);
|
||||
// --animation-for-open-window
|
||||
if (config_lookup_string(&cfg, "animation-for-open-window", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID) {
|
||||
log_fatal("Invalid open-window animation %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->animation_for_open_window = animation;
|
||||
}
|
||||
// --animation-for-transient-window
|
||||
if (config_lookup_string(&cfg, "animation-for-transient-window", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID) {
|
||||
log_fatal("Invalid transient-window animation %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->animation_for_transient_window = animation;
|
||||
}
|
||||
// --animation-for-unmap-window
|
||||
if (config_lookup_string(&cfg, "animation-for-unmap-window", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID) {
|
||||
log_fatal("Invalid unmap-window animation %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->animation_for_unmap_window = animation;
|
||||
}
|
||||
// --animation-for-workspace-switch-in
|
||||
if (config_lookup_string(&cfg, "animation-for-workspace-switch-in", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID) {
|
||||
log_fatal("Invalid workspace-switch-in animation %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->animation_for_workspace_switch_in = animation;
|
||||
}
|
||||
// --animation-for-workspace-switch-out
|
||||
if (config_lookup_string(&cfg, "animation-for-workspace-switch-out", &sval)) {
|
||||
enum open_window_animation animation = parse_open_window_animation(sval);
|
||||
if (animation >= OPEN_WINDOW_ANIMATION_INVALID) {
|
||||
log_fatal("Invalid workspace-switch-out animation %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->animation_for_workspace_switch_out = animation;
|
||||
}
|
||||
// --animation-stiffness
|
||||
config_lookup_float(&cfg, "animation-stiffness", &opt->animation_stiffness);
|
||||
// --animation-window-mass
|
||||
config_lookup_float(&cfg, "animation-window-mass", &opt->animation_window_mass);
|
||||
// --animation-dampening
|
||||
config_lookup_float(&cfg, "animation-dampening", &opt->animation_dampening);
|
||||
// --animation-delta
|
||||
config_lookup_float(&cfg, "animation-delta", &opt->animation_delta);
|
||||
// --animation-force-steps
|
||||
lcfg_lookup_bool(&cfg, "animation-force-steps", &opt->animation_force_steps);
|
||||
// --animation-clamping
|
||||
lcfg_lookup_bool(&cfg, "animation-clamping", &opt->animation_clamping);
|
||||
// --animation-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->animation_blacklist, "animation-exclude");
|
||||
// --focus-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->focus_blacklist, "focus-exclude");
|
||||
// --invert-color-include
|
||||
parse_cfg_condlst(&cfg, &opt->invert_color_list, "invert-color-include");
|
||||
// --blur-background-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->blur_background_blacklist, "blur-background-exclude");
|
||||
// --opacity-rule
|
||||
parse_cfg_condlst_opct(opt, &cfg, "opacity-rule");
|
||||
// --unredir-if-possible-exclude
|
||||
parse_cfg_condlst(&cfg, &opt->unredir_if_possible_blacklist,
|
||||
"unredir-if-possible-exclude");
|
||||
// --blur-method
|
||||
if (config_lookup_string(&cfg, "blur-method", &sval)) {
|
||||
enum blur_method method = parse_blur_method(sval);
|
||||
if (method >= BLUR_METHOD_INVALID) {
|
||||
log_fatal("Invalid blur method %s", sval);
|
||||
goto err;
|
||||
}
|
||||
opt->blur_method = method;
|
||||
}
|
||||
// --blur-size
|
||||
config_lookup_int(&cfg, "blur-size", &opt->blur_radius);
|
||||
// --blur-deviation
|
||||
config_lookup_float(&cfg, "blur-deviation", &opt->blur_deviation);
|
||||
// --blur-strength
|
||||
config_lookup_int(&cfg, "blur-strength", &opt->blur_strength);
|
||||
// --blur-background
|
||||
if (config_lookup_bool(&cfg, "blur-background", &ival) && ival) {
|
||||
if (opt->blur_method == BLUR_METHOD_NONE) {
|
||||
opt->blur_method = BLUR_METHOD_KERNEL;
|
||||
}
|
||||
}
|
||||
// --blur-background-frame
|
||||
lcfg_lookup_bool(&cfg, "blur-background-frame", &opt->blur_background_frame);
|
||||
// --blur-background-fixed
|
||||
lcfg_lookup_bool(&cfg, "blur-background-fixed", &opt->blur_background_fixed);
|
||||
// --blur-kern
|
||||
if (config_lookup_string(&cfg, "blur-kern", &sval)) {
|
||||
opt->blur_kerns =
|
||||
parse_blur_kern_lst(sval, conv_kern_hasneg, &opt->blur_kernel_count);
|
||||
if (!opt->blur_kerns) {
|
||||
log_fatal("Cannot parse \"blur-kern\"");
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
// --resize-damage
|
||||
config_lookup_int(&cfg, "resize-damage", &opt->resize_damage);
|
||||
// --glx-no-stencil
|
||||
lcfg_lookup_bool(&cfg, "glx-no-stencil", &opt->glx_no_stencil);
|
||||
// --glx-no-rebind-pixmap
|
||||
lcfg_lookup_bool(&cfg, "glx-no-rebind-pixmap", &opt->glx_no_rebind_pixmap);
|
||||
lcfg_lookup_bool(&cfg, "force-win-blend", &opt->force_win_blend);
|
||||
// --glx-swap-method
|
||||
if (config_lookup_string(&cfg, "glx-swap-method", &sval)) {
|
||||
char *endptr;
|
||||
long val = strtol(sval, &endptr, 10);
|
||||
bool should_remove = true;
|
||||
if (*endptr || !(*sval)) {
|
||||
// sval is not a number, or an empty string
|
||||
val = -1;
|
||||
}
|
||||
if (strcmp(sval, "undefined") != 0 && val != 0) {
|
||||
// If not undefined, we will use damage and buffer-age to limit
|
||||
// the rendering area.
|
||||
should_remove = false;
|
||||
}
|
||||
log_error("glx-swap-method has been removed, your setting "
|
||||
"\"%s\" should be %s.",
|
||||
sval,
|
||||
!should_remove ? "replaced by `use-damage = true`" : "removed");
|
||||
goto err;
|
||||
}
|
||||
// --use-damage
|
||||
lcfg_lookup_bool(&cfg, "use-damage", &opt->use_damage);
|
||||
|
||||
// --max-brightness
|
||||
if (config_lookup_float(&cfg, "max-brightness", &opt->max_brightness) &&
|
||||
opt->use_damage && opt->max_brightness < 1) {
|
||||
log_warn("max-brightness requires use-damage = false. Falling back to "
|
||||
"1.0");
|
||||
opt->max_brightness = 1.0;
|
||||
}
|
||||
|
||||
// --glx-use-gpushader4
|
||||
if (config_lookup_bool(&cfg, "glx-use-gpushader4", &ival)) {
|
||||
log_error("glx-use-gpushader4 has been removed, please remove it "
|
||||
"from your config file");
|
||||
goto err;
|
||||
}
|
||||
// --xrender-sync-fence
|
||||
lcfg_lookup_bool(&cfg, "xrender-sync-fence", &opt->xrender_sync_fence);
|
||||
|
||||
if (lcfg_lookup_bool(&cfg, "clear-shadow", &bval))
|
||||
log_warn("\"clear-shadow\" is removed as an option, and is always"
|
||||
" enabled now. Consider removing it from your config file");
|
||||
|
||||
config_setting_t *blur_cfg = config_lookup(&cfg, "blur");
|
||||
if (blur_cfg) {
|
||||
if (config_setting_lookup_string(blur_cfg, "method", &sval)) {
|
||||
enum blur_method method = parse_blur_method(sval);
|
||||
if (method >= BLUR_METHOD_INVALID) {
|
||||
log_warn("Invalid blur method %s, ignoring.", sval);
|
||||
} else {
|
||||
opt->blur_method = method;
|
||||
}
|
||||
}
|
||||
|
||||
config_setting_lookup_int(blur_cfg, "size", &opt->blur_radius);
|
||||
|
||||
if (config_setting_lookup_string(blur_cfg, "kernel", &sval)) {
|
||||
opt->blur_kerns = parse_blur_kern_lst(sval, conv_kern_hasneg,
|
||||
&opt->blur_kernel_count);
|
||||
if (!opt->blur_kerns) {
|
||||
log_warn("Failed to parse blur kernel: %s", sval);
|
||||
}
|
||||
}
|
||||
|
||||
config_setting_lookup_float(blur_cfg, "deviation", &opt->blur_deviation);
|
||||
config_setting_lookup_int(blur_cfg, "strength", &opt->blur_strength);
|
||||
}
|
||||
|
||||
// --write-pid-path
|
||||
if (config_lookup_string(&cfg, "write-pid-path", &sval)) {
|
||||
if (*sval != '/') {
|
||||
log_warn("The write-pid-path in your configuration file is not"
|
||||
" an absolute path");
|
||||
}
|
||||
opt->write_pid_path = strdup(sval);
|
||||
}
|
||||
|
||||
// Wintype settings
|
||||
|
||||
// XXX ! Refactor all the wintype_* arrays into a struct
|
||||
for (wintype_t i = 0; i < NUM_WINTYPES; ++i) {
|
||||
parse_wintype_config(&cfg, WINTYPES[i], &opt->wintype_option[i],
|
||||
&winopt_mask[i]);
|
||||
}
|
||||
|
||||
// Compatibility with the old name for notification windows.
|
||||
parse_wintype_config(&cfg, "notify", &opt->wintype_option[WINTYPE_NOTIFICATION],
|
||||
&winopt_mask[WINTYPE_NOTIFICATION]);
|
||||
|
||||
config_destroy(&cfg);
|
||||
return path;
|
||||
|
||||
err:
|
||||
config_destroy(&cfg);
|
||||
free(path);
|
||||
return ERR_PTR(-1);
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,54 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Compton - a compositor for X11
|
||||
*
|
||||
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
|
||||
*
|
||||
* Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
* See LICENSE-mit for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <dbus/dbus.h>
|
||||
|
||||
typedef struct session session_t;
|
||||
struct win;
|
||||
|
||||
/**
|
||||
* Return a string representation of a D-Bus message type.
|
||||
*/
|
||||
static inline const char *cdbus_repr_msgtype(DBusMessage *msg) {
|
||||
return dbus_message_type_to_string(dbus_message_get_type(msg));
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize D-Bus connection.
|
||||
*/
|
||||
bool cdbus_init(session_t *ps, const char *uniq_name);
|
||||
|
||||
/**
|
||||
* Destroy D-Bus connection.
|
||||
*/
|
||||
void cdbus_destroy(session_t *ps);
|
||||
|
||||
/// Generate dbus win_added signal
|
||||
void cdbus_ev_win_added(session_t *ps, struct win *w);
|
||||
|
||||
/// Generate dbus win_destroyed signal
|
||||
void cdbus_ev_win_destroyed(session_t *ps, struct win *w);
|
||||
|
||||
/// Generate dbus win_mapped signal
|
||||
void cdbus_ev_win_mapped(session_t *ps, struct win *w);
|
||||
|
||||
/// Generate dbus win_unmapped signal
|
||||
void cdbus_ev_win_unmapped(session_t *ps, struct win *w);
|
||||
|
||||
/// Generate dbus win_focusout signal
|
||||
void cdbus_ev_win_focusout(session_t *ps, struct win *w);
|
||||
|
||||
/// Generate dbus win_focusin signal
|
||||
void cdbus_ev_win_focusin(session_t *ps, struct win *w);
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,53 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <xcb/xcb.h>
|
||||
#include <xcb/composite.h>
|
||||
|
||||
#include "backend/driver.h"
|
||||
#include "diagnostic.h"
|
||||
#include "config.h"
|
||||
#include "picom.h"
|
||||
#include "common.h"
|
||||
|
||||
void print_diagnostics(session_t *ps, const char *config_file, bool compositor_running) {
|
||||
printf("**Version:** " COMPTON_VERSION "\n");
|
||||
//printf("**CFLAGS:** %s\n", "??");
|
||||
printf("\n### Extensions:\n\n");
|
||||
printf("* Shape: %s\n", ps->shape_exists ? "Yes" : "No");
|
||||
printf("* XRandR: %s\n", ps->randr_exists ? "Yes" : "No");
|
||||
printf("* Present: %s\n", ps->present_exists ? "Present" : "Not Present");
|
||||
printf("\n### Misc:\n\n");
|
||||
printf("* Use Overlay: %s\n", ps->overlay != XCB_NONE ? "Yes" : "No");
|
||||
if (ps->overlay == XCB_NONE) {
|
||||
if (compositor_running) {
|
||||
printf(" (Another compositor is already running)\n");
|
||||
} else if (session_redirection_mode(ps) != XCB_COMPOSITE_REDIRECT_MANUAL) {
|
||||
printf(" (Not in manual redirection mode)\n");
|
||||
} else {
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
#ifdef __FAST_MATH__
|
||||
printf("* Fast Math: Yes\n");
|
||||
#endif
|
||||
printf("* Config file used: %s\n", config_file ?: "None");
|
||||
printf("\n### Drivers (inaccurate):\n\n");
|
||||
print_drivers(ps->drivers);
|
||||
|
||||
for (int i = 0; i < NUM_BKEND; i++) {
|
||||
if (backend_list[i] && backend_list[i]->diagnostics) {
|
||||
printf("\n### Backend: %s\n\n", BACKEND_STRS[i]);
|
||||
auto data = backend_list[i]->init(ps);
|
||||
if (!data) {
|
||||
printf(" Cannot initialize this backend\n");
|
||||
} else {
|
||||
backend_list[i]->diagnostics(data);
|
||||
backend_list[i]->deinit(data);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,9 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct session session_t;
|
||||
|
||||
void print_diagnostics(session_t *, const char *config_file, bool compositor_running);
|
||||
@@ -0,0 +1,37 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2019 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "compiler.h"
|
||||
|
||||
// Functions for error reporting, adopted from Linux
|
||||
|
||||
// INFO in user space we can probably be more liberal about what pointer we consider
|
||||
// error. e.g. In x86_64 Linux, all addresses with the highest bit set is invalid in user
|
||||
// space.
|
||||
#define MAX_ERRNO 4095
|
||||
|
||||
static inline void *must_use ERR_PTR(intptr_t err) {
|
||||
return (void *)err;
|
||||
}
|
||||
|
||||
static inline intptr_t must_use PTR_ERR(void *ptr) {
|
||||
return (intptr_t)ptr;
|
||||
}
|
||||
|
||||
static inline bool must_use IS_ERR(void *ptr) {
|
||||
return unlikely((uintptr_t)ptr > (uintptr_t)-MAX_ERRNO);
|
||||
}
|
||||
|
||||
static inline bool must_use IS_ERR_OR_NULL(void *ptr) {
|
||||
return unlikely(!ptr) || IS_ERR(ptr);
|
||||
}
|
||||
|
||||
static inline intptr_t must_use PTR_ERR_OR_ZERO(void *ptr) {
|
||||
if (IS_ERR(ptr)) {
|
||||
return PTR_ERR(ptr);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,757 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2019, Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <X11/Xlibint.h>
|
||||
#include <X11/extensions/sync.h>
|
||||
#include <xcb/damage.h>
|
||||
#include <xcb/randr.h>
|
||||
|
||||
#include "atom.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "event.h"
|
||||
#include "log.h"
|
||||
#include "picom.h"
|
||||
#include "region.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
/// Event handling with X is complicated. Handling events with other events possibly
|
||||
/// in-flight is no good. Because your internal state won't be up to date. Also, querying
|
||||
/// the server while events are in-flight is not good. Because events later in the queue
|
||||
/// might container information you are querying. Thus those events will cause you to do
|
||||
/// unnecessary updates even when you already have the latest information (remember, you
|
||||
/// made the query when those events were already in the queue. so the reply you got is
|
||||
/// more up-to-date than the events). Also, handling events when other client are making
|
||||
/// concurrent requests is not good. Because the server states are changing without you
|
||||
/// knowning them. This is super racy, and can cause lots of potential problems.
|
||||
///
|
||||
/// All of above mandates we do these things:
|
||||
/// 1. Grab server when handling events
|
||||
/// 2. Make sure the event queue is empty before we make any query to the server
|
||||
///
|
||||
/// Notice (2) has a dependency circle. To handle events, you sometimes need to make
|
||||
/// queries. But to make queries you have to first handle events.
|
||||
///
|
||||
/// To break that circle, we split all event handling into top and bottom halves. The
|
||||
/// bottom half will just look at the event itself, update as much state as they can
|
||||
/// without making queries, then queue up necessary works need to be done by the top half.
|
||||
/// The top half will do all the other necessary updates. Before entering the top half, we
|
||||
/// grab the server and make sure the event queue is empty.
|
||||
///
|
||||
/// When top half finished, we enter the render stage, where no server state should be
|
||||
/// queried. All rendering should be done with our internal knowledge of the server state.
|
||||
///
|
||||
|
||||
// TODO(yshui) the things described above
|
||||
|
||||
/**
|
||||
* Get a window's name from window ID.
|
||||
*/
|
||||
static inline const char *ev_window_name(session_t *ps, xcb_window_t wid) {
|
||||
char *name = "";
|
||||
if (wid) {
|
||||
name = "(Failed to get title)";
|
||||
if (ps->root == wid) {
|
||||
name = "(Root window)";
|
||||
} else if (ps->overlay == wid) {
|
||||
name = "(Overlay)";
|
||||
} else {
|
||||
auto w = find_managed_win(ps, wid);
|
||||
if (!w) {
|
||||
w = find_toplevel(ps, wid);
|
||||
}
|
||||
|
||||
if (w && w->name) {
|
||||
name = w->name;
|
||||
}
|
||||
}
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
static inline xcb_window_t attr_pure ev_window(session_t *ps, xcb_generic_event_t *ev) {
|
||||
switch (ev->response_type) {
|
||||
case FocusIn:
|
||||
case FocusOut: return ((xcb_focus_in_event_t *)ev)->event;
|
||||
case CreateNotify: return ((xcb_create_notify_event_t *)ev)->window;
|
||||
case ConfigureNotify: return ((xcb_configure_notify_event_t *)ev)->window;
|
||||
case DestroyNotify: return ((xcb_destroy_notify_event_t *)ev)->window;
|
||||
case MapNotify: return ((xcb_map_notify_event_t *)ev)->window;
|
||||
case UnmapNotify: return ((xcb_unmap_notify_event_t *)ev)->window;
|
||||
case ReparentNotify: return ((xcb_reparent_notify_event_t *)ev)->window;
|
||||
case CirculateNotify: return ((xcb_circulate_notify_event_t *)ev)->window;
|
||||
case Expose: return ((xcb_expose_event_t *)ev)->window;
|
||||
case PropertyNotify: return ((xcb_property_notify_event_t *)ev)->window;
|
||||
case ClientMessage: return ((xcb_client_message_event_t *)ev)->window;
|
||||
default:
|
||||
if (ps->damage_event + XCB_DAMAGE_NOTIFY == ev->response_type) {
|
||||
return ((xcb_damage_notify_event_t *)ev)->drawable;
|
||||
}
|
||||
|
||||
if (ps->shape_exists && ev->response_type == ps->shape_event) {
|
||||
return ((xcb_shape_notify_event_t *)ev)->affected_window;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#define CASESTRRET(s) \
|
||||
case s: return #s;
|
||||
|
||||
static inline const char *ev_name(session_t *ps, xcb_generic_event_t *ev) {
|
||||
static char buf[128];
|
||||
switch (ev->response_type & 0x7f) {
|
||||
CASESTRRET(FocusIn);
|
||||
CASESTRRET(FocusOut);
|
||||
CASESTRRET(CreateNotify);
|
||||
CASESTRRET(ConfigureNotify);
|
||||
CASESTRRET(DestroyNotify);
|
||||
CASESTRRET(MapNotify);
|
||||
CASESTRRET(UnmapNotify);
|
||||
CASESTRRET(ReparentNotify);
|
||||
CASESTRRET(CirculateNotify);
|
||||
CASESTRRET(Expose);
|
||||
CASESTRRET(PropertyNotify);
|
||||
CASESTRRET(ClientMessage);
|
||||
}
|
||||
|
||||
if (ps->damage_event + XCB_DAMAGE_NOTIFY == ev->response_type)
|
||||
return "Damage";
|
||||
|
||||
if (ps->shape_exists && ev->response_type == ps->shape_event)
|
||||
return "ShapeNotify";
|
||||
|
||||
if (ps->xsync_exists) {
|
||||
int o = ev->response_type - ps->xsync_event;
|
||||
switch (o) {
|
||||
CASESTRRET(XSyncCounterNotify);
|
||||
CASESTRRET(XSyncAlarmNotify);
|
||||
}
|
||||
}
|
||||
|
||||
sprintf(buf, "Event %d", ev->response_type);
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
static inline const char *attr_pure ev_focus_mode_name(xcb_focus_in_event_t *ev) {
|
||||
switch (ev->mode) {
|
||||
CASESTRRET(NotifyNormal);
|
||||
CASESTRRET(NotifyWhileGrabbed);
|
||||
CASESTRRET(NotifyGrab);
|
||||
CASESTRRET(NotifyUngrab);
|
||||
}
|
||||
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
static inline const char *attr_pure ev_focus_detail_name(xcb_focus_in_event_t *ev) {
|
||||
switch (ev->detail) {
|
||||
CASESTRRET(NotifyAncestor);
|
||||
CASESTRRET(NotifyVirtual);
|
||||
CASESTRRET(NotifyInferior);
|
||||
CASESTRRET(NotifyNonlinear);
|
||||
CASESTRRET(NotifyNonlinearVirtual);
|
||||
CASESTRRET(NotifyPointer);
|
||||
CASESTRRET(NotifyPointerRoot);
|
||||
CASESTRRET(NotifyDetailNone);
|
||||
}
|
||||
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
#undef CASESTRRET
|
||||
|
||||
static inline void ev_focus_in(session_t *ps, xcb_focus_in_event_t *ev) {
|
||||
log_debug("{ mode: %s, detail: %s }\n", ev_focus_mode_name(ev),
|
||||
ev_focus_detail_name(ev));
|
||||
ps->pending_updates = true;
|
||||
}
|
||||
|
||||
static inline void ev_focus_out(session_t *ps, xcb_focus_out_event_t *ev) {
|
||||
log_debug("{ mode: %s, detail: %s }\n", ev_focus_mode_name(ev),
|
||||
ev_focus_detail_name(ev));
|
||||
ps->pending_updates = true;
|
||||
}
|
||||
|
||||
static inline void ev_create_notify(session_t *ps, xcb_create_notify_event_t *ev) {
|
||||
if (ev->parent == ps->root) {
|
||||
add_win_top(ps, ev->window);
|
||||
}
|
||||
}
|
||||
|
||||
/// Handle configure event of a regular window
|
||||
static void configure_win(session_t *ps, xcb_configure_notify_event_t *ce) {
|
||||
auto w = find_win(ps, ce->window);
|
||||
|
||||
if (!w) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!w->managed) {
|
||||
restack_above(ps, w, ce->above_sibling);
|
||||
return;
|
||||
}
|
||||
|
||||
auto mw = (struct managed_win *)w;
|
||||
|
||||
restack_above(ps, w, ce->above_sibling);
|
||||
|
||||
// We check against pending_g here, because there might have been multiple
|
||||
// configure notifies in this cycle, or the window could receive multiple updates
|
||||
// while it's unmapped.
|
||||
bool position_changed = mw->pending_g.x != ce->x || mw->pending_g.y != ce->y;
|
||||
bool size_changed = mw->pending_g.width != ce->width ||
|
||||
mw->pending_g.height != ce->height ||
|
||||
mw->pending_g.border_width != ce->border_width;
|
||||
if (position_changed || size_changed) {
|
||||
// Queue pending updates
|
||||
win_set_flags(mw, WIN_FLAGS_FACTOR_CHANGED);
|
||||
// TODO(yshui) don't set pending_updates if the window is not
|
||||
// visible/mapped
|
||||
ps->pending_updates = true;
|
||||
|
||||
// At least one of the following if's is true
|
||||
if (position_changed) {
|
||||
log_trace("Window position changed, %dx%d -> %dx%d", mw->g.x,
|
||||
mw->g.y, ce->x, ce->y);
|
||||
mw->pending_g.x = ce->x;
|
||||
mw->pending_g.y = ce->y;
|
||||
win_set_flags(mw, WIN_FLAGS_POSITION_STALE);
|
||||
}
|
||||
|
||||
if (size_changed) {
|
||||
log_trace("Window size changed, %dx%d -> %dx%d", mw->g.width,
|
||||
mw->g.height, ce->width, ce->height);
|
||||
mw->pending_g.width = ce->width;
|
||||
mw->pending_g.height = ce->height;
|
||||
mw->pending_g.border_width = ce->border_width;
|
||||
win_set_flags(mw, WIN_FLAGS_SIZE_STALE);
|
||||
}
|
||||
|
||||
// Recalculate which screen this window is on
|
||||
win_update_screen(ps->xinerama_nscrs, ps->xinerama_scr_regs, mw);
|
||||
}
|
||||
|
||||
// override_redirect flag cannot be changed after window creation, as far
|
||||
// as I know, so there's no point to re-match windows here.
|
||||
mw->a.override_redirect = ce->override_redirect;
|
||||
}
|
||||
|
||||
static inline void ev_configure_notify(session_t *ps, xcb_configure_notify_event_t *ev) {
|
||||
log_debug("{ send_event: %d, id: %#010x, above: %#010x, override_redirect: %d }",
|
||||
ev->event, ev->window, ev->above_sibling, ev->override_redirect);
|
||||
if (ev->window == ps->root) {
|
||||
set_root_flags(ps, ROOT_FLAGS_CONFIGURED);
|
||||
} else {
|
||||
configure_win(ps, ev);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ev_destroy_notify(session_t *ps, xcb_destroy_notify_event_t *ev) {
|
||||
auto w = find_win(ps, ev->window);
|
||||
auto mw = find_toplevel(ps, ev->window);
|
||||
if (mw && mw->client_win == mw->base.id) {
|
||||
// We only want _real_ frame window
|
||||
assert(&mw->base == w);
|
||||
mw = NULL;
|
||||
}
|
||||
assert(w == NULL || mw == NULL);
|
||||
|
||||
if (w != NULL) {
|
||||
auto _ attr_unused = destroy_win_start(ps, w);
|
||||
} else if (mw != NULL) {
|
||||
win_unmark_client(ps, mw);
|
||||
win_set_flags(mw, WIN_FLAGS_CLIENT_STALE);
|
||||
ps->pending_updates = true;
|
||||
} else {
|
||||
log_debug("Received a destroy notify from an unknown window, %#010x",
|
||||
ev->window);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ev_map_notify(session_t *ps, xcb_map_notify_event_t *ev) {
|
||||
// Unmap overlay window if it got mapped but we are currently not
|
||||
// in redirected state.
|
||||
if (ps->overlay && ev->window == ps->overlay && !ps->redirected) {
|
||||
log_debug("Overlay is mapped while we are not redirected");
|
||||
auto e = xcb_request_check(ps->c, xcb_unmap_window(ps->c, ps->overlay));
|
||||
if (e) {
|
||||
log_error("Failed to unmap the overlay window");
|
||||
free(e);
|
||||
}
|
||||
// We don't track the overlay window, so we can return
|
||||
return;
|
||||
}
|
||||
|
||||
auto w = find_managed_win(ps, ev->window);
|
||||
if (!w) {
|
||||
return;
|
||||
}
|
||||
|
||||
win_set_flags(w, WIN_FLAGS_MAPPED);
|
||||
|
||||
// FocusIn/Out may be ignored when the window is unmapped, so we must
|
||||
// recheck focus here
|
||||
ps->pending_updates = true; // to update focus
|
||||
}
|
||||
|
||||
static inline void ev_unmap_notify(session_t *ps, xcb_unmap_notify_event_t *ev) {
|
||||
auto w = find_managed_win(ps, ev->window);
|
||||
if (w) {
|
||||
unmap_win_start(ps, w);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ev_reparent_notify(session_t *ps, xcb_reparent_notify_event_t *ev) {
|
||||
log_debug("Window %#010x has new parent: %#010x, override_redirect: %d",
|
||||
ev->window, ev->parent, ev->override_redirect);
|
||||
auto w_top = find_toplevel(ps, ev->window);
|
||||
if (w_top) {
|
||||
win_unmark_client(ps, w_top);
|
||||
win_set_flags(w_top, WIN_FLAGS_CLIENT_STALE);
|
||||
ps->pending_updates = true;
|
||||
}
|
||||
|
||||
if (ev->parent == ps->root) {
|
||||
// X will generate reparent notifiy even if the parent didn't actually
|
||||
// change (i.e. reparent again to current parent). So we check if that's
|
||||
// the case
|
||||
auto w = find_win(ps, ev->window);
|
||||
if (w) {
|
||||
// This window has already been reparented to root before,
|
||||
// so we don't need to create a new window for it, we just need to
|
||||
// move it to the top
|
||||
restack_top(ps, w);
|
||||
} else {
|
||||
add_win_top(ps, ev->window);
|
||||
}
|
||||
} else {
|
||||
// otherwise, find and destroy the window first
|
||||
{
|
||||
auto w = find_win(ps, ev->window);
|
||||
if (w) {
|
||||
auto ret = destroy_win_start(ps, w);
|
||||
if (!ret && w->managed) {
|
||||
auto mw = (struct managed_win *)w;
|
||||
CHECK(win_skip_fading(ps, mw));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reset event mask in case something wrong happens
|
||||
xcb_change_window_attributes(
|
||||
ps->c, ev->window, XCB_CW_EVENT_MASK,
|
||||
(const uint32_t[]){determine_evmask(ps, ev->window, WIN_EVMODE_UNKNOWN)});
|
||||
|
||||
if (!wid_has_prop(ps, ev->window, ps->atoms->aWM_STATE)) {
|
||||
log_debug("Window %#010x doesn't have WM_STATE property, it is "
|
||||
"probably not a client window. But we will listen for "
|
||||
"property change in case it gains one.",
|
||||
ev->window);
|
||||
xcb_change_window_attributes(
|
||||
ps->c, ev->window, XCB_CW_EVENT_MASK,
|
||||
(const uint32_t[]){determine_evmask(ps, ev->window, WIN_EVMODE_UNKNOWN) |
|
||||
XCB_EVENT_MASK_PROPERTY_CHANGE});
|
||||
} else {
|
||||
auto w_real_top = find_managed_window_or_parent(ps, ev->parent);
|
||||
if (w_real_top && w_real_top->state != WSTATE_UNMAPPED &&
|
||||
w_real_top->state != WSTATE_UNMAPPING) {
|
||||
log_debug("Mark window %#010x (%s) as having a stale "
|
||||
"client",
|
||||
w_real_top->base.id, w_real_top->name);
|
||||
win_set_flags(w_real_top, WIN_FLAGS_CLIENT_STALE);
|
||||
ps->pending_updates = true;
|
||||
} else {
|
||||
if (!w_real_top)
|
||||
log_debug("parent %#010x not found", ev->parent);
|
||||
else {
|
||||
// Window is not currently mapped, unmark its
|
||||
// client to trigger a client recheck when it is
|
||||
// mapped later.
|
||||
win_unmark_client(ps, w_real_top);
|
||||
log_debug("parent %#010x (%s) is in state %d",
|
||||
w_real_top->base.id, w_real_top->name,
|
||||
w_real_top->state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ev_circulate_notify(session_t *ps, xcb_circulate_notify_event_t *ev) {
|
||||
auto w = find_win(ps, ev->window);
|
||||
|
||||
if (!w)
|
||||
return;
|
||||
|
||||
if (ev->place == PlaceOnTop) {
|
||||
restack_top(ps, w);
|
||||
} else {
|
||||
restack_bottom(ps, w);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void expose_root(session_t *ps, const rect_t *rects, int nrects) {
|
||||
region_t region;
|
||||
pixman_region32_init_rects(®ion, rects, nrects);
|
||||
add_damage(ps, ®ion);
|
||||
pixman_region32_fini(®ion);
|
||||
}
|
||||
|
||||
static inline void ev_expose(session_t *ps, xcb_expose_event_t *ev) {
|
||||
if (ev->window == ps->root || (ps->overlay && ev->window == ps->overlay)) {
|
||||
int more = ev->count + 1;
|
||||
if (ps->n_expose == ps->size_expose) {
|
||||
if (ps->expose_rects) {
|
||||
ps->expose_rects =
|
||||
crealloc(ps->expose_rects, ps->size_expose + more);
|
||||
ps->size_expose += more;
|
||||
} else {
|
||||
ps->expose_rects = ccalloc(more, rect_t);
|
||||
ps->size_expose = more;
|
||||
}
|
||||
}
|
||||
|
||||
ps->expose_rects[ps->n_expose].x1 = ev->x;
|
||||
ps->expose_rects[ps->n_expose].y1 = ev->y;
|
||||
ps->expose_rects[ps->n_expose].x2 = ev->x + ev->width;
|
||||
ps->expose_rects[ps->n_expose].y2 = ev->y + ev->height;
|
||||
ps->n_expose++;
|
||||
|
||||
if (ev->count == 0) {
|
||||
expose_root(ps, ps->expose_rects, ps->n_expose);
|
||||
ps->n_expose = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void ev_property_notify(session_t *ps, xcb_property_notify_event_t *ev) {
|
||||
if (unlikely(log_get_level_tls() <= LOG_LEVEL_TRACE)) {
|
||||
// Print out changed atom
|
||||
xcb_get_atom_name_reply_t *reply =
|
||||
xcb_get_atom_name_reply(ps->c, xcb_get_atom_name(ps->c, ev->atom), NULL);
|
||||
const char *name = "?";
|
||||
int name_len = 1;
|
||||
if (reply) {
|
||||
name = xcb_get_atom_name_name(reply);
|
||||
name_len = xcb_get_atom_name_name_length(reply);
|
||||
}
|
||||
|
||||
log_debug("{ atom = %.*s }", name_len, name);
|
||||
free(reply);
|
||||
}
|
||||
|
||||
if (ps->root == ev->window) {
|
||||
// If desktop number property changes
|
||||
if (ev->atom == ps->atoms->a_NET_CURRENT_DESKTOP) {
|
||||
auto prop = x_get_prop(ps->c, ps->root, ps->atoms->a_NET_CURRENT_DESKTOP,
|
||||
1L, XCB_ATOM_CARDINAL, 32);
|
||||
|
||||
if (prop.nitems) {
|
||||
ps->root_desktop_switch_direction = ((int)*prop.c32) - ps->root_desktop_num;
|
||||
ps->root_desktop_num = (int)*prop.c32;
|
||||
}
|
||||
}
|
||||
|
||||
if (ps->o.use_ewmh_active_win && ps->atoms->a_NET_ACTIVE_WINDOW == ev->atom) {
|
||||
// to update focus
|
||||
ps->pending_updates = true;
|
||||
} else {
|
||||
// Destroy the root "image" if the wallpaper probably changed
|
||||
if (x_is_root_back_pixmap_atom(ps->atoms, ev->atom)) {
|
||||
root_damaged(ps);
|
||||
}
|
||||
}
|
||||
|
||||
// Unconcerned about any other proprties on root window
|
||||
return;
|
||||
}
|
||||
|
||||
ps->pending_updates = true;
|
||||
// If WM_STATE changes
|
||||
if (ev->atom == ps->atoms->aWM_STATE) {
|
||||
// Check whether it could be a client window
|
||||
if (!find_toplevel(ps, ev->window)) {
|
||||
// Reset event mask anyway
|
||||
xcb_change_window_attributes(ps->c, ev->window, XCB_CW_EVENT_MASK,
|
||||
(const uint32_t[]){determine_evmask(
|
||||
ps, ev->window, WIN_EVMODE_UNKNOWN)});
|
||||
|
||||
auto w_top = find_managed_window_or_parent(ps, ev->window);
|
||||
// ev->window might have not been managed yet, in that case w_top
|
||||
// would be NULL.
|
||||
if (w_top) {
|
||||
win_set_flags(w_top, WIN_FLAGS_CLIENT_STALE);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// If _NET_WM_WINDOW_TYPE changes... God knows why this would happen, but
|
||||
// there are always some stupid applications. (#144)
|
||||
if (ev->atom == ps->atoms->a_NET_WM_WINDOW_TYPE) {
|
||||
struct managed_win *w = NULL;
|
||||
if ((w = find_toplevel(ps, ev->window))) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
if (ev->atom == ps->atoms->a_NET_WM_BYPASS_COMPOSITOR) {
|
||||
// Unnecessay until we remove the queue_redraw in ev_handle
|
||||
queue_redraw(ps);
|
||||
}
|
||||
|
||||
// If _NET_WM_WINDOW_OPACITY changes
|
||||
if (ev->atom == ps->atoms->a_NET_WM_WINDOW_OPACITY) {
|
||||
auto w = find_managed_win(ps, ev->window) ?: find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If frame extents property changes
|
||||
if (ev->atom == ps->atoms->a_NET_FRAME_EXTENTS) {
|
||||
auto w = find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If name changes
|
||||
if (ps->atoms->aWM_NAME == ev->atom || ps->atoms->a_NET_WM_NAME == ev->atom) {
|
||||
auto w = find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If class changes
|
||||
if (ps->atoms->aWM_CLASS == ev->atom) {
|
||||
auto w = find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If role changes
|
||||
if (ps->atoms->aWM_WINDOW_ROLE == ev->atom) {
|
||||
auto w = find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If _COMPTON_SHADOW changes
|
||||
if (ps->atoms->a_COMPTON_SHADOW == ev->atom) {
|
||||
auto w = find_managed_win(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// If a leader property changes
|
||||
if ((ps->o.detect_transient && ps->atoms->aWM_TRANSIENT_FOR == ev->atom) ||
|
||||
(ps->o.detect_client_leader && ps->atoms->aWM_CLIENT_LEADER == ev->atom)) {
|
||||
auto w = find_toplevel(ps, ev->window);
|
||||
if (w) {
|
||||
win_set_property_stale(w, ev->atom);
|
||||
}
|
||||
}
|
||||
|
||||
// Check for other atoms we are tracking
|
||||
for (latom_t *platom = ps->track_atom_lst; platom; platom = platom->next) {
|
||||
if (platom->atom == ev->atom) {
|
||||
auto w = find_managed_win(ps, ev->window);
|
||||
if (!w) {
|
||||
w = find_toplevel(ps, ev->window);
|
||||
}
|
||||
if (w) {
|
||||
// Set FACTOR_CHANGED so rules based on properties will be
|
||||
// re-evaluated.
|
||||
// Don't need to set property stale here, since that only
|
||||
// concerns properties we explicitly check.
|
||||
win_set_flags(w, WIN_FLAGS_FACTOR_CHANGED);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void repair_win(session_t *ps, struct managed_win *w) {
|
||||
// Only mapped window can receive damages
|
||||
assert(win_is_mapped_in_x(w));
|
||||
|
||||
region_t parts;
|
||||
pixman_region32_init(&parts);
|
||||
|
||||
if (!w->ever_damaged) {
|
||||
win_extents(w, &parts);
|
||||
set_ignore_cookie(
|
||||
ps, xcb_damage_subtract(ps->c, w->damage, XCB_NONE, XCB_NONE));
|
||||
} else {
|
||||
set_ignore_cookie(
|
||||
ps, xcb_damage_subtract(ps->c, w->damage, XCB_NONE, ps->damaged_region));
|
||||
x_fetch_region(ps->c, ps->damaged_region, &parts);
|
||||
pixman_region32_translate(&parts, w->g.x + w->g.border_width,
|
||||
w->g.y + w->g.border_width);
|
||||
}
|
||||
|
||||
log_trace("Mark window %#010x (%s) as having received damage", w->base.id, w->name);
|
||||
w->ever_damaged = true;
|
||||
w->pixmap_damaged = true;
|
||||
|
||||
// Why care about damage when screen is unredirected?
|
||||
// We will force full-screen repaint on redirection.
|
||||
if (!ps->redirected) {
|
||||
pixman_region32_fini(&parts);
|
||||
return;
|
||||
}
|
||||
|
||||
// Remove the part in the damage area that could be ignored
|
||||
if (w->reg_ignore && win_is_region_ignore_valid(ps, w)) {
|
||||
pixman_region32_subtract(&parts, &parts, w->reg_ignore);
|
||||
}
|
||||
|
||||
add_damage(ps, &parts);
|
||||
pixman_region32_fini(&parts);
|
||||
}
|
||||
|
||||
static inline void ev_damage_notify(session_t *ps, xcb_damage_notify_event_t *de) {
|
||||
/*
|
||||
if (ps->root == de->drawable) {
|
||||
root_damaged();
|
||||
return;
|
||||
} */
|
||||
|
||||
auto w = find_managed_win(ps, de->drawable);
|
||||
|
||||
if (!w) {
|
||||
return;
|
||||
}
|
||||
|
||||
repair_win(ps, w);
|
||||
}
|
||||
|
||||
static inline void ev_shape_notify(session_t *ps, xcb_shape_notify_event_t *ev) {
|
||||
auto w = find_managed_win(ps, ev->affected_window);
|
||||
if (!w || w->a.map_state == XCB_MAP_STATE_UNMAPPED) {
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Empty bounding_shape may indicated an
|
||||
* unmapped/destroyed window, in which case
|
||||
* seemingly BadRegion errors would be triggered
|
||||
* if we attempt to rebuild border_size
|
||||
*/
|
||||
// Mark the old bounding shape as damaged
|
||||
if (!win_check_flags_any(w, WIN_FLAGS_SIZE_STALE | WIN_FLAGS_POSITION_STALE)) {
|
||||
region_t tmp = win_get_bounding_shape_global_by_val(w);
|
||||
add_damage(ps, &tmp);
|
||||
pixman_region32_fini(&tmp);
|
||||
}
|
||||
w->reg_ignore_valid = false;
|
||||
|
||||
win_set_flags(w, WIN_FLAGS_SIZE_STALE);
|
||||
ps->pending_updates = true;
|
||||
}
|
||||
|
||||
static inline void
|
||||
ev_selection_clear(session_t *ps, xcb_selection_clear_event_t attr_unused *ev) {
|
||||
// The only selection we own is the _NET_WM_CM_Sn selection.
|
||||
// If we lose that one, we should exit.
|
||||
log_fatal("Another composite manager started and took the _NET_WM_CM_Sn "
|
||||
"selection.");
|
||||
quit(ps);
|
||||
}
|
||||
|
||||
void ev_handle(session_t *ps, xcb_generic_event_t *ev) {
|
||||
if ((ev->response_type & 0x7f) != KeymapNotify) {
|
||||
discard_ignore(ps, ev->full_sequence);
|
||||
}
|
||||
|
||||
xcb_window_t wid = ev_window(ps, ev);
|
||||
if (ev->response_type != ps->damage_event + XCB_DAMAGE_NOTIFY) {
|
||||
log_debug("event %10.10s serial %#010x window %#010x \"%s\"",
|
||||
ev_name(ps, ev), ev->full_sequence, wid, ev_window_name(ps, wid));
|
||||
} else {
|
||||
log_trace("event %10.10s serial %#010x window %#010x \"%s\"",
|
||||
ev_name(ps, ev), ev->full_sequence, wid, ev_window_name(ps, wid));
|
||||
}
|
||||
|
||||
// Check if a custom XEvent constructor was registered in xlib for this event
|
||||
// type, and call it discarding the constructed XEvent if any. XESetWireToEvent
|
||||
// might be used by libraries to intercept messages from the X server e.g. the
|
||||
// OpenGL lib waiting for DRI2 events.
|
||||
|
||||
// XXX This exists to workaround compton issue #33, #34, #47
|
||||
// For even more details, see:
|
||||
// https://bugs.freedesktop.org/show_bug.cgi?id=35945
|
||||
// https://lists.freedesktop.org/archives/xcb/2011-November/007337.html
|
||||
auto proc = XESetWireToEvent(ps->dpy, ev->response_type, 0);
|
||||
if (proc) {
|
||||
XESetWireToEvent(ps->dpy, ev->response_type, proc);
|
||||
XEvent dummy;
|
||||
|
||||
// Stop Xlib from complaining about lost sequence numbers.
|
||||
// proc might also just be Xlib internal event processing functions, and
|
||||
// because they probably won't see all X replies, they will complain about
|
||||
// missing sequence numbers.
|
||||
//
|
||||
// We only need the low 16 bits
|
||||
ev->sequence = (uint16_t)(LastKnownRequestProcessed(ps->dpy) & 0xffff);
|
||||
proc(ps->dpy, &dummy, (xEvent *)ev);
|
||||
}
|
||||
|
||||
// XXX redraw needs to be more fine grained
|
||||
queue_redraw(ps);
|
||||
|
||||
switch (ev->response_type) {
|
||||
case FocusIn: ev_focus_in(ps, (xcb_focus_in_event_t *)ev); break;
|
||||
case FocusOut: ev_focus_out(ps, (xcb_focus_out_event_t *)ev); break;
|
||||
case CreateNotify: ev_create_notify(ps, (xcb_create_notify_event_t *)ev); break;
|
||||
case ConfigureNotify:
|
||||
ev_configure_notify(ps, (xcb_configure_notify_event_t *)ev);
|
||||
break;
|
||||
case DestroyNotify:
|
||||
ev_destroy_notify(ps, (xcb_destroy_notify_event_t *)ev);
|
||||
break;
|
||||
case MapNotify: ev_map_notify(ps, (xcb_map_notify_event_t *)ev); break;
|
||||
case UnmapNotify: ev_unmap_notify(ps, (xcb_unmap_notify_event_t *)ev); break;
|
||||
case ReparentNotify:
|
||||
ev_reparent_notify(ps, (xcb_reparent_notify_event_t *)ev);
|
||||
break;
|
||||
case CirculateNotify:
|
||||
ev_circulate_notify(ps, (xcb_circulate_notify_event_t *)ev);
|
||||
break;
|
||||
case Expose: ev_expose(ps, (xcb_expose_event_t *)ev); break;
|
||||
case PropertyNotify:
|
||||
ev_property_notify(ps, (xcb_property_notify_event_t *)ev);
|
||||
break;
|
||||
case SelectionClear:
|
||||
ev_selection_clear(ps, (xcb_selection_clear_event_t *)ev);
|
||||
break;
|
||||
case 0: ev_xcb_error(ps, (xcb_generic_error_t *)ev); break;
|
||||
default:
|
||||
if (ps->shape_exists && ev->response_type == ps->shape_event) {
|
||||
ev_shape_notify(ps, (xcb_shape_notify_event_t *)ev);
|
||||
break;
|
||||
}
|
||||
if (ps->randr_exists &&
|
||||
ev->response_type == (ps->randr_event + XCB_RANDR_SCREEN_CHANGE_NOTIFY)) {
|
||||
set_root_flags(ps, ROOT_FLAGS_SCREEN_CHANGE);
|
||||
break;
|
||||
}
|
||||
if (ps->damage_event + XCB_DAMAGE_NOTIFY == ev->response_type) {
|
||||
ev_damage_notify(ps, (xcb_damage_notify_event_t *)ev);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2019, Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "common.h"
|
||||
|
||||
void ev_handle(session_t *ps, xcb_generic_event_t *ev);
|
||||
@@ -0,0 +1,188 @@
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#ifdef HAS_INOTIFY
|
||||
#include <sys/inotify.h>
|
||||
#elif HAS_KQUEUE
|
||||
// clang-format off
|
||||
#include <sys/types.h>
|
||||
// clang-format on
|
||||
#include <sys/event.h>
|
||||
#undef EV_ERROR // Avoid clashing with libev's EV_ERROR
|
||||
#include <fcntl.h> // For O_RDONLY
|
||||
#include <sys/time.h> // For struct timespec
|
||||
#include <unistd.h> // For open
|
||||
#endif
|
||||
|
||||
#include <ev.h>
|
||||
#include <uthash.h>
|
||||
|
||||
#include "file_watch.h"
|
||||
#include "list.h"
|
||||
#include "log.h"
|
||||
#include "utils.h"
|
||||
|
||||
struct watched_file {
|
||||
int wd;
|
||||
void *ud;
|
||||
file_watch_cb_t cb;
|
||||
|
||||
UT_hash_handle hh;
|
||||
};
|
||||
|
||||
struct file_watch_registry {
|
||||
struct ev_io w;
|
||||
|
||||
struct watched_file *reg;
|
||||
};
|
||||
|
||||
static void file_watch_ev_cb(EV_P attr_unused, struct ev_io *w, int revent attr_unused) {
|
||||
auto fwr = (struct file_watch_registry *)w;
|
||||
|
||||
while (true) {
|
||||
int wd = -1;
|
||||
#ifdef HAS_INOTIFY
|
||||
struct inotify_event inotify_event;
|
||||
auto ret = read(w->fd, &inotify_event, sizeof(struct inotify_event));
|
||||
if (ret < 0) {
|
||||
if (errno != EAGAIN) {
|
||||
log_error_errno("Failed to read from inotify fd");
|
||||
}
|
||||
break;
|
||||
}
|
||||
wd = inotify_event.wd;
|
||||
#elif HAS_KQUEUE
|
||||
struct kevent ev;
|
||||
struct timespec timeout = {0};
|
||||
int ret = kevent(fwr->w.fd, NULL, 0, &ev, 1, &timeout);
|
||||
if (ret <= 0) {
|
||||
if (ret < 0) {
|
||||
log_error_errno("Failed to get kevent");
|
||||
}
|
||||
break;
|
||||
}
|
||||
wd = (int)ev.ident;
|
||||
#else
|
||||
assert(false);
|
||||
#endif
|
||||
|
||||
struct watched_file *wf = NULL;
|
||||
HASH_FIND_INT(fwr->reg, &wd, wf);
|
||||
if (!wf) {
|
||||
log_warn("Got notification for a file I didn't watch.");
|
||||
continue;
|
||||
}
|
||||
wf->cb(wf->ud);
|
||||
}
|
||||
}
|
||||
|
||||
void *file_watch_init(EV_P) {
|
||||
log_debug("Starting watching for file changes");
|
||||
int fd = -1;
|
||||
#ifdef HAS_INOTIFY
|
||||
fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
|
||||
if (fd < 0) {
|
||||
log_error_errno("inotify_init1 failed");
|
||||
return NULL;
|
||||
}
|
||||
#elif HAS_KQUEUE
|
||||
fd = kqueue();
|
||||
if (fd < 0) {
|
||||
log_error_errno("Failed to create kqueue");
|
||||
return NULL;
|
||||
}
|
||||
#else
|
||||
log_info("No file watching support found on the host system.");
|
||||
return NULL;
|
||||
#endif
|
||||
auto fwr = ccalloc(1, struct file_watch_registry);
|
||||
ev_io_init(&fwr->w, file_watch_ev_cb, fd, EV_READ);
|
||||
ev_io_start(EV_A_ & fwr->w);
|
||||
|
||||
return fwr;
|
||||
}
|
||||
|
||||
void file_watch_destroy(EV_P_ void *_fwr) {
|
||||
log_debug("Stopping watching for file changes");
|
||||
auto fwr = (struct file_watch_registry *)_fwr;
|
||||
struct watched_file *i, *tmp;
|
||||
|
||||
HASH_ITER(hh, fwr->reg, i, tmp) {
|
||||
HASH_DEL(fwr->reg, i);
|
||||
#ifdef HAS_KQUEUE
|
||||
// kqueue watch descriptors are file descriptors of
|
||||
// the files we are watching, so we need to close
|
||||
// them
|
||||
close(i->wd);
|
||||
#endif
|
||||
free(i);
|
||||
}
|
||||
|
||||
ev_io_stop(EV_A_ & fwr->w);
|
||||
close(fwr->w.fd);
|
||||
free(fwr);
|
||||
}
|
||||
|
||||
bool file_watch_add(void *_fwr, const char *filename, file_watch_cb_t cb, void *ud) {
|
||||
log_debug("Adding \"%s\" to watched files", filename);
|
||||
auto fwr = (struct file_watch_registry *)_fwr;
|
||||
int wd = -1;
|
||||
|
||||
struct stat statbuf;
|
||||
int ret = stat(filename, &statbuf);
|
||||
if (ret < 0) {
|
||||
log_error_errno("Failed to retrieve information about file \"%s\"", filename);
|
||||
return false;
|
||||
}
|
||||
if (!S_ISREG(statbuf.st_mode)) {
|
||||
log_info("\"%s\" is not a regular file, not watching it.", filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef HAS_INOTIFY
|
||||
wd = inotify_add_watch(fwr->w.fd, filename,
|
||||
IN_CLOSE_WRITE | IN_MOVE_SELF | IN_DELETE_SELF);
|
||||
if (wd < 0) {
|
||||
log_error_errno("Failed to watch file \"%s\"", filename);
|
||||
return false;
|
||||
}
|
||||
#elif HAS_KQUEUE
|
||||
wd = open(filename, O_RDONLY);
|
||||
if (wd < 0) {
|
||||
log_error_errno("Cannot open file \"%s\" for watching", filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t fflags = NOTE_DELETE | NOTE_RENAME | NOTE_REVOKE | NOTE_ATTRIB;
|
||||
// NOTE_CLOSE_WRITE is relatively new, so we cannot just use it
|
||||
#ifdef NOTE_CLOSE_WRITE
|
||||
fflags |= NOTE_CLOSE_WRITE;
|
||||
#else
|
||||
// NOTE_WRITE will receive notification more frequent than necessary, so is less
|
||||
// preferrable
|
||||
fflags |= NOTE_WRITE;
|
||||
#endif
|
||||
struct kevent ev = {
|
||||
.ident = (unsigned int)wd, // the wd < 0 case is checked above
|
||||
.filter = EVFILT_VNODE,
|
||||
.flags = EV_ADD | EV_CLEAR,
|
||||
.fflags = fflags,
|
||||
.data = 0,
|
||||
.udata = NULL,
|
||||
};
|
||||
if (kevent(fwr->w.fd, &ev, 1, NULL, 0, NULL) < 0) {
|
||||
log_error_errno("Failed to register kevent");
|
||||
close(wd);
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
assert(false);
|
||||
#endif // HAS_KQUEUE
|
||||
|
||||
auto w = ccalloc(1, struct watched_file);
|
||||
w->wd = wd;
|
||||
w->cb = cb;
|
||||
w->ud = ud;
|
||||
|
||||
HASH_ADD_INT(fwr->reg, wd, w);
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
|
||||
#include <ev.h>
|
||||
|
||||
typedef void (*file_watch_cb_t)(void *);
|
||||
|
||||
void *file_watch_init(EV_P);
|
||||
bool file_watch_add(void *, const char *, file_watch_cb_t, void *);
|
||||
void file_watch_destroy(EV_P_ void *);
|
||||
@@ -0,0 +1,160 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "utils.h"
|
||||
|
||||
/// Sum a region convolution kernel. Region is defined by a width x height rectangle whose
|
||||
/// top left corner is at (x, y)
|
||||
double sum_kernel(const conv *map, int x, int y, int width, int height) {
|
||||
double ret = 0;
|
||||
|
||||
// Compute sum of values which are "in range"
|
||||
int xstart = normalize_i_range(x, 0, map->w),
|
||||
xend = normalize_i_range(width + x, 0, map->w);
|
||||
int ystart = normalize_i_range(y, 0, map->h),
|
||||
yend = normalize_i_range(height + y, 0, map->h);
|
||||
assert(yend >= ystart && xend >= xstart);
|
||||
|
||||
int d = map->w;
|
||||
if (map->rsum) {
|
||||
// See sum_kernel_preprocess
|
||||
double v1 = xstart ? map->rsum[(yend - 1) * d + xstart - 1] : 0;
|
||||
double v2 = ystart ? map->rsum[(ystart - 1) * d + xend - 1] : 0;
|
||||
double v3 = (xstart && ystart) ? map->rsum[(ystart - 1) * d + xstart - 1] : 0;
|
||||
return map->rsum[(yend - 1) * d + xend - 1] - v1 - v2 + v3;
|
||||
}
|
||||
|
||||
for (int yi = ystart; yi < yend; yi++) {
|
||||
for (int xi = xstart; xi < xend; xi++) {
|
||||
ret += map->data[yi * d + xi];
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
double sum_kernel_normalized(const conv *map, int x, int y, int width, int height) {
|
||||
double ret = sum_kernel(map, x, y, width, height);
|
||||
if (ret < 0) {
|
||||
ret = 0;
|
||||
}
|
||||
if (ret > 1) {
|
||||
ret = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline double attr_const gaussian(double r, double x, double y) {
|
||||
// Formula can be found here:
|
||||
// https://en.wikipedia.org/wiki/Gaussian_blur#Mathematics
|
||||
// Except a special case for r == 0 to produce sharp shadows
|
||||
if (r == 0)
|
||||
return 1;
|
||||
return exp(-0.5 * (x * x + y * y) / (r * r)) / (2 * M_PI * r * r);
|
||||
}
|
||||
|
||||
conv *gaussian_kernel(double r, int size) {
|
||||
conv *c;
|
||||
int center = size / 2;
|
||||
double t;
|
||||
assert(size % 2 == 1);
|
||||
|
||||
c = cvalloc(sizeof(conv) + (size_t)(size * size) * sizeof(double));
|
||||
c->w = c->h = size;
|
||||
c->rsum = NULL;
|
||||
t = 0.0;
|
||||
|
||||
for (int y = 0; y < size; y++) {
|
||||
for (int x = 0; x < size; x++) {
|
||||
double g = gaussian(r, x - center, y - center);
|
||||
t += g;
|
||||
c->data[y * size + x] = g;
|
||||
}
|
||||
}
|
||||
|
||||
for (int y = 0; y < size; y++) {
|
||||
for (int x = 0; x < size; x++) {
|
||||
c->data[y * size + x] /= t;
|
||||
}
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
/// Estimate the element of the sum of the first row in a gaussian kernel with standard
|
||||
/// deviation `r` and size `size`,
|
||||
static inline double estimate_first_row_sum(double size, double r) {
|
||||
double factor = erf(size / r / sqrt(2));
|
||||
double a = exp(-0.5 * size * size / (r * r)) / sqrt(2 * M_PI) / r;
|
||||
return a / factor;
|
||||
}
|
||||
|
||||
/// Pick a suitable gaussian kernel radius for a given kernel size. The returned radius
|
||||
/// is the maximum possible radius (<= size*2) that satisfies no sum of the rows in
|
||||
/// the kernel are less than `row_limit` (up to certain precision).
|
||||
static inline double gaussian_kernel_std_for_size(int size, double row_limit) {
|
||||
assert(size > 0);
|
||||
if (row_limit >= 1.0 / 2.0 / size) {
|
||||
return size * 2;
|
||||
}
|
||||
double l = 0, r = size * 2;
|
||||
while (r - l > 1e-2) {
|
||||
double mid = (l + r) / 2.0;
|
||||
double vmid = estimate_first_row_sum(size, mid);
|
||||
if (vmid > row_limit) {
|
||||
r = mid;
|
||||
} else {
|
||||
l = mid;
|
||||
}
|
||||
}
|
||||
return (l + r) / 2.0;
|
||||
}
|
||||
|
||||
/// Create a gaussian kernel with auto detected standard deviation. The choosen standard
|
||||
/// deviation tries to make sure the outer most pixels of the shadow are completely
|
||||
/// transparent, so the transition from shadow to the background is smooth.
|
||||
///
|
||||
/// @param[in] shadow_radius the radius of the shadow
|
||||
conv *gaussian_kernel_autodetect_deviation(int shadow_radius) {
|
||||
assert(shadow_radius >= 0);
|
||||
int size = shadow_radius * 2 + 1;
|
||||
|
||||
if (shadow_radius == 0) {
|
||||
return gaussian_kernel(0, size);
|
||||
}
|
||||
double std = gaussian_kernel_std_for_size(shadow_radius, 1.0 / 256.0);
|
||||
return gaussian_kernel(std, size);
|
||||
}
|
||||
|
||||
/// preprocess kernels to make shadow generation faster
|
||||
/// shadow_sum[x*d+y] is the sum of the kernel from (0, 0) to (x, y), inclusive
|
||||
void sum_kernel_preprocess(conv *map) {
|
||||
if (map->rsum) {
|
||||
free(map->rsum);
|
||||
}
|
||||
|
||||
auto sum = map->rsum = ccalloc(map->w * map->h, double);
|
||||
sum[0] = map->data[0];
|
||||
|
||||
for (int x = 1; x < map->w; x++) {
|
||||
sum[x] = sum[x - 1] + map->data[x];
|
||||
}
|
||||
|
||||
const int d = map->w;
|
||||
for (int y = 1; y < map->h; y++) {
|
||||
sum[y * d] = sum[(y - 1) * d] + map->data[y * d];
|
||||
for (int x = 1; x < map->w; x++) {
|
||||
double tmp = sum[(y - 1) * d + x] + sum[y * d + x - 1] -
|
||||
sum[(y - 1) * d + x - 1];
|
||||
sum[y * d + x] = tmp + map->data[y * d + x];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,39 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#include <stdlib.h>
|
||||
#include "compiler.h"
|
||||
|
||||
/// Code for generating convolution kernels
|
||||
|
||||
typedef struct conv {
|
||||
int w, h;
|
||||
double *rsum;
|
||||
double data[];
|
||||
} conv;
|
||||
|
||||
/// Calculate the sum of a rectangle part of the convolution kernel
|
||||
/// the rectangle is defined by top left (x, y), and a size (width x height)
|
||||
double attr_pure sum_kernel(const conv *map, int x, int y, int width, int height);
|
||||
double attr_pure sum_kernel_normalized(const conv *map, int x, int y, int width, int height);
|
||||
|
||||
/// Create a kernel with gaussian distribution with standard deviation `r`, and size
|
||||
/// `size`.
|
||||
conv *gaussian_kernel(double r, int size);
|
||||
|
||||
/// Create a gaussian kernel with auto detected standard deviation. The choosen standard
|
||||
/// deviation tries to make sure the outer most pixels of the shadow are completely
|
||||
/// transparent.
|
||||
///
|
||||
/// @param[in] shadow_radius the radius of the shadow
|
||||
conv *gaussian_kernel_autodetect_deviation(int shadow_radius);
|
||||
|
||||
/// preprocess kernels to make shadow generation faster
|
||||
/// shadow_sum[x*d+y] is the sum of the kernel from (0, 0) to (x, y), inclusive
|
||||
void sum_kernel_preprocess(conv *map);
|
||||
|
||||
static inline void free_conv(conv *k) {
|
||||
free(k->rsum);
|
||||
free(k);
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
/**
|
||||
* container_of - cast a member of a structure out to the containing structure
|
||||
* @ptr: the pointer to the member.
|
||||
* @type: the type of the container struct this is embedded in.
|
||||
* @member: the name of the member within the struct.
|
||||
*
|
||||
*/
|
||||
#define container_of(ptr, type, member) \
|
||||
({ \
|
||||
const __typeof__(((type *)0)->member) *__mptr = (ptr); \
|
||||
(type *)((char *)__mptr - offsetof(type, member)); \
|
||||
})
|
||||
|
||||
struct list_node {
|
||||
struct list_node *next, *prev;
|
||||
};
|
||||
|
||||
#define list_entry(ptr, type, node) container_of(ptr, type, node)
|
||||
#define list_next_entry(ptr, node) list_entry((ptr)->node.next, __typeof__(*(ptr)), node)
|
||||
#define list_prev_entry(ptr, node) list_entry((ptr)->node.prev, __typeof__(*(ptr)), node)
|
||||
|
||||
/// Insert a new node between two adjacent nodes in the list
|
||||
static inline void __list_insert_between(struct list_node *prev, struct list_node *next,
|
||||
struct list_node *new_) {
|
||||
new_->prev = prev;
|
||||
new_->next = next;
|
||||
next->prev = new_;
|
||||
prev->next = new_;
|
||||
}
|
||||
|
||||
/// Insert a new node after `curr`
|
||||
static inline void list_insert_after(struct list_node *curr, struct list_node *new_) {
|
||||
__list_insert_between(curr, curr->next, new_);
|
||||
}
|
||||
|
||||
/// Insert a new node before `curr`
|
||||
static inline void list_insert_before(struct list_node *curr, struct list_node *new_) {
|
||||
__list_insert_between(curr->prev, curr, new_);
|
||||
}
|
||||
|
||||
/// Link two nodes in the list, so `next` becomes the successor node of `prev`
|
||||
static inline void __list_link(struct list_node *prev, struct list_node *next) {
|
||||
next->prev = prev;
|
||||
prev->next = next;
|
||||
}
|
||||
|
||||
/// Remove a node from the list
|
||||
static inline void list_remove(struct list_node *to_remove) {
|
||||
__list_link(to_remove->prev, to_remove->next);
|
||||
to_remove->prev = (void *)-1;
|
||||
to_remove->next = (void *)-2;
|
||||
}
|
||||
|
||||
/// Move `to_move` so that it's before `new_next`
|
||||
static inline void list_move_before(struct list_node *to_move, struct list_node *new_next) {
|
||||
list_remove(to_move);
|
||||
list_insert_before(new_next, to_move);
|
||||
}
|
||||
|
||||
/// Move `to_move` so that it's after `new_prev`
|
||||
static inline void list_move_after(struct list_node *to_move, struct list_node *new_prev) {
|
||||
list_remove(to_move);
|
||||
list_insert_after(new_prev, to_move);
|
||||
}
|
||||
|
||||
/// Initialize a list node that's intended to be the head node
|
||||
static inline void list_init_head(struct list_node *head) {
|
||||
head->next = head->prev = head;
|
||||
}
|
||||
|
||||
/// Replace list node `old` with `n`
|
||||
static inline void list_replace(struct list_node *old, struct list_node *n) {
|
||||
__list_insert_between(old->prev, old->next, n);
|
||||
old->prev = (void *)-1;
|
||||
old->next = (void *)-2;
|
||||
}
|
||||
|
||||
/// Return true if head is the only node in the list. Under usual circumstances this means
|
||||
/// the list is empty
|
||||
static inline bool list_is_empty(const struct list_node *head) {
|
||||
return head->prev == head;
|
||||
}
|
||||
|
||||
/// Return true if `to_check` is the first node in list headed by `head`
|
||||
static inline bool
|
||||
list_node_is_first(const struct list_node *head, const struct list_node *to_check) {
|
||||
return head->next == to_check;
|
||||
}
|
||||
|
||||
/// Return true if `to_check` is the last node in list headed by `head`
|
||||
static inline bool
|
||||
list_node_is_last(const struct list_node *head, const struct list_node *to_check) {
|
||||
return head->prev == to_check;
|
||||
}
|
||||
|
||||
#define list_foreach(type, i, head, member) \
|
||||
for (type *i = list_entry((head)->next, type, member); &i->member != (head); \
|
||||
i = list_next_entry(i, member))
|
||||
|
||||
/// Like list_for_each, but it's safe to remove the current list node from the list
|
||||
#define list_foreach_safe(type, i, head, member) \
|
||||
for (type *i = list_entry((head)->next, type, member), \
|
||||
*__tmp = list_next_entry(i, member); \
|
||||
&i->member != (head); i = __tmp, __tmp = list_next_entry(i, member))
|
||||
@@ -0,0 +1,376 @@
|
||||
#include <assert.h>
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/uio.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include <GL/gl.h>
|
||||
#include "backend/gl/gl_common.h"
|
||||
#include "backend/gl/glx.h"
|
||||
#endif
|
||||
|
||||
#include "compiler.h"
|
||||
#include "log.h"
|
||||
#include "utils.h"
|
||||
|
||||
thread_local struct log *tls_logger;
|
||||
|
||||
struct log_target;
|
||||
|
||||
struct log {
|
||||
struct log_target *head;
|
||||
|
||||
int log_level;
|
||||
};
|
||||
|
||||
struct log_target {
|
||||
const struct log_ops *ops;
|
||||
struct log_target *next;
|
||||
};
|
||||
|
||||
struct log_ops {
|
||||
void (*write)(struct log_target *, const char *, size_t);
|
||||
void (*writev)(struct log_target *, const struct iovec *, int vcnt);
|
||||
void (*destroy)(struct log_target *);
|
||||
|
||||
/// Additional strings to print around the log_level string
|
||||
const char *(*colorize_begin)(enum log_level);
|
||||
const char *(*colorize_end)(enum log_level);
|
||||
};
|
||||
|
||||
/// Fallback writev for targets don't implement it
|
||||
static attr_unused void
|
||||
log_default_writev(struct log_target *tgt, const struct iovec *vec, int vcnt) {
|
||||
size_t total = 0;
|
||||
for (int i = 0; i < vcnt; i++) {
|
||||
total += vec[i].iov_len;
|
||||
}
|
||||
|
||||
if (!total) {
|
||||
// Nothing to write
|
||||
return;
|
||||
}
|
||||
char *buf = ccalloc(total, char);
|
||||
total = 0;
|
||||
for (int i = 0; i < vcnt; i++) {
|
||||
memcpy(buf + total, vec[i].iov_base, vec[i].iov_len);
|
||||
total += vec[i].iov_len;
|
||||
}
|
||||
tgt->ops->write(tgt, buf, total);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static attr_const const char *log_level_to_string(enum log_level level) {
|
||||
switch (level) {
|
||||
case LOG_LEVEL_TRACE: return "TRACE";
|
||||
case LOG_LEVEL_DEBUG: return "DEBUG";
|
||||
case LOG_LEVEL_INFO: return "INFO";
|
||||
case LOG_LEVEL_WARN: return "WARN";
|
||||
case LOG_LEVEL_ERROR: return "ERROR";
|
||||
case LOG_LEVEL_FATAL: return "FATAL ERROR";
|
||||
default: return "????";
|
||||
}
|
||||
}
|
||||
|
||||
enum log_level string_to_log_level(const char *str) {
|
||||
if (strcasecmp(str, "TRACE") == 0)
|
||||
return LOG_LEVEL_TRACE;
|
||||
else if (strcasecmp(str, "DEBUG") == 0)
|
||||
return LOG_LEVEL_DEBUG;
|
||||
else if (strcasecmp(str, "INFO") == 0)
|
||||
return LOG_LEVEL_INFO;
|
||||
else if (strcasecmp(str, "WARN") == 0)
|
||||
return LOG_LEVEL_WARN;
|
||||
else if (strcasecmp(str, "ERROR") == 0)
|
||||
return LOG_LEVEL_ERROR;
|
||||
return LOG_LEVEL_INVALID;
|
||||
}
|
||||
|
||||
struct log *log_new(void) {
|
||||
auto ret = cmalloc(struct log);
|
||||
ret->log_level = LOG_LEVEL_WARN;
|
||||
ret->head = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void log_add_target(struct log *l, struct log_target *tgt) {
|
||||
assert(tgt->ops->writev);
|
||||
tgt->next = l->head;
|
||||
l->head = tgt;
|
||||
}
|
||||
|
||||
/// Remove a previously added log target for a log struct, and destroy it. If the log
|
||||
/// target was never added, nothing happens.
|
||||
void log_remove_target(struct log *l, struct log_target *tgt) {
|
||||
struct log_target *now = l->head, **prev = &l->head;
|
||||
while (now) {
|
||||
if (now == tgt) {
|
||||
*prev = now->next;
|
||||
tgt->ops->destroy(tgt);
|
||||
break;
|
||||
}
|
||||
prev = &now->next;
|
||||
now = now->next;
|
||||
}
|
||||
}
|
||||
|
||||
/// Destroy a log struct and every log target added to it
|
||||
void log_destroy(struct log *l) {
|
||||
// free all tgt
|
||||
struct log_target *head = l->head;
|
||||
while (head) {
|
||||
auto next = head->next;
|
||||
head->ops->destroy(head);
|
||||
head = next;
|
||||
}
|
||||
free(l);
|
||||
}
|
||||
|
||||
void log_set_level(struct log *l, int level) {
|
||||
assert(level <= LOG_LEVEL_FATAL && level >= 0);
|
||||
l->log_level = level;
|
||||
}
|
||||
|
||||
enum log_level log_get_level(const struct log *l) {
|
||||
return l->log_level;
|
||||
}
|
||||
|
||||
attr_printf(4, 5) void log_printf(struct log *l, int level, const char *func,
|
||||
const char *fmt, ...) {
|
||||
assert(level <= LOG_LEVEL_FATAL && level >= 0);
|
||||
if (level < l->log_level)
|
||||
return;
|
||||
|
||||
char *buf = NULL;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
int blen = vasprintf(&buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
if (blen < 0 || !buf) {
|
||||
free(buf);
|
||||
return;
|
||||
}
|
||||
|
||||
struct timespec ts;
|
||||
timespec_get(&ts, TIME_UTC);
|
||||
struct tm now;
|
||||
localtime_r(&ts.tv_sec, &now);
|
||||
char time_buf[100];
|
||||
strftime(time_buf, sizeof time_buf, "%x %T", &now);
|
||||
|
||||
char *time = NULL;
|
||||
int tlen = asprintf(&time, "%s.%03ld", time_buf, ts.tv_nsec / 1000000);
|
||||
if (tlen < 0 || !time) {
|
||||
free(buf);
|
||||
free(time);
|
||||
return;
|
||||
}
|
||||
|
||||
const char *log_level_str = log_level_to_string(level);
|
||||
size_t llen = strlen(log_level_str);
|
||||
size_t flen = strlen(func);
|
||||
|
||||
struct log_target *head = l->head;
|
||||
while (head) {
|
||||
const char *p = "", *s = "";
|
||||
size_t plen = 0, slen = 0;
|
||||
|
||||
if (head->ops->colorize_begin) {
|
||||
// construct target specific prefix
|
||||
p = head->ops->colorize_begin(level);
|
||||
plen = strlen(p);
|
||||
if (head->ops->colorize_end) {
|
||||
s = head->ops->colorize_end(level);
|
||||
slen = strlen(s);
|
||||
}
|
||||
}
|
||||
head->ops->writev(
|
||||
head,
|
||||
(struct iovec[]){{.iov_base = "[ ", .iov_len = 2},
|
||||
{.iov_base = time, .iov_len = (size_t)tlen},
|
||||
{.iov_base = " ", .iov_len = 1},
|
||||
{.iov_base = (void *)func, .iov_len = flen},
|
||||
{.iov_base = " ", .iov_len = 1},
|
||||
{.iov_base = (void *)p, .iov_len = plen},
|
||||
{.iov_base = (void *)log_level_str, .iov_len = llen},
|
||||
{.iov_base = (void *)s, .iov_len = slen},
|
||||
{.iov_base = " ] ", .iov_len = 3},
|
||||
{.iov_base = buf, .iov_len = (size_t)blen},
|
||||
{.iov_base = "\n", .iov_len = 1}},
|
||||
11);
|
||||
head = head->next;
|
||||
}
|
||||
free(time);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
/// A trivial deinitializer that simply frees the memory
|
||||
static attr_unused void logger_trivial_destroy(struct log_target *tgt) {
|
||||
free(tgt);
|
||||
}
|
||||
|
||||
/// A null log target that does nothing
|
||||
static const struct log_ops null_logger_ops;
|
||||
static struct log_target null_logger_target = {
|
||||
.ops = &null_logger_ops,
|
||||
};
|
||||
|
||||
struct log_target *null_logger_new(void) {
|
||||
return &null_logger_target;
|
||||
}
|
||||
|
||||
static void null_logger_write(struct log_target *tgt attr_unused,
|
||||
const char *str attr_unused, size_t len attr_unused) {
|
||||
return;
|
||||
}
|
||||
|
||||
static void null_logger_writev(struct log_target *tgt attr_unused,
|
||||
const struct iovec *vec attr_unused, int vcnt attr_unused) {
|
||||
return;
|
||||
}
|
||||
|
||||
static const struct log_ops null_logger_ops = {
|
||||
.write = null_logger_write,
|
||||
.writev = null_logger_writev,
|
||||
};
|
||||
|
||||
/// A file based logger that writes to file (or stdout/stderr)
|
||||
struct file_logger {
|
||||
struct log_target tgt;
|
||||
FILE *f;
|
||||
struct log_ops ops;
|
||||
};
|
||||
|
||||
static void file_logger_write(struct log_target *tgt, const char *str, size_t len) {
|
||||
auto f = (struct file_logger *)tgt;
|
||||
fwrite(str, 1, len, f->f);
|
||||
}
|
||||
|
||||
static void file_logger_writev(struct log_target *tgt, const struct iovec *vec, int vcnt) {
|
||||
auto f = (struct file_logger *)tgt;
|
||||
fflush(f->f);
|
||||
writev(fileno(f->f), vec, vcnt);
|
||||
}
|
||||
|
||||
static void file_logger_destroy(struct log_target *tgt) {
|
||||
auto f = (struct file_logger *)tgt;
|
||||
fclose(f->f);
|
||||
free(tgt);
|
||||
}
|
||||
|
||||
#define ANSI(x) "\033[" x "m"
|
||||
static const char *terminal_colorize_begin(enum log_level level) {
|
||||
switch (level) {
|
||||
case LOG_LEVEL_TRACE: return ANSI("30;2");
|
||||
case LOG_LEVEL_DEBUG: return ANSI("37;2");
|
||||
case LOG_LEVEL_INFO: return ANSI("92");
|
||||
case LOG_LEVEL_WARN: return ANSI("33");
|
||||
case LOG_LEVEL_ERROR: return ANSI("31;1");
|
||||
case LOG_LEVEL_FATAL: return ANSI("30;103;1");
|
||||
default: return "";
|
||||
}
|
||||
}
|
||||
|
||||
static const char *terminal_colorize_end(enum log_level level attr_unused) {
|
||||
return ANSI("0");
|
||||
}
|
||||
#undef PREFIX
|
||||
|
||||
static const struct log_ops file_logger_ops = {
|
||||
.write = file_logger_write,
|
||||
.writev = file_logger_writev,
|
||||
.destroy = file_logger_destroy,
|
||||
};
|
||||
|
||||
struct log_target *file_logger_new(const char *filename) {
|
||||
FILE *f = fopen(filename, "a");
|
||||
if (!f) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
auto ret = cmalloc(struct file_logger);
|
||||
ret->tgt.ops = &ret->ops;
|
||||
ret->f = f;
|
||||
|
||||
// Always assume a file is not a terminal
|
||||
ret->ops = file_logger_ops;
|
||||
|
||||
return &ret->tgt;
|
||||
}
|
||||
|
||||
struct log_target *stderr_logger_new(void) {
|
||||
int fd = dup(STDERR_FILENO);
|
||||
if (fd < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
FILE *f = fdopen(fd, "w");
|
||||
if (!f) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
auto ret = cmalloc(struct file_logger);
|
||||
ret->tgt.ops = &ret->ops;
|
||||
ret->f = f;
|
||||
ret->ops = file_logger_ops;
|
||||
|
||||
if (isatty(fd)) {
|
||||
ret->ops.colorize_begin = terminal_colorize_begin;
|
||||
ret->ops.colorize_end = terminal_colorize_end;
|
||||
}
|
||||
return &ret->tgt;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
/// An opengl logger that can be used for logging into opengl debugging tools,
|
||||
/// such as apitrace
|
||||
struct gl_string_marker_logger {
|
||||
struct log_target tgt;
|
||||
PFNGLSTRINGMARKERGREMEDYPROC gl_string_marker;
|
||||
};
|
||||
|
||||
static void
|
||||
gl_string_marker_logger_write(struct log_target *tgt, const char *str, size_t len) {
|
||||
auto g = (struct gl_string_marker_logger *)tgt;
|
||||
// strip newlines at the end of the string
|
||||
while (len > 0 && str[len-1] == '\n') {
|
||||
len--;
|
||||
}
|
||||
g->gl_string_marker((GLsizei)len, str);
|
||||
}
|
||||
|
||||
static const struct log_ops gl_string_marker_logger_ops = {
|
||||
.write = gl_string_marker_logger_write,
|
||||
.writev = log_default_writev,
|
||||
.destroy = logger_trivial_destroy,
|
||||
};
|
||||
|
||||
struct log_target *gl_string_marker_logger_new(void) {
|
||||
if (!gl_has_extension("GL_GREMEDY_string_marker")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *fnptr = glXGetProcAddress((GLubyte *)"glStringMarkerGREMEDY");
|
||||
if (!fnptr)
|
||||
return NULL;
|
||||
|
||||
auto ret = cmalloc(struct gl_string_marker_logger);
|
||||
ret->tgt.ops = &gl_string_marker_logger_ops;
|
||||
ret->gl_string_marker = fnptr;
|
||||
return &ret->tgt;
|
||||
}
|
||||
|
||||
#else
|
||||
struct log_target *gl_string_marker_logger_new(void) {
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
// vim: set noet sw=8 ts=8:
|
||||
@@ -0,0 +1,96 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "compiler.h"
|
||||
|
||||
enum log_level {
|
||||
LOG_LEVEL_INVALID = -1,
|
||||
LOG_LEVEL_TRACE = 0,
|
||||
LOG_LEVEL_DEBUG,
|
||||
LOG_LEVEL_INFO,
|
||||
LOG_LEVEL_WARN,
|
||||
LOG_LEVEL_ERROR,
|
||||
LOG_LEVEL_FATAL,
|
||||
};
|
||||
|
||||
#define LOG_UNLIKELY(level, x, ...) \
|
||||
do { \
|
||||
if (unlikely(LOG_LEVEL_##level >= log_get_level_tls())) { \
|
||||
log_printf(tls_logger, LOG_LEVEL_##level, __func__, x, ##__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define LOG(level, x, ...) \
|
||||
do { \
|
||||
if (LOG_LEVEL_##level >= log_get_level_tls()) { \
|
||||
log_printf(tls_logger, LOG_LEVEL_##level, __func__, x, ##__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
#define log_trace(x, ...) LOG_UNLIKELY(TRACE, x, ##__VA_ARGS__)
|
||||
#define log_debug(x, ...) LOG_UNLIKELY(DEBUG, x, ##__VA_ARGS__)
|
||||
#define log_info(x, ...) LOG(INFO, x, ##__VA_ARGS__)
|
||||
#define log_warn(x, ...) LOG(WARN, x, ##__VA_ARGS__)
|
||||
#define log_error(x, ...) LOG(ERROR, x, ##__VA_ARGS__)
|
||||
#define log_fatal(x, ...) LOG(FATAL, x, ##__VA_ARGS__)
|
||||
|
||||
#define log_error_errno(x, ...) LOG(ERROR, x ": %s", ##__VA_ARGS__, strerror(errno))
|
||||
|
||||
struct log;
|
||||
struct log_target;
|
||||
|
||||
attr_printf(4, 5) void log_printf(struct log *, int level, const char *func,
|
||||
const char *fmt, ...);
|
||||
|
||||
attr_malloc struct log *log_new(void);
|
||||
/// Destroy a log struct and every log target added to it
|
||||
attr_nonnull_all void log_destroy(struct log *);
|
||||
attr_nonnull(1) void log_set_level(struct log *l, int level);
|
||||
attr_pure enum log_level log_get_level(const struct log *l);
|
||||
attr_nonnull_all void log_add_target(struct log *, struct log_target *);
|
||||
attr_pure enum log_level string_to_log_level(const char *);
|
||||
/// Remove a previously added log target for a log struct, and destroy it. If the log
|
||||
/// target was never added, nothing happens.
|
||||
void log_remove_target(struct log *l, struct log_target *tgt);
|
||||
|
||||
extern thread_local struct log *tls_logger;
|
||||
|
||||
/// Create a thread local logger
|
||||
static inline void log_init_tls(void) {
|
||||
tls_logger = log_new();
|
||||
}
|
||||
/// Set thread local logger log level
|
||||
static inline void log_set_level_tls(int level) {
|
||||
assert(tls_logger);
|
||||
log_set_level(tls_logger, level);
|
||||
}
|
||||
static inline attr_nonnull_all void log_add_target_tls(struct log_target *tgt) {
|
||||
assert(tls_logger);
|
||||
log_add_target(tls_logger, tgt);
|
||||
}
|
||||
|
||||
static inline attr_nonnull_all void log_remove_target_tls(struct log_target *tgt) {
|
||||
assert(tls_logger);
|
||||
log_remove_target(tls_logger, tgt);
|
||||
}
|
||||
|
||||
static inline attr_pure enum log_level log_get_level_tls(void) {
|
||||
assert(tls_logger);
|
||||
return log_get_level(tls_logger);
|
||||
}
|
||||
|
||||
static inline void log_deinit_tls(void) {
|
||||
assert(tls_logger);
|
||||
log_destroy(tls_logger);
|
||||
tls_logger = NULL;
|
||||
}
|
||||
|
||||
attr_malloc struct log_target *stderr_logger_new(void);
|
||||
attr_malloc struct log_target *file_logger_new(const char *file);
|
||||
attr_malloc struct log_target *null_logger_new(void);
|
||||
attr_malloc struct log_target *gl_string_marker_logger_new(void);
|
||||
|
||||
// vim: set noet sw=8 ts=8:
|
||||
@@ -0,0 +1,97 @@
|
||||
libev = dependency('libev', required: false)
|
||||
if not libev.found()
|
||||
libev = cc.find_library('ev')
|
||||
endif
|
||||
base_deps = [
|
||||
cc.find_library('m'),
|
||||
libev
|
||||
]
|
||||
|
||||
srcs = [ files('picom.c', 'win.c', 'c2.c', 'x.c', 'config.c', 'vsync.c', 'utils.c',
|
||||
'diagnostic.c', 'string_utils.c', 'render.c', 'kernel.c', 'log.c',
|
||||
'options.c', 'event.c', 'cache.c', 'atom.c', 'file_watch.c') ]
|
||||
picom_inc = include_directories('.')
|
||||
|
||||
cflags = []
|
||||
|
||||
required_xcb_packages = [
|
||||
'xcb-render', 'xcb-damage', 'xcb-randr', 'xcb-sync', 'xcb-composite',
|
||||
'xcb-shape', 'xcb-xinerama', 'xcb-xfixes', 'xcb-present', 'xcb-glx', 'xcb'
|
||||
]
|
||||
|
||||
required_packages = [
|
||||
'x11', 'x11-xcb', 'xcb-renderutil', 'xcb-image', 'xext', 'pixman-1'
|
||||
]
|
||||
|
||||
foreach i : required_packages
|
||||
base_deps += [dependency(i, required: true)]
|
||||
endforeach
|
||||
|
||||
foreach i : required_xcb_packages
|
||||
base_deps += [dependency(i, version: '>=1.12.0', required: true)]
|
||||
endforeach
|
||||
|
||||
if not cc.has_header('uthash.h')
|
||||
error('Dependency uthash not found')
|
||||
endif
|
||||
|
||||
deps = []
|
||||
|
||||
if get_option('config_file')
|
||||
deps += [dependency('libconfig', version: '>=1.4', required: true)]
|
||||
|
||||
cflags += ['-DCONFIG_LIBCONFIG']
|
||||
srcs += [ 'config_libconfig.c' ]
|
||||
endif
|
||||
if get_option('regex')
|
||||
pcre = dependency('libpcre', required: true)
|
||||
cflags += ['-DCONFIG_REGEX_PCRE']
|
||||
if pcre.version().version_compare('>=8.20')
|
||||
cflags += ['-DCONFIG_REGEX_PCRE_JIT']
|
||||
endif
|
||||
deps += [pcre]
|
||||
endif
|
||||
|
||||
if get_option('vsync_drm')
|
||||
cflags += ['-DCONFIG_VSYNC_DRM']
|
||||
deps += [dependency('libdrm', required: true)]
|
||||
endif
|
||||
|
||||
if get_option('opengl')
|
||||
cflags += ['-DCONFIG_OPENGL', '-DGL_GLEXT_PROTOTYPES']
|
||||
deps += [dependency('gl', required: true)]
|
||||
srcs += [ 'opengl.c' ]
|
||||
endif
|
||||
|
||||
if get_option('dbus')
|
||||
cflags += ['-DCONFIG_DBUS']
|
||||
deps += [dependency('dbus-1', required: true)]
|
||||
srcs += [ 'dbus.c' ]
|
||||
endif
|
||||
|
||||
if get_option('xrescheck')
|
||||
cflags += ['-DDEBUG_XRC']
|
||||
srcs += [ 'xrescheck.c' ]
|
||||
endif
|
||||
|
||||
if get_option('unittest')
|
||||
cflags += ['-DUNIT_TEST']
|
||||
endif
|
||||
|
||||
host_system = host_machine.system()
|
||||
if host_system == 'linux'
|
||||
cflags += ['-DHAS_INOTIFY']
|
||||
elif (host_system == 'freebsd' or host_system == 'netbsd' or
|
||||
host_system == 'dragonfly' or host_system == 'openbsd')
|
||||
cflags += ['-DHAS_KQUEUE']
|
||||
endif
|
||||
|
||||
subdir('backend')
|
||||
|
||||
picom = executable('picom', srcs, c_args: cflags,
|
||||
dependencies: [ base_deps, deps, test_h_dep ],
|
||||
install: true, include_directories: picom_inc)
|
||||
|
||||
if get_option('unittest')
|
||||
test('picom unittest', picom, args: [ '--unittest' ])
|
||||
endif
|
||||
@@ -0,0 +1,75 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2019, Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
|
||||
/// Macro metaprogramming
|
||||
|
||||
#define _APPLY1(a, ...) a(__VA_ARGS__)
|
||||
#define _APPLY2(a, ...) a(__VA_ARGS__)
|
||||
#define _APPLY3(a, ...) a(__VA_ARGS__)
|
||||
#define _APPLY4(a, ...) a(__VA_ARGS__)
|
||||
|
||||
#define RIOTA1(x) x
|
||||
#define RIOTA2(x) RIOTA1(x##1), RIOTA1(x##0)
|
||||
#define RIOTA4(x) RIOTA2(x##1), RIOTA2(x##0)
|
||||
#define RIOTA8(x) RIOTA4(x##1), RIOTA4(x##0)
|
||||
#define RIOTA16(x) RIOTA8(x##1), RIOTA8(x##0)
|
||||
/// Generate a list containing 31, 30, ..., 0, in binary
|
||||
#define RIOTA32(x) RIOTA16(x##1), RIOTA16(x##0)
|
||||
|
||||
#define CONCAT2(a, b) a##b
|
||||
#define CONCAT1(a, b) CONCAT2(a, b)
|
||||
#define CONCAT(a, b) CONCAT1(a, b)
|
||||
|
||||
#define _ARGS_HEAD(head, ...) head
|
||||
#define _ARGS_SKIP4(_1, _2, _3, _4, ...) __VA_ARGS__
|
||||
#define _ARGS_SKIP8(...) _APPLY1(_ARGS_SKIP4, _ARGS_SKIP4(__VA_ARGS__))
|
||||
#define _ARGS_SKIP16(...) _APPLY2(_ARGS_SKIP8, _ARGS_SKIP8(__VA_ARGS__))
|
||||
#define _ARGS_SKIP32(...) _APPLY3(_ARGS_SKIP16, _ARGS_SKIP16(__VA_ARGS__))
|
||||
|
||||
/// Return the 33rd argument
|
||||
#define _ARG33(...) _APPLY4(_ARGS_HEAD, _ARGS_SKIP32(__VA_ARGS__))
|
||||
|
||||
/// Return the number of arguments passed in binary, handles at most 31 elements
|
||||
#define VA_ARGS_LENGTH(...) _ARG33(0, ##__VA_ARGS__, RIOTA32(0))
|
||||
|
||||
#define LIST_APPLY_000000(fn, sep, ...)
|
||||
#define LIST_APPLY_000001(fn, sep, x, ...) fn(x)
|
||||
#define LIST_APPLY_000010(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000001(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_000011(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000010(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_000100(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000011(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_000101(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000100(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_000110(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000101(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_000111(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000110(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001000(fn, sep, x, ...) fn(x) sep() LIST_APPLY_000111(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001001(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001000(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001010(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001001(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001011(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001010(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001100(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001011(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001101(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001100(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001110(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001101(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_001111(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001110(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010000(fn, sep, x, ...) fn(x) sep() LIST_APPLY_001111(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010001(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010000(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010010(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010001(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010011(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010010(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010100(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010011(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010101(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010100(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010110(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010101(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_010111(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010110(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011000(fn, sep, x, ...) fn(x) sep() LIST_APPLY_010111(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011001(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011000(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011010(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011001(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011011(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011010(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011100(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011011(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011101(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011100(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011110(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011101(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_011111(fn, sep, x, ...) fn(x) sep() LIST_APPLY_011110(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY_(N, fn, sep, ...) CONCAT(LIST_APPLY_, N)(fn, sep, __VA_ARGS__)
|
||||
#define LIST_APPLY(fn, sep, ...) \
|
||||
LIST_APPLY_(VA_ARGS_LENGTH(__VA_ARGS__), fn, sep, __VA_ARGS__)
|
||||
|
||||
#define SEP_COMMA() ,
|
||||
#define SEP_COLON() ;
|
||||
#define SEP_NONE()
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,246 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Compton - a compositor for X11
|
||||
*
|
||||
* Based on `xcompmgr` - Copyright (c) 2003, Keith Packard
|
||||
*
|
||||
* Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
* See LICENSE-mit for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "render.h"
|
||||
#include "win.h"
|
||||
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glx.h>
|
||||
#include <ctype.h>
|
||||
#include <locale.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
typedef struct {
|
||||
/// Fragment shader for blur.
|
||||
GLuint frag_shader;
|
||||
/// GLSL program for blur.
|
||||
GLuint prog;
|
||||
/// Location of uniform "offset_x" in blur GLSL program.
|
||||
GLint unifm_offset_x;
|
||||
/// Location of uniform "offset_y" in blur GLSL program.
|
||||
GLint unifm_offset_y;
|
||||
/// Location of uniform "factor_center" in blur GLSL program.
|
||||
GLint unifm_factor_center;
|
||||
} glx_blur_pass_t;
|
||||
|
||||
typedef struct {
|
||||
/// Fragment shader for rounded corners.
|
||||
GLuint frag_shader;
|
||||
/// GLSL program for rounded corners.
|
||||
GLuint prog;
|
||||
/// Location of uniform "radius" in rounded-corners GLSL program.
|
||||
GLint unifm_radius;
|
||||
/// Location of uniform "texcoord" in rounded-corners GLSL program.
|
||||
GLint unifm_texcoord;
|
||||
/// Location of uniform "texsize" in rounded-corners GLSL program.
|
||||
GLint unifm_texsize;
|
||||
/// Location of uniform "borderw" in rounded-corners GLSL program.
|
||||
GLint unifm_borderw;
|
||||
/// Location of uniform "borderc" in rounded-corners GLSL program.
|
||||
GLint unifm_borderc;
|
||||
/// Location of uniform "resolution" in rounded-corners GLSL program.
|
||||
GLint unifm_resolution;
|
||||
/// Location of uniform "texture_scr" in rounded-corners GLSL program.
|
||||
GLint unifm_tex_scr;
|
||||
|
||||
} glx_round_pass_t;
|
||||
|
||||
/// Structure containing GLX-dependent data for a session.
|
||||
typedef struct glx_session {
|
||||
// === OpenGL related ===
|
||||
/// GLX context.
|
||||
GLXContext context;
|
||||
/// Whether we have GL_ARB_texture_non_power_of_two.
|
||||
bool has_texture_non_power_of_two;
|
||||
/// Current GLX Z value.
|
||||
int z;
|
||||
glx_blur_pass_t *blur_passes;
|
||||
glx_round_pass_t *round_passes;
|
||||
} glx_session_t;
|
||||
|
||||
/// @brief Wrapper of a binded GLX texture.
|
||||
typedef struct _glx_texture {
|
||||
GLuint texture;
|
||||
GLXPixmap glpixmap;
|
||||
xcb_pixmap_t pixmap;
|
||||
GLenum target;
|
||||
int width;
|
||||
int height;
|
||||
bool y_inverted;
|
||||
} glx_texture_t;
|
||||
|
||||
#define CGLX_SESSION_INIT \
|
||||
{ .context = NULL }
|
||||
|
||||
bool glx_dim_dst(session_t *ps, int dx, int dy, int width, int height, int z,
|
||||
GLfloat factor, const region_t *reg_tgt);
|
||||
|
||||
bool glx_render(session_t *ps, const glx_texture_t *ptex, int x, int y, int dx, int dy,
|
||||
int width, int height, int z, double opacity, bool argb, bool neg,
|
||||
const region_t *reg_tgt, const glx_prog_main_t *pprogram);
|
||||
|
||||
bool glx_init(session_t *ps, bool need_render);
|
||||
|
||||
void glx_destroy(session_t *ps);
|
||||
|
||||
void glx_on_root_change(session_t *ps);
|
||||
|
||||
bool glx_init_blur(session_t *ps);
|
||||
|
||||
bool glx_init_rounded_corners(session_t *ps);
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
bool glx_load_prog_main(const char *vshader_str, const char *fshader_str,
|
||||
glx_prog_main_t *pprogram);
|
||||
#endif
|
||||
|
||||
bool glx_bind_pixmap(session_t *ps, glx_texture_t **pptex, xcb_pixmap_t pixmap, int width,
|
||||
int height, bool repeat, const struct glx_fbconfig_info *);
|
||||
|
||||
void glx_release_pixmap(session_t *ps, glx_texture_t *ptex);
|
||||
|
||||
bool glx_bind_texture(session_t *ps, glx_texture_t **pptex, int x, int y, int width, int height);
|
||||
|
||||
void glx_paint_pre(session_t *ps, region_t *preg) attr_nonnull(1, 2);
|
||||
|
||||
/**
|
||||
* Check if a texture is binded, or is binded to the given pixmap.
|
||||
*/
|
||||
static inline bool glx_tex_binded(const glx_texture_t *ptex, xcb_pixmap_t pixmap) {
|
||||
return ptex && ptex->glpixmap && ptex->texture && (!pixmap || pixmap == ptex->pixmap);
|
||||
}
|
||||
|
||||
void glx_set_clip(session_t *ps, const region_t *reg);
|
||||
|
||||
bool glx_blur_dst(session_t *ps, int dx, int dy, int width, int height, float z,
|
||||
GLfloat factor_center, const region_t *reg_tgt, glx_blur_cache_t *pbc);
|
||||
|
||||
bool glx_round_corners_dst(session_t *ps, struct managed_win *w,
|
||||
const glx_texture_t *ptex, int dx, int dy, int width,
|
||||
int height, float z, float cr, const region_t *reg_tgt);
|
||||
|
||||
GLuint glx_create_shader(GLenum shader_type, const char *shader_str);
|
||||
|
||||
GLuint glx_create_program(const GLuint *const shaders, int nshaders);
|
||||
|
||||
GLuint glx_create_program_from_str(const char *vert_shader_str, const char *frag_shader_str);
|
||||
|
||||
unsigned char *glx_take_screenshot(session_t *ps, int *out_length);
|
||||
|
||||
/**
|
||||
* Check if there's a GLX context.
|
||||
*/
|
||||
static inline bool glx_has_context(session_t *ps) {
|
||||
return ps->psglx && ps->psglx->context;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure we have a GLX context.
|
||||
*/
|
||||
static inline bool ensure_glx_context(session_t *ps) {
|
||||
// Create GLX context
|
||||
if (!glx_has_context(ps))
|
||||
glx_init(ps, false);
|
||||
|
||||
return ps->psglx->context;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a GLX texture.
|
||||
*/
|
||||
static inline void free_texture_r(session_t *ps attr_unused, GLuint *ptexture) {
|
||||
if (*ptexture) {
|
||||
assert(glx_has_context(ps));
|
||||
glDeleteTextures(1, ptexture);
|
||||
*ptexture = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a GLX Framebuffer object.
|
||||
*/
|
||||
static inline void free_glx_fbo(GLuint *pfbo) {
|
||||
if (*pfbo) {
|
||||
glDeleteFramebuffers(1, pfbo);
|
||||
*pfbo = 0;
|
||||
}
|
||||
assert(!*pfbo);
|
||||
}
|
||||
|
||||
/**
|
||||
* Free data in glx_blur_cache_t on resize.
|
||||
*/
|
||||
static inline void free_glx_bc_resize(session_t *ps, glx_blur_cache_t *pbc) {
|
||||
free_texture_r(ps, &pbc->textures[0]);
|
||||
free_texture_r(ps, &pbc->textures[1]);
|
||||
pbc->width = 0;
|
||||
pbc->height = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a glx_blur_cache_t
|
||||
*/
|
||||
static inline void free_glx_bc(session_t *ps, glx_blur_cache_t *pbc) {
|
||||
free_glx_fbo(&pbc->fbo);
|
||||
free_glx_bc_resize(ps, pbc);
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a glx_texture_t.
|
||||
*/
|
||||
static inline void free_texture(session_t *ps, glx_texture_t **pptex) {
|
||||
glx_texture_t *ptex = *pptex;
|
||||
|
||||
// Quit if there's nothing
|
||||
if (!ptex) {
|
||||
return;
|
||||
}
|
||||
|
||||
glx_release_pixmap(ps, ptex);
|
||||
|
||||
free_texture_r(ps, &ptex->texture);
|
||||
|
||||
// Free structure itself
|
||||
free(ptex);
|
||||
*pptex = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free GLX part of paint_t.
|
||||
*/
|
||||
static inline void free_paint_glx(session_t *ps, paint_t *ppaint) {
|
||||
free_texture(ps, &ppaint->ptex);
|
||||
#ifdef CONFIG_OPENGL
|
||||
free(ppaint->fbcfg);
|
||||
#endif
|
||||
ppaint->fbcfg = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Free GLX part of win.
|
||||
*/
|
||||
static inline void free_win_res_glx(session_t *ps, struct managed_win *w) {
|
||||
free_paint_glx(ps, &w->paint);
|
||||
free_paint_glx(ps, &w->shadow_paint);
|
||||
#ifdef CONFIG_OPENGL
|
||||
free_glx_bc(ps, &w->glx_blur_cache);
|
||||
free_texture(ps, &w->glx_texture_bg);
|
||||
#endif
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,37 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
|
||||
/// Parse command line options
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <xcb/render.h> // for xcb_render_fixed_t
|
||||
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "types.h"
|
||||
#include "win.h" // for wintype_t
|
||||
|
||||
typedef struct session session_t;
|
||||
|
||||
/// Get config options that are needed to parse the rest of the options
|
||||
/// Return true if we should quit
|
||||
bool get_early_config(int argc, char *const *argv, char **config_file, bool *all_xerrors,
|
||||
bool *fork, int *exit_code);
|
||||
|
||||
/**
|
||||
* Process arguments and configuration files.
|
||||
*
|
||||
* Parameters:
|
||||
* shadow_enable = Carry overs from parse_config
|
||||
* fading_enable
|
||||
* conv_kern_hasneg
|
||||
* winopt_mask
|
||||
* Returns:
|
||||
* Whether configuration are processed successfully.
|
||||
*/
|
||||
bool must_use get_cfg(options_t *opt, int argc, char *const *argv, bool shadow_enable,
|
||||
bool fading_enable, bool conv_kern_hasneg,
|
||||
win_option_mask_t *winopt_mask);
|
||||
|
||||
// vim: set noet sw=8 ts=8:
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,115 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// Copyright (c)
|
||||
|
||||
// Throw everything in here.
|
||||
// !!! DON'T !!!
|
||||
|
||||
// === Includes ===
|
||||
|
||||
#include <locale.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <xcb/xproto.h>
|
||||
|
||||
#include <X11/Xutil.h>
|
||||
#include "backend/backend.h"
|
||||
#include "c2.h"
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "config.h"
|
||||
#include "log.h" // XXX clean up
|
||||
#include "region.h"
|
||||
#include "render.h"
|
||||
#include "types.h"
|
||||
#include "utils.h"
|
||||
#include "win.h"
|
||||
#include "x.h"
|
||||
|
||||
enum root_flags {
|
||||
ROOT_FLAGS_SCREEN_CHANGE = 1, // Received RandR screen change notify, we
|
||||
// use this to track refresh rate changes
|
||||
ROOT_FLAGS_CONFIGURED = 2 // Received configure notify on the root window
|
||||
};
|
||||
|
||||
// == Functions ==
|
||||
// TODO(yshui) move static inline functions that are only used in picom.c, into picom.c
|
||||
|
||||
void add_damage(session_t *ps, const region_t *damage);
|
||||
|
||||
uint32_t determine_evmask(session_t *ps, xcb_window_t wid, win_evmode_t mode);
|
||||
|
||||
void circulate_win(session_t *ps, xcb_circulate_notify_event_t *ce);
|
||||
|
||||
void root_damaged(session_t *ps);
|
||||
|
||||
void cxinerama_upd_scrs(session_t *ps);
|
||||
|
||||
void queue_redraw(session_t *ps);
|
||||
|
||||
void discard_ignore(session_t *ps, unsigned long sequence);
|
||||
|
||||
void set_root_flags(session_t *ps, uint64_t flags);
|
||||
|
||||
void quit(session_t *ps);
|
||||
|
||||
xcb_window_t session_get_target_window(session_t *);
|
||||
|
||||
uint8_t session_redirection_mode(session_t *ps);
|
||||
|
||||
/**
|
||||
* Set a <code>switch_t</code> array of all unset wintypes to true.
|
||||
*/
|
||||
static inline void wintype_arr_enable_unset(switch_t arr[]) {
|
||||
wintype_t i;
|
||||
|
||||
for (i = 0; i < NUM_WINTYPES; ++i)
|
||||
if (UNSET == arr[i])
|
||||
arr[i] = ON;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a window ID exists in an array of window IDs.
|
||||
*
|
||||
* @param arr the array of window IDs
|
||||
* @param count amount of elements in the array
|
||||
* @param wid window ID to search for
|
||||
*/
|
||||
static inline bool array_wid_exists(const xcb_window_t *arr, int count, xcb_window_t wid) {
|
||||
while (count--) {
|
||||
if (arr[count] == wid) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy a condition list.
|
||||
*/
|
||||
static inline void free_wincondlst(c2_lptr_t **pcondlst) {
|
||||
while ((*pcondlst = c2_free_lptr(*pcondlst)))
|
||||
continue;
|
||||
}
|
||||
|
||||
#ifndef CONFIG_OPENGL
|
||||
static inline void free_paint_glx(session_t *ps attr_unused, paint_t *p attr_unused) {
|
||||
}
|
||||
static inline void
|
||||
free_win_res_glx(session_t *ps attr_unused, struct managed_win *w attr_unused) {
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Dump an drawable's info.
|
||||
*/
|
||||
static inline void dump_drawable(session_t *ps, xcb_drawable_t drawable) {
|
||||
auto r = xcb_get_geometry_reply(ps->c, xcb_get_geometry(ps->c, drawable), NULL);
|
||||
if (!r) {
|
||||
log_trace("Drawable %#010x: Failed", drawable);
|
||||
return;
|
||||
}
|
||||
log_trace("Drawable %#010x: x = %u, y = %u, wid = %u, hei = %d, b = %u, d = %u",
|
||||
drawable, r->x, r->y, r->width, r->height, r->border_width, r->depth);
|
||||
free(r);
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
// modulemap
|
||||
|
||||
module compiler {
|
||||
header "compiler.h"
|
||||
}
|
||||
module string_utils {
|
||||
header "string_utils.h"
|
||||
}
|
||||
module dbus {
|
||||
header "dbus.h"
|
||||
}
|
||||
module kernel {
|
||||
header "kernel.h"
|
||||
}
|
||||
module utils {
|
||||
// Has macros expands to calloc/malloc
|
||||
header "utils.h"
|
||||
export libc.stdlib
|
||||
}
|
||||
module region {
|
||||
header "region.h"
|
||||
}
|
||||
module picom {
|
||||
header "picom.h"
|
||||
}
|
||||
module types {
|
||||
header "types.h"
|
||||
}
|
||||
module c2 {
|
||||
header "c2.h"
|
||||
}
|
||||
module render {
|
||||
header "render.h"
|
||||
}
|
||||
module options {
|
||||
header "options.h"
|
||||
}
|
||||
module opengl {
|
||||
header "opengl.h"
|
||||
}
|
||||
module diagnostic {
|
||||
header "diagnostic.h"
|
||||
}
|
||||
module win_defs {
|
||||
header "win_defs.h"
|
||||
}
|
||||
module win {
|
||||
header "win.h"
|
||||
export win_defs
|
||||
}
|
||||
module log {
|
||||
header "log.h"
|
||||
export compiler
|
||||
}
|
||||
module x {
|
||||
header "x.h"
|
||||
}
|
||||
module vsync {
|
||||
header "vsync.h"
|
||||
}
|
||||
module common {
|
||||
header "common.h"
|
||||
}
|
||||
module config {
|
||||
header "config.h"
|
||||
}
|
||||
module xrescheck {
|
||||
header "xrescheck.h"
|
||||
}
|
||||
module cache {
|
||||
header "cache.h"
|
||||
}
|
||||
module backend {
|
||||
module gl {
|
||||
module gl_common {
|
||||
header "backend/gl/gl_common.h"
|
||||
}
|
||||
module glx {
|
||||
header "backend/gl/glx.h"
|
||||
export GL.glx
|
||||
}
|
||||
}
|
||||
module backend {
|
||||
header "backend/backend.h"
|
||||
}
|
||||
module backend_common {
|
||||
header "backend/backend_common.h"
|
||||
}
|
||||
}
|
||||
module xcb [system] {
|
||||
module xcb {
|
||||
header "/usr/include/xcb/xcb.h"
|
||||
export *
|
||||
}
|
||||
module randr {
|
||||
header "/usr/include/xcb/randr.h"
|
||||
export *
|
||||
}
|
||||
module render {
|
||||
header "/usr/include/xcb/render.h"
|
||||
export *
|
||||
}
|
||||
module sync {
|
||||
header "/usr/include/xcb/sync.h"
|
||||
export *
|
||||
}
|
||||
module composite {
|
||||
header "/usr/include/xcb/composite.h"
|
||||
export *
|
||||
}
|
||||
module xfixes {
|
||||
header "/usr/include/xcb/xfixes.h"
|
||||
export *
|
||||
}
|
||||
module damage {
|
||||
header "/usr/include/xcb/damage.h"
|
||||
export *
|
||||
}
|
||||
module xproto {
|
||||
header "/usr/include/xcb/xproto.h"
|
||||
export *
|
||||
}
|
||||
module present {
|
||||
header "/usr/include/xcb/present.h"
|
||||
}
|
||||
module util {
|
||||
module render {
|
||||
header "/usr/include/xcb/xcb_renderutil.h"
|
||||
export *
|
||||
}
|
||||
}
|
||||
}
|
||||
module X11 [system] {
|
||||
module Xlib {
|
||||
header "/usr/include/X11/Xlib.h"
|
||||
export *
|
||||
}
|
||||
module Xutil {
|
||||
header "/usr/include/X11/Xutil.h"
|
||||
export *
|
||||
}
|
||||
}
|
||||
module GL [system] {
|
||||
module glx {
|
||||
header "/usr/include/GL/glx.h"
|
||||
export *
|
||||
}
|
||||
module gl {
|
||||
header "/usr/include/GL/gl.h"
|
||||
export *
|
||||
}
|
||||
}
|
||||
module libc [system] {
|
||||
export *
|
||||
module assert {
|
||||
export *
|
||||
textual header "/usr/include/assert.h"
|
||||
}
|
||||
module string {
|
||||
export *
|
||||
header "/usr/include/string.h"
|
||||
}
|
||||
module ctype {
|
||||
export *
|
||||
header "/usr/include/ctype.h"
|
||||
}
|
||||
module errno {
|
||||
export *
|
||||
header "/usr/include/errno.h"
|
||||
}
|
||||
module fenv {
|
||||
export *
|
||||
header "/usr/include/fenv.h"
|
||||
}
|
||||
module inttypes {
|
||||
export *
|
||||
header "/usr/include/inttypes.h"
|
||||
}
|
||||
module math {
|
||||
export *
|
||||
header "/usr/include/math.h"
|
||||
}
|
||||
module setjmp {
|
||||
export *
|
||||
header "/usr/include/setjmp.h"
|
||||
}
|
||||
module stdio {
|
||||
export *
|
||||
header "/usr/include/stdio.h"
|
||||
}
|
||||
|
||||
module stdlib [system] {
|
||||
export *
|
||||
header "/usr/include/stdlib.h"
|
||||
}
|
||||
}
|
||||
|
||||
// glib specific header. In it's own module because it
|
||||
// doesn't exist on some systems with unpatched glib 2.26+
|
||||
module "xlocale.h" [system] {
|
||||
export *
|
||||
header "/usr/include/xlocale.h"
|
||||
}
|
||||
|
||||
// System header that we have difficult with merging.
|
||||
module "sys_types.h" [system] {
|
||||
export *
|
||||
header "/usr/include/sys/types.h"
|
||||
}
|
||||
|
||||
module "signal.h" [system] {
|
||||
export *
|
||||
header "/usr/include/signal.h"
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
#include <pixman.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "log.h"
|
||||
#include "utils.h"
|
||||
|
||||
typedef struct pixman_region32 pixman_region32_t;
|
||||
typedef struct pixman_box32 pixman_box32_t;
|
||||
typedef pixman_region32_t region_t;
|
||||
typedef pixman_box32_t rect_t;
|
||||
|
||||
RC_TYPE(region_t, rc_region, pixman_region32_init, pixman_region32_fini, static inline)
|
||||
|
||||
static inline void dump_region(const region_t *x) {
|
||||
if (log_get_level_tls() < LOG_LEVEL_TRACE) {
|
||||
return;
|
||||
}
|
||||
int nrects;
|
||||
const rect_t *rects = pixman_region32_rectangles((region_t *)x, &nrects);
|
||||
log_trace("nrects: %d", nrects);
|
||||
for (int i = 0; i < nrects; i++)
|
||||
log_trace("(%d, %d) - (%d, %d)", rects[i].x1, rects[i].y1, rects[i].x2,
|
||||
rects[i].y2);
|
||||
}
|
||||
|
||||
/// Convert one xcb rectangle to our rectangle type
|
||||
static inline rect_t from_x_rect(const xcb_rectangle_t *rect) {
|
||||
return (rect_t){
|
||||
.x1 = rect->x,
|
||||
.y1 = rect->y,
|
||||
.x2 = rect->x + rect->width,
|
||||
.y2 = rect->y + rect->height,
|
||||
};
|
||||
}
|
||||
|
||||
/// Convert an array of xcb rectangles to our rectangle type
|
||||
/// Returning an array that needs to be freed
|
||||
static inline rect_t *from_x_rects(int nrects, const xcb_rectangle_t *rects) {
|
||||
rect_t *ret = ccalloc(nrects, rect_t);
|
||||
for (int i = 0; i < nrects; i++) {
|
||||
ret[i] = from_x_rect(rects + i);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resize a region.
|
||||
*/
|
||||
static inline void _resize_region(const region_t *region, region_t *output, int dx,
|
||||
int dy) {
|
||||
if (!region || !output) {
|
||||
return;
|
||||
}
|
||||
if (!dx && !dy) {
|
||||
if (region != output) {
|
||||
pixman_region32_copy(output, (region_t *)region);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Loop through all rectangles
|
||||
int nrects;
|
||||
int nnewrects = 0;
|
||||
const rect_t *rects = pixman_region32_rectangles((region_t *)region, &nrects);
|
||||
auto newrects = ccalloc(nrects, rect_t);
|
||||
for (int i = 0; i < nrects; i++) {
|
||||
int x1 = rects[i].x1 - dx;
|
||||
int y1 = rects[i].y1 - dy;
|
||||
int x2 = rects[i].x2 + dx;
|
||||
int y2 = rects[i].y2 + dy;
|
||||
int wid = x2 - x1;
|
||||
int hei = y2 - y1;
|
||||
if (wid <= 0 || hei <= 0) {
|
||||
continue;
|
||||
}
|
||||
newrects[nnewrects] =
|
||||
(rect_t){.x1 = x1, .x2 = x2, .y1 = y1, .y2 = y2};
|
||||
++nnewrects;
|
||||
}
|
||||
|
||||
pixman_region32_fini(output);
|
||||
pixman_region32_init_rects(output, newrects, nnewrects);
|
||||
|
||||
free(newrects);
|
||||
}
|
||||
|
||||
static inline region_t resize_region(const region_t *region, int dx, int dy) {
|
||||
region_t ret;
|
||||
pixman_region32_init(&ret);
|
||||
_resize_region(region, &ret, dx, dy);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void resize_region_in_place(region_t *region, int dx, int dy) {
|
||||
return _resize_region(region, region, dx, dy);
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,50 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb.h>
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include "backend/gl/glx.h"
|
||||
#endif
|
||||
#include "region.h"
|
||||
|
||||
typedef struct _glx_texture glx_texture_t;
|
||||
typedef struct glx_prog_main glx_prog_main_t;
|
||||
typedef struct session session_t;
|
||||
|
||||
struct managed_win;
|
||||
|
||||
typedef struct paint {
|
||||
xcb_pixmap_t pixmap;
|
||||
xcb_render_picture_t pict;
|
||||
glx_texture_t *ptex;
|
||||
#ifdef CONFIG_OPENGL
|
||||
struct glx_fbconfig_info *fbcfg;
|
||||
#endif
|
||||
} paint_t;
|
||||
|
||||
typedef struct clip {
|
||||
xcb_render_picture_t pict;
|
||||
int x;
|
||||
int y;
|
||||
} clip_t;
|
||||
|
||||
void render(session_t *ps, int x, int y, int dx, int dy, int w, int h, int fullw,
|
||||
int fullh, double opacity, bool argb, bool neg, int cr,
|
||||
xcb_render_picture_t pict, glx_texture_t *ptex, const region_t *reg_paint,
|
||||
const glx_prog_main_t *pprogram, clip_t *clip);
|
||||
void paint_one(session_t *ps, struct managed_win *w, const region_t *reg_paint);
|
||||
|
||||
void paint_all(session_t *ps, struct managed_win *const t, bool ignore_damage);
|
||||
|
||||
void free_picture(xcb_connection_t *c, xcb_render_picture_t *p);
|
||||
|
||||
void free_paint(session_t *ps, paint_t *ppaint);
|
||||
void free_root_tile(session_t *ps);
|
||||
|
||||
bool init_render(session_t *ps);
|
||||
void deinit_render(session_t *ps);
|
||||
|
||||
int maximum_buffer_age(session_t *);
|
||||
@@ -0,0 +1,129 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <test.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "string_utils.h"
|
||||
#include "utils.h"
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
|
||||
// gcc warns about legitimate strncpy in mstrjoin and mstrextend
|
||||
// strncpy(str, src1, len1) intentional truncates the null byte from src1.
|
||||
// strncpy(str+len1, src2, len2) uses bound depends on the source argument,
|
||||
// but str is allocated with len1+len2+1, so this strncpy can't overflow
|
||||
#pragma GCC diagnostic ignored "-Wpragmas"
|
||||
#pragma GCC diagnostic ignored "-Wstringop-truncation"
|
||||
#pragma GCC diagnostic ignored "-Wstringop-overflow"
|
||||
|
||||
/**
|
||||
* Allocate the space and join two strings.
|
||||
*/
|
||||
char *mstrjoin(const char *src1, const char *src2) {
|
||||
auto len1 = strlen(src1);
|
||||
auto len2 = strlen(src2);
|
||||
auto len = len1 + len2 + 1;
|
||||
auto str = ccalloc(len, char);
|
||||
|
||||
strncpy(str, src1, len1);
|
||||
strncpy(str + len1, src2, len2);
|
||||
str[len - 1] = '\0';
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
TEST_CASE(mstrjoin) {
|
||||
char *str = mstrjoin("asdf", "qwer");
|
||||
TEST_STREQUAL(str, "asdfqwer");
|
||||
free(str);
|
||||
|
||||
str = mstrjoin("", "qwer");
|
||||
TEST_STREQUAL(str, "qwer");
|
||||
free(str);
|
||||
|
||||
str = mstrjoin("asdf", "");
|
||||
TEST_STREQUAL(str, "asdf");
|
||||
free(str);
|
||||
}
|
||||
|
||||
/**
|
||||
* Concatenate a string on heap with another string.
|
||||
*/
|
||||
void mstrextend(char **psrc1, const char *src2) {
|
||||
if (!*psrc1) {
|
||||
*psrc1 = strdup(src2);
|
||||
return;
|
||||
}
|
||||
|
||||
auto len1 = strlen(*psrc1);
|
||||
auto len2 = strlen(src2);
|
||||
auto len = len1 + len2 + 1;
|
||||
*psrc1 = crealloc(*psrc1, len);
|
||||
|
||||
strncpy(*psrc1 + len1, src2, len2);
|
||||
(*psrc1)[len - 1] = '\0';
|
||||
}
|
||||
|
||||
TEST_CASE(mstrextend) {
|
||||
char *str1 = NULL;
|
||||
mstrextend(&str1, "asdf");
|
||||
TEST_STREQUAL(str1, "asdf");
|
||||
|
||||
mstrextend(&str1, "asd");
|
||||
TEST_STREQUAL(str1, "asdfasd");
|
||||
|
||||
mstrextend(&str1, "");
|
||||
TEST_STREQUAL(str1, "asdfasd");
|
||||
free(str1);
|
||||
}
|
||||
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
/// Parse a floating point number of form (+|-)?[0-9]*(\.[0-9]*)
|
||||
double strtod_simple(const char *src, const char **end) {
|
||||
double neg = 1;
|
||||
if (*src == '-') {
|
||||
neg = -1;
|
||||
src++;
|
||||
} else if (*src == '+') {
|
||||
src++;
|
||||
}
|
||||
|
||||
double ret = 0;
|
||||
while (*src >= '0' && *src <= '9') {
|
||||
ret = ret * 10 + (*src - '0');
|
||||
src++;
|
||||
}
|
||||
|
||||
if (*src == '.') {
|
||||
double frac = 0, mult = 0.1;
|
||||
src++;
|
||||
while (*src >= '0' && *src <= '9') {
|
||||
frac += mult * (*src - '0');
|
||||
mult *= 0.1;
|
||||
src++;
|
||||
}
|
||||
ret += frac;
|
||||
}
|
||||
|
||||
*end = src;
|
||||
return ret * neg;
|
||||
}
|
||||
|
||||
TEST_CASE(strtod_simple) {
|
||||
const char *end;
|
||||
double result = strtod_simple("1.0", &end);
|
||||
TEST_EQUAL(result, 1);
|
||||
TEST_EQUAL(*end, '\0');
|
||||
|
||||
result = strtod_simple("-1.0", &end);
|
||||
TEST_EQUAL(result, -1);
|
||||
TEST_EQUAL(*end, '\0');
|
||||
|
||||
result = strtod_simple("+.5", &end);
|
||||
TEST_EQUAL(result, 0.5);
|
||||
TEST_EQUAL(*end, '\0');
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
#include <ctype.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include "compiler.h"
|
||||
|
||||
#define mstrncmp(s1, s2) strncmp((s1), (s2), strlen(s1))
|
||||
|
||||
char *mstrjoin(const char *src1, const char *src2);
|
||||
char *mstrjoin3(const char *src1, const char *src2, const char *src3);
|
||||
void mstrextend(char **psrc1, const char *src2);
|
||||
|
||||
/// Parse a floating point number of form (+|-)?[0-9]*(\.[0-9]*)
|
||||
double strtod_simple(const char *, const char **);
|
||||
|
||||
static inline int uitostr(unsigned int n, char *buf) {
|
||||
int ret = 0;
|
||||
unsigned int tmp = n;
|
||||
while (tmp > 0) {
|
||||
tmp /= 10;
|
||||
ret++;
|
||||
}
|
||||
|
||||
if (ret == 0)
|
||||
ret = 1;
|
||||
|
||||
int pos = ret;
|
||||
while (pos--) {
|
||||
buf[pos] = (char)(n % 10 + '0');
|
||||
n /= 10;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline const char *skip_space_const(const char *src) {
|
||||
if (!src)
|
||||
return NULL;
|
||||
while (*src && isspace((unsigned char)*src))
|
||||
src++;
|
||||
return src;
|
||||
}
|
||||
|
||||
static inline char *skip_space_mut(char *src) {
|
||||
if (!src)
|
||||
return NULL;
|
||||
while (*src && isspace((unsigned char)*src))
|
||||
src++;
|
||||
return src;
|
||||
}
|
||||
|
||||
#define skip_space(x) \
|
||||
_Generic((x), char * : skip_space_mut, const char * : skip_space_const)(x)
|
||||
@@ -0,0 +1,32 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
#pragma once
|
||||
|
||||
/// Some common types
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/// Enumeration type to represent switches.
|
||||
typedef enum {
|
||||
OFF = 0, // false
|
||||
ON, // true
|
||||
UNSET
|
||||
} switch_t;
|
||||
|
||||
/// A structure representing margins around a rectangle.
|
||||
typedef struct {
|
||||
int top;
|
||||
int left;
|
||||
int bottom;
|
||||
int right;
|
||||
} margin_t;
|
||||
|
||||
struct color {
|
||||
double red, green, blue, alpha;
|
||||
};
|
||||
|
||||
typedef uint32_t opacity_t;
|
||||
|
||||
#define MARGIN_INIT \
|
||||
{ 0, 0, 0, 0 }
|
||||
@@ -0,0 +1,7 @@
|
||||
#pragma once
|
||||
|
||||
#include <uthash.h>
|
||||
|
||||
#define HASH_ITER2(head, el) \
|
||||
for (__typeof__(head) el = (head), __tmp = el != NULL ? el->hh.next : NULL; \
|
||||
el != NULL; el = __tmp, __tmp = el != NULL ? el->hh.next : NULL)
|
||||
@@ -0,0 +1,51 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/uio.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "string_utils.h"
|
||||
#include "utils.h"
|
||||
|
||||
/// Report allocation failure without allocating memory
|
||||
void report_allocation_failure(const char *func, const char *file, unsigned int line) {
|
||||
// Since memory allocation failed, we try to print this error message without any
|
||||
// memory allocation. Since logging framework allocates memory (and might even
|
||||
// have not been initialized yet), so we can't use it.
|
||||
char buf[11];
|
||||
int llen = uitostr(line, buf);
|
||||
const char msg1[] = " has failed to allocate memory, ";
|
||||
const char msg2[] = ". Aborting...\n";
|
||||
const struct iovec v[] = {
|
||||
{.iov_base = (void *)func, .iov_len = strlen(func)},
|
||||
{.iov_base = "()", .iov_len = 2},
|
||||
{.iov_base = (void *)msg1, .iov_len = sizeof(msg1) - 1},
|
||||
{.iov_base = "at ", .iov_len = 3},
|
||||
{.iov_base = (void *)file, .iov_len = strlen(file)},
|
||||
{.iov_base = ":", .iov_len = 1},
|
||||
{.iov_base = buf, .iov_len = (size_t)llen},
|
||||
{.iov_base = (void *)msg2, .iov_len = sizeof(msg2) - 1},
|
||||
};
|
||||
|
||||
writev(STDERR_FILENO, v, ARR_SIZE(v));
|
||||
abort();
|
||||
|
||||
unreachable;
|
||||
}
|
||||
|
||||
///
|
||||
/// Calculates next closest power of two of 32bit integer n
|
||||
/// ref: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
|
||||
///
|
||||
int next_power_of_two(int n)
|
||||
{
|
||||
n--;
|
||||
n |= n >> 1;
|
||||
n |= n >> 2;
|
||||
n |= n >> 4;
|
||||
n |= n >> 8;
|
||||
n |= n >> 16;
|
||||
n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,310 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#pragma once
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <test.h>
|
||||
|
||||
#include <time.h>
|
||||
|
||||
#include "compiler.h"
|
||||
#include "types.h"
|
||||
|
||||
#define ARR_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
|
||||
|
||||
#ifdef __FAST_MATH__
|
||||
#warning Use of -ffast-math can cause rendering error or artifacts, \
|
||||
therefore it is not recommended.
|
||||
#endif
|
||||
|
||||
#ifdef __clang__
|
||||
__attribute__((optnone))
|
||||
#else
|
||||
__attribute__((optimize("-fno-fast-math")))
|
||||
#endif
|
||||
static inline bool
|
||||
safe_isnan(double a) {
|
||||
return __builtin_isnan(a);
|
||||
}
|
||||
|
||||
/// Same as assert(false), but make sure we abort _even in release builds_.
|
||||
/// Silence compiler warning caused by release builds making some code paths reachable.
|
||||
#define BUG() \
|
||||
do { \
|
||||
assert(false); \
|
||||
abort(); \
|
||||
} while (0)
|
||||
#define CHECK_EXPR(...) ((void)0)
|
||||
/// Same as assert, but evaluates the expression even in release builds
|
||||
#define CHECK(expr) \
|
||||
do { \
|
||||
auto _ = (expr); \
|
||||
/* make sure the original expression appears in the assertion message */ \
|
||||
assert((CHECK_EXPR(expr), _)); \
|
||||
(void)_; \
|
||||
} while (0)
|
||||
|
||||
/// Asserts that var is within [lower, upper]. Silence compiler warning about expressions
|
||||
/// being always true or false.
|
||||
#define ASSERT_IN_RANGE(var, lower, upper) \
|
||||
do { \
|
||||
auto __tmp attr_unused = (var); \
|
||||
_Pragma("GCC diagnostic push"); \
|
||||
_Pragma("GCC diagnostic ignored \"-Wtype-limits\""); \
|
||||
assert(__tmp >= lower); \
|
||||
assert(__tmp <= upper); \
|
||||
_Pragma("GCC diagnostic pop"); \
|
||||
} while (0)
|
||||
|
||||
/// Asserts that var >= lower. Silence compiler warning about expressions
|
||||
/// being always true or false.
|
||||
#define ASSERT_GEQ(var, lower) \
|
||||
do { \
|
||||
auto __tmp attr_unused = (var); \
|
||||
_Pragma("GCC diagnostic push"); \
|
||||
_Pragma("GCC diagnostic ignored \"-Wtype-limits\""); \
|
||||
assert(__tmp >= lower); \
|
||||
_Pragma("GCC diagnostic pop"); \
|
||||
} while (0)
|
||||
|
||||
// Some macros for checked cast
|
||||
// Note these macros are not complete, as in, they won't work for every integer types. But
|
||||
// they are good enough for our use cases.
|
||||
|
||||
#define to_int_checked(val) \
|
||||
({ \
|
||||
int64_t tmp = (val); \
|
||||
ASSERT_IN_RANGE(tmp, INT_MIN, INT_MAX); \
|
||||
(int)tmp; \
|
||||
})
|
||||
|
||||
#define to_char_checked(val) \
|
||||
({ \
|
||||
int64_t tmp = (val); \
|
||||
ASSERT_IN_RANGE(tmp, CHAR_MIN, CHAR_MAX); \
|
||||
(char)tmp; \
|
||||
})
|
||||
|
||||
#define to_u16_checked(val) \
|
||||
({ \
|
||||
auto tmp = (val); \
|
||||
ASSERT_IN_RANGE(tmp, 0, UINT16_MAX); \
|
||||
(uint16_t) tmp; \
|
||||
})
|
||||
|
||||
#define to_i16_checked(val) \
|
||||
({ \
|
||||
int64_t tmp = (val); \
|
||||
ASSERT_IN_RANGE(tmp, INT16_MIN, INT16_MAX); \
|
||||
(int16_t) tmp; \
|
||||
})
|
||||
|
||||
#define to_u32_checked(val) \
|
||||
({ \
|
||||
auto tmp = (val); \
|
||||
int64_t max attr_unused = UINT32_MAX; /* silence clang tautological \
|
||||
comparison warning*/ \
|
||||
ASSERT_IN_RANGE(tmp, 0, max); \
|
||||
(uint32_t) tmp; \
|
||||
})
|
||||
/**
|
||||
* Normalize an int value to a specific range.
|
||||
*
|
||||
* @param i int value to normalize
|
||||
* @param min minimal value
|
||||
* @param max maximum value
|
||||
* @return normalized value
|
||||
*/
|
||||
static inline int attr_const normalize_i_range(int i, int min, int max) {
|
||||
if (i > max)
|
||||
return max;
|
||||
if (i < min)
|
||||
return min;
|
||||
return i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Linearly interpolate from a range into another.
|
||||
*
|
||||
* @param a,b first range
|
||||
* @param c,d second range
|
||||
* @param value value to interpolate, should be in range [a,b]
|
||||
* @return interpolated value in range [c,d]
|
||||
*/
|
||||
static inline int attr_const lerp_range(int a, int b, int c, int d, int value) {
|
||||
ASSERT_IN_RANGE(value, a, b);
|
||||
return (d-c)*(value-a)/(b-a) + c;
|
||||
}
|
||||
|
||||
#define min2(a, b) ((a) > (b) ? (b) : (a))
|
||||
#define max2(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define min3(a, b, c) min2(a, min2(b, c))
|
||||
|
||||
/// clamp `val` into interval [min, max]
|
||||
#define clamp(val, min, max) max2(min2(val, max), min)
|
||||
|
||||
/**
|
||||
* Normalize a double value to a specific range.
|
||||
*
|
||||
* @param d double value to normalize
|
||||
* @param min minimal value
|
||||
* @param max maximum value
|
||||
* @return normalized value
|
||||
*/
|
||||
static inline double attr_const normalize_d_range(double d, double min, double max) {
|
||||
if (d > max)
|
||||
return max;
|
||||
if (d < min)
|
||||
return min;
|
||||
return d;
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize a double value to 0.\ 0 - 1.\ 0.
|
||||
*
|
||||
* @param d double value to normalize
|
||||
* @return normalized value
|
||||
*/
|
||||
static inline double attr_const normalize_d(double d) {
|
||||
return normalize_d_range(d, 0.0, 1.0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a hex RGB string to RGB
|
||||
*/
|
||||
static inline struct color hex_to_rgb(const char *hex) {
|
||||
struct color rgb;
|
||||
// Ignore the # in front of the string
|
||||
const char *sane_hex = hex + 1;
|
||||
int hex_color = (int)strtol(sane_hex, NULL, 16);
|
||||
rgb.red = (float)(hex_color >> 16) / 256;
|
||||
rgb.green = (float)((hex_color & 0x00ff00) >> 8) / 256;
|
||||
rgb.blue = (float)(hex_color & 0x0000ff) / 256;
|
||||
|
||||
return rgb;
|
||||
}
|
||||
|
||||
attr_noret void
|
||||
report_allocation_failure(const char *func, const char *file, unsigned int line);
|
||||
|
||||
/**
|
||||
* @brief Quit if the passed-in pointer is empty.
|
||||
*/
|
||||
static inline void *
|
||||
allocchk_(const char *func_name, const char *file, unsigned int line, void *ptr) {
|
||||
if (unlikely(!ptr)) {
|
||||
report_allocation_failure(func_name, file, line);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/// @brief Wrapper of allocchk_().
|
||||
#define allocchk(ptr) allocchk_(__func__, __FILE__, __LINE__, ptr)
|
||||
|
||||
/// @brief Wrapper of malloc().
|
||||
#define cmalloc(type) ((type *)allocchk(malloc(sizeof(type))))
|
||||
|
||||
/// @brief Wrapper of malloc() that takes a size
|
||||
#define cvalloc(size) allocchk(malloc(size))
|
||||
|
||||
/// @brief Wrapper of calloc().
|
||||
#define ccalloc(nmemb, type) \
|
||||
({ \
|
||||
auto tmp = (nmemb); \
|
||||
ASSERT_GEQ(tmp, 0); \
|
||||
((type *)allocchk(calloc((size_t)tmp, sizeof(type)))); \
|
||||
})
|
||||
|
||||
/// @brief Wrapper of ealloc().
|
||||
#define crealloc(ptr, nmemb) \
|
||||
({ \
|
||||
auto tmp = (nmemb); \
|
||||
ASSERT_GEQ(tmp, 0); \
|
||||
((__typeof__(ptr))allocchk(realloc((ptr), (size_t)tmp * sizeof(*(ptr))))); \
|
||||
})
|
||||
|
||||
/// RC_TYPE generates a reference counted type from `type`
|
||||
///
|
||||
/// parameters:
|
||||
/// name = the generated type will be called `name`_t.
|
||||
/// ctor = the constructor of `type`, will be called when
|
||||
/// a value of `type` is created. should take one
|
||||
/// argument of `type *`.
|
||||
/// dtor = the destructor. will be called when all reference
|
||||
/// is gone. has same signature as ctor
|
||||
/// Q = function qualifier. this is the qualifier that
|
||||
/// will be put before generated functions
|
||||
//
|
||||
/// functions generated:
|
||||
/// `name`_new: create a new reference counted object of `type`
|
||||
/// `name`_ref: increment the reference counter, return a
|
||||
/// reference to the object
|
||||
/// `name`_unref: decrement the reference counter. take a `type **`
|
||||
/// because it needs to nullify the reference.
|
||||
#define RC_TYPE(type, name, ctor, dtor, Q) \
|
||||
typedef struct { \
|
||||
type inner; \
|
||||
int ref_count; \
|
||||
} name##_internal_t; \
|
||||
typedef type name##_t; \
|
||||
Q type *name##_new(void) { \
|
||||
name##_internal_t *ret = cmalloc(name##_internal_t); \
|
||||
ctor((type *)ret); \
|
||||
ret->ref_count = 1; \
|
||||
return (type *)ret; \
|
||||
} \
|
||||
Q type *name##_ref(type *a) { \
|
||||
__auto_type b = (name##_internal_t *)a; \
|
||||
b->ref_count++; \
|
||||
return a; \
|
||||
} \
|
||||
Q void name##_unref(type **a) { \
|
||||
__auto_type b = (name##_internal_t *)*a; \
|
||||
if (!b) \
|
||||
return; \
|
||||
b->ref_count--; \
|
||||
if (!b->ref_count) { \
|
||||
dtor((type *)b); \
|
||||
free(b); \
|
||||
} \
|
||||
*a = NULL; \
|
||||
}
|
||||
|
||||
/// Generate prototypes for functions generated by RC_TYPE
|
||||
#define RC_TYPE_PROTO(type, name) \
|
||||
typedef type name##_t; \
|
||||
type *name##_new(void); \
|
||||
void name##_ref(type *a); \
|
||||
void name##_unref(type **a);
|
||||
|
||||
|
||||
///
|
||||
/// Calculates next closest power of two of 32bit integer n
|
||||
/// ref: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
|
||||
///
|
||||
int next_power_of_two(int n);
|
||||
|
||||
// Some versions of the Android libc do not have timespec_get(), use
|
||||
// clock_gettime() instead.
|
||||
#ifdef __ANDROID__
|
||||
|
||||
#ifndef TIME_UTC
|
||||
#define TIME_UTC 1
|
||||
#endif
|
||||
|
||||
static inline int timespec_get(struct timespec *ts, int base) {
|
||||
assert(base == TIME_UTC);
|
||||
return clock_gettime(CLOCK_REALTIME, ts);
|
||||
}
|
||||
#endif
|
||||
|
||||
// vim: set noet sw=8 ts=8 :
|
||||
@@ -0,0 +1,204 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
|
||||
/// Function pointers to init VSync modes.
|
||||
|
||||
#include "common.h"
|
||||
#include "log.h"
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include "backend/gl/glx.h"
|
||||
#include "opengl.h"
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_VSYNC_DRM
|
||||
#include <drm.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#endif
|
||||
|
||||
#include "config.h"
|
||||
#include "vsync.h"
|
||||
|
||||
#ifdef CONFIG_VSYNC_DRM
|
||||
/**
|
||||
* Wait for next VSync, DRM method.
|
||||
*
|
||||
* Stolen from:
|
||||
* https://github.com/MythTV/mythtv/blob/master/mythtv/libs/libmythtv/vsync.cpp
|
||||
*/
|
||||
static int vsync_drm_wait(session_t *ps) {
|
||||
int ret = -1;
|
||||
drm_wait_vblank_t vbl;
|
||||
|
||||
vbl.request.type = _DRM_VBLANK_RELATIVE, vbl.request.sequence = 1;
|
||||
|
||||
do {
|
||||
ret = ioctl(ps->drm_fd, DRM_IOCTL_WAIT_VBLANK, &vbl);
|
||||
vbl.request.type &= ~(uint)_DRM_VBLANK_RELATIVE;
|
||||
} while (ret && errno == EINTR);
|
||||
|
||||
if (ret)
|
||||
log_error("VBlank ioctl did not work, unimplemented in this drmver?");
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize DRM VSync.
|
||||
*
|
||||
* @return true for success, false otherwise
|
||||
*/
|
||||
static bool vsync_drm_init(session_t *ps) {
|
||||
// Should we always open card0?
|
||||
if (ps->drm_fd < 0 && (ps->drm_fd = open("/dev/dri/card0", O_RDWR)) < 0) {
|
||||
log_error("Failed to open device.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (vsync_drm_wait(ps))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
/**
|
||||
* Initialize OpenGL VSync.
|
||||
*
|
||||
* Stolen from:
|
||||
* http://git.tuxfamily.org/?p=ccm/cairocompmgr.git;a=commitdiff;h=efa4ceb97da501e8630ca7f12c99b1dce853c73e
|
||||
* Possible original source: http://www.inb.uni-luebeck.de/~boehme/xvideo_sync.html
|
||||
*
|
||||
* @return true for success, false otherwise
|
||||
*/
|
||||
static bool vsync_opengl_init(session_t *ps) {
|
||||
if (!ensure_glx_context(ps))
|
||||
return false;
|
||||
|
||||
return glxext.has_GLX_SGI_video_sync;
|
||||
}
|
||||
|
||||
static bool vsync_opengl_oml_init(session_t *ps) {
|
||||
if (!ensure_glx_context(ps))
|
||||
return false;
|
||||
|
||||
return glxext.has_GLX_OML_sync_control;
|
||||
}
|
||||
|
||||
static inline bool vsync_opengl_swc_swap_interval(session_t *ps, int interval) {
|
||||
if (glxext.has_GLX_MESA_swap_control)
|
||||
return glXSwapIntervalMESA((uint)interval) == 0;
|
||||
else if (glxext.has_GLX_SGI_swap_control)
|
||||
return glXSwapIntervalSGI(interval) == 0;
|
||||
else if (glxext.has_GLX_EXT_swap_control) {
|
||||
GLXDrawable d = glXGetCurrentDrawable();
|
||||
if (d == None) {
|
||||
// We don't have a context??
|
||||
return false;
|
||||
}
|
||||
glXSwapIntervalEXT(ps->dpy, glXGetCurrentDrawable(), interval);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool vsync_opengl_swc_init(session_t *ps) {
|
||||
if (!bkend_use_glx(ps)) {
|
||||
log_error("OpenGL swap control requires the GLX backend.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!vsync_opengl_swc_swap_interval(ps, 1)) {
|
||||
log_error("Failed to load a swap control extension.");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for next VSync, OpenGL method.
|
||||
*/
|
||||
static int vsync_opengl_wait(session_t *ps attr_unused) {
|
||||
unsigned vblank_count = 0;
|
||||
|
||||
glXGetVideoSyncSGI(&vblank_count);
|
||||
glXWaitVideoSyncSGI(2, (vblank_count + 1) % 2, &vblank_count);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wait for next VSync, OpenGL OML method.
|
||||
*
|
||||
* https://mail.gnome.org/archives/clutter-list/2012-November/msg00031.html
|
||||
*/
|
||||
static int vsync_opengl_oml_wait(session_t *ps) {
|
||||
int64_t ust = 0, msc = 0, sbc = 0;
|
||||
|
||||
glXGetSyncValuesOML(ps->dpy, ps->reg_win, &ust, &msc, &sbc);
|
||||
glXWaitForMscOML(ps->dpy, ps->reg_win, 0, 2, (msc + 1) % 2, &ust, &msc, &sbc);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Initialize current VSync method.
|
||||
*/
|
||||
bool vsync_init(session_t *ps) {
|
||||
#ifdef CONFIG_OPENGL
|
||||
if (bkend_use_glx(ps)) {
|
||||
// Mesa turns on swap control by default, undo that
|
||||
vsync_opengl_swc_swap_interval(ps, 0);
|
||||
}
|
||||
#endif
|
||||
#ifdef CONFIG_VSYNC_DRM
|
||||
log_warn("The DRM vsync method is deprecated, please don't enable it.");
|
||||
#endif
|
||||
|
||||
if (!ps->o.vsync) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
if (bkend_use_glx(ps)) {
|
||||
if (!vsync_opengl_swc_init(ps)) {
|
||||
return false;
|
||||
}
|
||||
ps->vsync_wait = NULL; // glXSwapBuffers will automatically wait
|
||||
// for vsync, we don't need to do anything.
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Oh no, we are not using glx backend.
|
||||
// Throwing things at wall.
|
||||
#ifdef CONFIG_OPENGL
|
||||
if (vsync_opengl_oml_init(ps)) {
|
||||
log_info("Using the opengl-oml vsync method");
|
||||
ps->vsync_wait = vsync_opengl_oml_wait;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (vsync_opengl_init(ps)) {
|
||||
log_info("Using the opengl vsync method");
|
||||
ps->vsync_wait = vsync_opengl_wait;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_VSYNC_DRM
|
||||
if (vsync_drm_init(ps)) {
|
||||
log_info("Using the drm vsync method");
|
||||
ps->vsync_wait = vsync_drm_wait;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
|
||||
log_error("No supported vsync method found for this backend");
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct session session_t;
|
||||
|
||||
bool vsync_init(session_t *ps);
|
||||
+3147
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,533 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// Copyright (c) 2011-2013, Christopher Jeffrey
|
||||
// Copyright (c) 2013 Richard Grenville <pyxlcy@gmail.com>
|
||||
#pragma once
|
||||
#include <stdbool.h>
|
||||
#include <xcb/damage.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb.h>
|
||||
|
||||
#include "uthash_extra.h"
|
||||
|
||||
// FIXME shouldn't need this
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include <GL/gl.h>
|
||||
#endif
|
||||
|
||||
#include "c2.h"
|
||||
#include "compiler.h"
|
||||
#include "list.h"
|
||||
#include "region.h"
|
||||
#include "render.h"
|
||||
#include "types.h"
|
||||
#include "utils.h"
|
||||
#include "win_defs.h"
|
||||
#include "x.h"
|
||||
|
||||
struct backend_base;
|
||||
typedef struct session session_t;
|
||||
typedef struct _glx_texture glx_texture_t;
|
||||
|
||||
#define win_stack_foreach_managed(w, win_stack) \
|
||||
list_foreach(struct managed_win, w, win_stack, base.stack_neighbour) if (w->base.managed)
|
||||
|
||||
#define win_stack_foreach_managed_safe(w, win_stack) \
|
||||
list_foreach_safe(struct managed_win, w, win_stack, \
|
||||
base.stack_neighbour) if (w->base.managed)
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
// FIXME this type should be in opengl.h
|
||||
// it is very unideal for it to be here
|
||||
typedef struct {
|
||||
/// Framebuffer used for blurring.
|
||||
GLuint fbo;
|
||||
/// Textures used for blurring.
|
||||
GLuint textures[2];
|
||||
/// Width of the textures.
|
||||
int width;
|
||||
/// Height of the textures.
|
||||
int height;
|
||||
} glx_blur_cache_t;
|
||||
#endif
|
||||
|
||||
/// An entry in the window stack. May or may not correspond to a window we know about.
|
||||
struct window_stack_entry {
|
||||
struct list_node stack_neighbour;
|
||||
/// The actual window correspond to this stack entry. NULL if we didn't know about
|
||||
/// this window (e.g. an InputOnly window, or we haven't handled the window
|
||||
/// creation yet)
|
||||
struct win *win;
|
||||
/// The window id. Might not be unique in the stack, because there might be
|
||||
/// destroyed window still fading out in the stack.
|
||||
xcb_window_t id;
|
||||
};
|
||||
|
||||
/**
|
||||
* About coordinate systems
|
||||
*
|
||||
* In general, X is the horizontal axis, Y is the vertical axis.
|
||||
* X goes from left to right, Y goes downwards.
|
||||
*
|
||||
* Global: the origin is the top left corner of the Xorg screen.
|
||||
* Local: the origin is the top left corner of the window, border is
|
||||
* considered part of the window.
|
||||
*/
|
||||
|
||||
/// Structure representing a top-level managed window.
|
||||
typedef struct win win;
|
||||
struct win {
|
||||
UT_hash_handle hh;
|
||||
struct list_node stack_neighbour;
|
||||
/// ID of the top-level frame window.
|
||||
xcb_window_t id;
|
||||
/// Whether the window is destroyed from Xorg's perspective
|
||||
bool destroyed : 1;
|
||||
/// True if we just received CreateNotify, and haven't queried X for any info
|
||||
/// about the window
|
||||
bool is_new : 1;
|
||||
/// True if this window is managed, i.e. this struct is actually a `managed_win`.
|
||||
/// Always false if `is_new` is true.
|
||||
bool managed : 1;
|
||||
};
|
||||
|
||||
struct win_geometry {
|
||||
int16_t x;
|
||||
int16_t y;
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
uint16_t border_width;
|
||||
};
|
||||
|
||||
struct managed_win {
|
||||
struct win base;
|
||||
/// backend data attached to this window. Only available when
|
||||
/// `state` is not UNMAPPED
|
||||
void *win_image;
|
||||
void *old_win_image; // Old window image for interpolating window contents during animations
|
||||
void *shadow_image;
|
||||
/// Pointer to the next higher window to paint.
|
||||
struct managed_win *prev_trans;
|
||||
/// Number of windows above this window
|
||||
int stacking_rank;
|
||||
// TODO(yshui) rethink reg_ignore
|
||||
|
||||
// Core members
|
||||
/// The "mapped state" of this window, doesn't necessary
|
||||
/// match X mapped state, because of fading.
|
||||
winstate_t state;
|
||||
/// Window attributes.
|
||||
xcb_get_window_attributes_reply_t a;
|
||||
/// The geometry of the window body, excluding the window border region.
|
||||
struct win_geometry g;
|
||||
/// Updated geometry received in events
|
||||
struct win_geometry pending_g;
|
||||
/// Xinerama screen this window is on.
|
||||
int xinerama_scr;
|
||||
/// Window visual pict format
|
||||
const xcb_render_pictforminfo_t *pictfmt;
|
||||
/// Client window visual pict format
|
||||
const xcb_render_pictforminfo_t *client_pictfmt;
|
||||
/// Window painting mode.
|
||||
winmode_t mode;
|
||||
/// Whether the window has been damaged at least once.
|
||||
bool ever_damaged;
|
||||
/// Whether the window was damaged after last paint.
|
||||
bool pixmap_damaged;
|
||||
/// Damage of the window.
|
||||
xcb_damage_damage_t damage;
|
||||
/// Paint info of the window.
|
||||
paint_t paint;
|
||||
/// bitmap for properties which needs to be updated
|
||||
uint64_t *stale_props;
|
||||
/// number of uint64_ts that has been allocated for stale_props
|
||||
size_t stale_props_capacity;
|
||||
|
||||
/// Bounding shape of the window. In local coordinates.
|
||||
/// See above about coordinate systems.
|
||||
region_t bounding_shape;
|
||||
/// Window flags. Definitions above.
|
||||
uint64_t flags;
|
||||
/// The region of screen that will be obscured when windows above is painted,
|
||||
/// in global coordinates.
|
||||
/// We use this to reduce the pixels that needed to be paint when painting
|
||||
/// this window and anything underneath. Depends on window frame
|
||||
/// opacity state, window geometry, window mapped/unmapped state,
|
||||
/// window mode of the windows above. DOES NOT INCLUDE the body of THIS WINDOW.
|
||||
/// NULL means reg_ignore has not been calculated for this window.
|
||||
rc_region_t *reg_ignore;
|
||||
/// Whether the reg_ignore of all windows beneath this window are valid
|
||||
bool reg_ignore_valid;
|
||||
/// Cached width/height of the window including border.
|
||||
int widthb, heightb;
|
||||
/// Whether the window is bounding-shaped.
|
||||
bool bounding_shaped;
|
||||
/// Whether the window just have rounded corners.
|
||||
bool rounded_corners;
|
||||
/// Whether this window is to be painted.
|
||||
bool to_paint;
|
||||
/// Whether the window is painting excluded.
|
||||
bool paint_excluded;
|
||||
/// Whether the window is unredirect-if-possible excluded.
|
||||
bool unredir_if_possible_excluded;
|
||||
/// Whether this window is in open/close state.
|
||||
bool in_openclose;
|
||||
/// Whether this window should ignore all animations
|
||||
bool animation_ignore;
|
||||
/// Whether this window was transient when animated on open
|
||||
bool animation_transient;
|
||||
/// Current position and destination, for animation
|
||||
double animation_center_x, animation_center_y;
|
||||
double animation_dest_center_x, animation_dest_center_y;
|
||||
double animation_w, animation_h;
|
||||
double animation_dest_w, animation_dest_h;
|
||||
/// Spring animation velocity
|
||||
double animation_velocity_x, animation_velocity_y;
|
||||
double animation_velocity_w, animation_velocity_h;
|
||||
/// Track animation progress; goes from 0 to 1
|
||||
double animation_progress;
|
||||
/// Inverse of the window distance at the start of animation, for
|
||||
/// tracking animation progress
|
||||
double animation_inv_og_distance;
|
||||
|
||||
// Client window related members
|
||||
/// ID of the top-level client window of the window.
|
||||
xcb_window_t client_win;
|
||||
/// Type of the window.
|
||||
wintype_t window_type;
|
||||
/// Whether it looks like a WM window. We consider a window WM window if
|
||||
/// it does not have a decedent with WM_STATE and it is not override-
|
||||
/// redirected itself.
|
||||
bool wmwin;
|
||||
/// Leader window ID of the window.
|
||||
xcb_window_t leader;
|
||||
/// Cached topmost window ID of the window.
|
||||
xcb_window_t cache_leader;
|
||||
|
||||
// Focus-related members
|
||||
/// Whether the window is to be considered focused.
|
||||
bool focused;
|
||||
/// Override value of window focus state. Set by D-Bus method calls.
|
||||
switch_t focused_force;
|
||||
|
||||
// Blacklist related members
|
||||
/// Name of the window.
|
||||
char *name;
|
||||
/// Window instance class of the window.
|
||||
char *class_instance;
|
||||
/// Window general class of the window.
|
||||
char *class_general;
|
||||
/// <code>WM_WINDOW_ROLE</code> value of the window.
|
||||
char *role;
|
||||
|
||||
// Opacity-related members
|
||||
/// Current window opacity.
|
||||
double opacity;
|
||||
/// Target window opacity.
|
||||
double opacity_target;
|
||||
/// Previous window opacity.
|
||||
double opacity_target_old;
|
||||
/// true if window (or client window, for broken window managers
|
||||
/// not transferring client window's _NET_WM_WINDOW_OPACITY value) has opacity prop
|
||||
bool has_opacity_prop;
|
||||
/// Cached value of opacity window attribute.
|
||||
opacity_t opacity_prop;
|
||||
/// true if opacity is set by some rules
|
||||
bool opacity_is_set;
|
||||
/// Last window opacity value set by the rules.
|
||||
double opacity_set;
|
||||
|
||||
/// Radius of rounded window corners
|
||||
int corner_radius;
|
||||
float border_col[4];
|
||||
|
||||
// Fading-related members
|
||||
/// Override value of window fade state. Set by D-Bus method calls.
|
||||
switch_t fade_force;
|
||||
/// Whether fading is excluded by the rules. Calculated.
|
||||
bool fade_excluded;
|
||||
|
||||
// Frame-opacity-related members
|
||||
/// Current window frame opacity. Affected by window opacity.
|
||||
double frame_opacity;
|
||||
/// Frame extents. Acquired from _NET_FRAME_EXTENTS.
|
||||
margin_t frame_extents;
|
||||
|
||||
// Shadow-related members
|
||||
/// Whether a window has shadow. Calculated.
|
||||
bool shadow;
|
||||
/// Override value of window shadow state. Set by D-Bus method calls.
|
||||
switch_t shadow_force;
|
||||
/// Opacity of the shadow. Affected by window opacity and frame opacity.
|
||||
double shadow_opacity;
|
||||
/// X offset of shadow. Affected by commandline argument.
|
||||
int shadow_dx;
|
||||
/// Y offset of shadow. Affected by commandline argument.
|
||||
int shadow_dy;
|
||||
/// Width of shadow. Affected by window size and commandline argument.
|
||||
int shadow_width;
|
||||
/// Height of shadow. Affected by window size and commandline argument.
|
||||
int shadow_height;
|
||||
/// Picture to render shadow. Affected by window size.
|
||||
paint_t shadow_paint;
|
||||
/// The value of _COMPTON_SHADOW attribute of the window. Below 0 for
|
||||
/// none.
|
||||
long long prop_shadow;
|
||||
/// Do not paint shadow over this window.
|
||||
bool clip_shadow_above;
|
||||
|
||||
// Dim-related members
|
||||
/// Whether the window is to be dimmed.
|
||||
bool dim;
|
||||
|
||||
/// Whether to invert window color.
|
||||
bool invert_color;
|
||||
/// Override value of window color inversion state. Set by D-Bus method
|
||||
/// calls.
|
||||
switch_t invert_color_force;
|
||||
|
||||
/// Whether to blur window background.
|
||||
bool blur_background;
|
||||
|
||||
#ifdef CONFIG_OPENGL
|
||||
/// Textures and FBO background blur use.
|
||||
glx_blur_cache_t glx_blur_cache;
|
||||
/// Background texture of the window
|
||||
glx_texture_t *glx_texture_bg;
|
||||
#endif
|
||||
};
|
||||
|
||||
/// Process pending updates/images flags on a window. Has to be called in X critical
|
||||
/// section
|
||||
void win_process_update_flags(session_t *ps, struct managed_win *w);
|
||||
void win_process_image_flags(session_t *ps, struct managed_win *w);
|
||||
/// Bind a shadow to the window, with color `c` and shadow kernel `kernel`
|
||||
bool win_bind_shadow(struct backend_base *b, struct managed_win *w, struct color c,
|
||||
struct conv *kernel);
|
||||
|
||||
/// Start the unmap of a window. We cannot unmap immediately since we might need to fade
|
||||
/// the window out.
|
||||
void unmap_win_start(struct session *, struct managed_win *);
|
||||
|
||||
/// Start the mapping of a window. We cannot map immediately since we might need to fade
|
||||
/// the window in.
|
||||
void map_win_start(struct session *, struct managed_win *);
|
||||
|
||||
/// Start the destroying of a window. Windows cannot always be destroyed immediately
|
||||
/// because of fading and such.
|
||||
bool must_use destroy_win_start(session_t *ps, struct win *w);
|
||||
|
||||
/// Release images bound with a window, set the *_NONE flags on the window. Only to be
|
||||
/// used when de-initializing the backend outside of win.c
|
||||
void win_release_images(struct backend_base *base, struct managed_win *w);
|
||||
winmode_t attr_pure win_calc_mode(const struct managed_win *w);
|
||||
void win_set_shadow_force(session_t *ps, struct managed_win *w, switch_t val);
|
||||
void win_set_fade_force(struct managed_win *w, switch_t val);
|
||||
void win_set_focused_force(session_t *ps, struct managed_win *w, switch_t val);
|
||||
void win_set_invert_color_force(session_t *ps, struct managed_win *w, switch_t val);
|
||||
/**
|
||||
* Set real focused state of a window.
|
||||
*/
|
||||
void win_set_focused(session_t *ps, struct managed_win *w);
|
||||
bool attr_pure win_should_fade(session_t *ps, const struct managed_win *w);
|
||||
void win_on_factor_change(session_t *ps, struct managed_win *w);
|
||||
/**
|
||||
* Update cache data in struct _win that depends on window size.
|
||||
*/
|
||||
void win_on_win_size_change(session_t *ps, struct managed_win *w);
|
||||
void win_unmark_client(session_t *ps, struct managed_win *w);
|
||||
void win_recheck_client(session_t *ps, struct managed_win *w);
|
||||
|
||||
/**
|
||||
* Calculate and return the opacity target of a window.
|
||||
*
|
||||
* The priority of opacity settings are:
|
||||
*
|
||||
* inactive_opacity_override (if set, and unfocused) > _NET_WM_WINDOW_OPACITY (if set) >
|
||||
* opacity-rules (if matched) > window type default opacity > active/inactive opacity
|
||||
*
|
||||
* @param ps current session
|
||||
* @param w struct _win object representing the window
|
||||
*
|
||||
* @return target opacity
|
||||
*/
|
||||
double attr_pure win_calc_opacity_target(session_t *ps, const struct managed_win *w);
|
||||
bool attr_pure win_should_dim(session_t *ps, const struct managed_win *w);
|
||||
void win_update_screen(int nscreens, region_t *screens, struct managed_win *w);
|
||||
/**
|
||||
* Retrieve the bounding shape of a window.
|
||||
*/
|
||||
// XXX was win_border_size
|
||||
void win_update_bounding_shape(session_t *ps, struct managed_win *w);
|
||||
/**
|
||||
* Check if a window has BYPASS_COMPOSITOR property set
|
||||
*/
|
||||
bool win_is_bypassing_compositor(const session_t *ps, const struct managed_win *w);
|
||||
/**
|
||||
* Get a rectangular region in global coordinates a window (and possibly
|
||||
* its shadow) occupies.
|
||||
*
|
||||
* Note w->shadow and shadow geometry must be correct before calling this
|
||||
* function.
|
||||
*/
|
||||
void win_extents(const struct managed_win *w, region_t *res);
|
||||
region_t win_extents_by_val(const struct managed_win *w);
|
||||
/**
|
||||
* Add a window to damaged area.
|
||||
*
|
||||
* @param ps current session
|
||||
* @param w struct _win element representing the window
|
||||
*/
|
||||
void add_damage_from_win(session_t *ps, const struct managed_win *w);
|
||||
/**
|
||||
* Get a rectangular region a window occupies, excluding frame and shadow.
|
||||
*
|
||||
* Return region in global coordinates.
|
||||
*/
|
||||
void win_get_region_noframe_local(const struct managed_win *w, region_t *);
|
||||
void win_get_region_noframe_local_without_corners(const struct managed_win *w, region_t *);
|
||||
|
||||
/// Get the region for the frame of the window
|
||||
void win_get_region_frame_local(const struct managed_win *w, region_t *res);
|
||||
/// Get the region for the frame of the window, by value
|
||||
region_t win_get_region_frame_local_by_val(const struct managed_win *w);
|
||||
/// Insert a new window above window with id `below`, if there is no window, add to top
|
||||
/// New window will be in unmapped state
|
||||
struct win *add_win_above(session_t *ps, xcb_window_t id, xcb_window_t below);
|
||||
/// Insert a new win entry at the top of the stack
|
||||
struct win *add_win_top(session_t *ps, xcb_window_t id);
|
||||
/// Query the Xorg for information about window `win`
|
||||
/// `win` pointer might become invalid after this function returns
|
||||
struct win *fill_win(session_t *ps, struct win *win);
|
||||
/// Move window `w` to be right above `below`
|
||||
void restack_above(session_t *ps, struct win *w, xcb_window_t below);
|
||||
/// Move window `w` to the bottom of the stack
|
||||
void restack_bottom(session_t *ps, struct win *w);
|
||||
/// Move window `w` to the top of the stack
|
||||
void restack_top(session_t *ps, struct win *w);
|
||||
|
||||
/**
|
||||
* Execute fade callback of a window if fading finished.
|
||||
*/
|
||||
bool must_use win_check_fade_finished(session_t *ps, struct managed_win *w);
|
||||
|
||||
// Stop receiving events (except ConfigureNotify, XXX why?) from a window
|
||||
void win_ev_stop(session_t *ps, const struct win *w);
|
||||
|
||||
/// Skip the current in progress fading of window,
|
||||
/// transition the window straight to its end state
|
||||
///
|
||||
/// @return whether the window is destroyed and freed
|
||||
bool must_use win_skip_fading(session_t *ps, struct managed_win *w);
|
||||
/**
|
||||
* Find a managed window from window id in window linked list of the session.
|
||||
*/
|
||||
struct managed_win *find_managed_win(session_t *ps, xcb_window_t id);
|
||||
struct win *find_win(session_t *ps, xcb_window_t id);
|
||||
struct managed_win *find_toplevel(session_t *ps, xcb_window_t id);
|
||||
/**
|
||||
* Find a managed window that is, or is a parent of `wid`.
|
||||
*
|
||||
* @param ps current session
|
||||
* @param wid window ID
|
||||
* @return struct _win object of the found window, NULL if not found
|
||||
*/
|
||||
struct managed_win *find_managed_window_or_parent(session_t *ps, xcb_window_t wid);
|
||||
|
||||
/**
|
||||
* Check if a window is a fullscreen window.
|
||||
*
|
||||
* It's not using w->border_size for performance measures.
|
||||
*/
|
||||
bool attr_pure win_is_fullscreen(const session_t *ps, const struct managed_win *w);
|
||||
|
||||
/**
|
||||
* Check if a window is focused, without using any focus rules or forced focus settings
|
||||
*/
|
||||
bool attr_pure win_is_focused_raw(const session_t *ps, const struct managed_win *w);
|
||||
|
||||
/// check if window has ARGB visual
|
||||
bool attr_pure win_has_alpha(const struct managed_win *w);
|
||||
|
||||
/// check if reg_ignore_valid is true for all windows above us
|
||||
bool attr_pure win_is_region_ignore_valid(session_t *ps, const struct managed_win *w);
|
||||
|
||||
/// Whether a given window is mapped on the X server side
|
||||
bool win_is_mapped_in_x(const struct managed_win *w);
|
||||
|
||||
// Find the managed window immediately below `w` in the window stack
|
||||
struct managed_win *attr_pure win_stack_find_next_managed(const session_t *ps,
|
||||
const struct list_node *w);
|
||||
/// Set flags on a window. Some sanity checks are performed
|
||||
void win_set_flags(struct managed_win *w, uint64_t flags);
|
||||
/// Clear flags on a window. Some sanity checks are performed
|
||||
void win_clear_flags(struct managed_win *w, uint64_t flags);
|
||||
/// Returns true if any of the flags in `flags` is set
|
||||
bool win_check_flags_any(struct managed_win *w, uint64_t flags);
|
||||
/// Returns true if all of the flags in `flags` are set
|
||||
bool win_check_flags_all(struct managed_win *w, uint64_t flags);
|
||||
/// Mark properties as stale for a window
|
||||
void win_set_properties_stale(struct managed_win *w, const xcb_atom_t *prop, int nprops);
|
||||
|
||||
static inline attr_unused void win_set_property_stale(struct managed_win *w, xcb_atom_t prop) {
|
||||
return win_set_properties_stale(w, (xcb_atom_t[]){prop}, 1);
|
||||
}
|
||||
|
||||
/// Free all resources in a struct win
|
||||
void free_win_res(session_t *ps, struct managed_win *w);
|
||||
|
||||
static inline void win_region_remove_corners(const struct managed_win *w, region_t *res) {
|
||||
region_t corners;
|
||||
pixman_region32_init_rects(
|
||||
&corners,
|
||||
(rect_t[]){
|
||||
{.x1 = 0, .y1 = 0, .x2 = w->corner_radius, .y2 = w->corner_radius},
|
||||
{.x1 = 0, .y1 = w->heightb - w->corner_radius, .x2 = w->corner_radius, .y2 = w->heightb},
|
||||
{.x1 = w->widthb - w->corner_radius, .y1 = 0, .x2 = w->widthb, .y2 = w->corner_radius},
|
||||
{.x1 = w->widthb - w->corner_radius,
|
||||
.y1 = w->heightb - w->corner_radius,
|
||||
.x2 = w->widthb,
|
||||
.y2 = w->heightb},
|
||||
},
|
||||
4);
|
||||
pixman_region32_subtract(res, res, &corners);
|
||||
pixman_region32_fini(&corners);
|
||||
}
|
||||
|
||||
static inline region_t attr_unused win_get_bounding_shape_global_by_val(struct managed_win *w) {
|
||||
region_t ret;
|
||||
pixman_region32_init(&ret);
|
||||
pixman_region32_copy(&ret, &w->bounding_shape);
|
||||
pixman_region32_translate(&ret, w->g.x, w->g.y);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline region_t
|
||||
win_get_bounding_shape_global_without_corners_by_val(struct managed_win *w) {
|
||||
region_t ret;
|
||||
pixman_region32_init(&ret);
|
||||
pixman_region32_copy(&ret, &w->bounding_shape);
|
||||
win_region_remove_corners(w, &ret);
|
||||
pixman_region32_translate(&ret, w->g.x, w->g.y);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the extents of the frame of the given window based on EWMH
|
||||
* _NET_FRAME_EXTENTS and the X window border width.
|
||||
*/
|
||||
static inline margin_t attr_pure attr_unused win_calc_frame_extents(const struct managed_win *w) {
|
||||
margin_t result = w->frame_extents;
|
||||
result.top = max2(result.top, w->g.border_width);
|
||||
result.left = max2(result.left, w->g.border_width);
|
||||
result.bottom = max2(result.bottom, w->g.border_width);
|
||||
result.right = max2(result.right, w->g.border_width);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether a window has WM frames.
|
||||
*/
|
||||
static inline bool attr_pure attr_unused win_has_frame(const struct managed_win *w) {
|
||||
return w->g.border_width || w->frame_extents.top || w->frame_extents.left ||
|
||||
w->frame_extents.right || w->frame_extents.bottom;
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
#pragma once
|
||||
#include <stdint.h>
|
||||
|
||||
typedef enum {
|
||||
WINTYPE_UNKNOWN,
|
||||
WINTYPE_DESKTOP,
|
||||
WINTYPE_DOCK,
|
||||
WINTYPE_TOOLBAR,
|
||||
WINTYPE_MENU,
|
||||
WINTYPE_UTILITY,
|
||||
WINTYPE_SPLASH,
|
||||
WINTYPE_DIALOG,
|
||||
WINTYPE_NORMAL,
|
||||
WINTYPE_DROPDOWN_MENU,
|
||||
WINTYPE_POPUP_MENU,
|
||||
WINTYPE_TOOLTIP,
|
||||
WINTYPE_NOTIFICATION,
|
||||
WINTYPE_COMBO,
|
||||
WINTYPE_DND,
|
||||
NUM_WINTYPES
|
||||
} wintype_t;
|
||||
|
||||
/// Enumeration type of window painting mode.
|
||||
typedef enum {
|
||||
WMODE_TRANS, // The window body is (potentially) transparent
|
||||
WMODE_FRAME_TRANS, // The window body is opaque, but the frame is not
|
||||
WMODE_SOLID, // The window is opaque including the frame
|
||||
} winmode_t;
|
||||
|
||||
/// Transition table:
|
||||
/// (DESTROYED is when the win struct is destroyed and freed)
|
||||
/// ('o' means in all other cases)
|
||||
/// (Window is created in the UNMAPPED state)
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | |UNMAPPING|DESTROYING|MAPPING|FADING |UNMAPPED| MAPPED |DESTROYED|
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | UNMAPPING | o | Window |Window | - | Fading | - | - |
|
||||
/// | | |destroyed |mapped | |finished| | |
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | DESTROYING | - | o | - | - | - | - | Fading |
|
||||
/// | | | | | | | |finished |
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | MAPPING | Window | Window | o |Opacity| - | Fading | - |
|
||||
/// | |unmapped |destroyed | |change | |finished| |
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | FADING | Window | Window | - | o | - | Fading | - |
|
||||
/// | |unmapped |destroyed | | | |finished| |
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | UNMAPPED | - | - |Window | - | o | - | Window |
|
||||
/// | | | |mapped | | | |destroyed|
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
/// | MAPPED | Window | Window | - |Opacity| - | o | - |
|
||||
/// | |unmapped |destroyed | |change | | | |
|
||||
/// +-------------+---------+----------+-------+-------+--------+--------+---------+
|
||||
typedef enum {
|
||||
// The window is being faded out because it's unmapped.
|
||||
WSTATE_UNMAPPING,
|
||||
// The window is being faded out because it's destroyed,
|
||||
WSTATE_DESTROYING,
|
||||
// The window is being faded in
|
||||
WSTATE_MAPPING,
|
||||
// Window opacity is not at the target level
|
||||
WSTATE_FADING,
|
||||
// The window is mapped, no fading is in progress.
|
||||
WSTATE_MAPPED,
|
||||
// The window is unmapped, no fading is in progress.
|
||||
WSTATE_UNMAPPED,
|
||||
} winstate_t;
|
||||
|
||||
enum win_flags {
|
||||
// Note: *_NONE flags are mostly redudant and meant for detecting logical errors
|
||||
// in the code
|
||||
|
||||
/// pixmap is out of date, will be update in win_process_flags
|
||||
WIN_FLAGS_PIXMAP_STALE = 1,
|
||||
/// window does not have pixmap bound
|
||||
WIN_FLAGS_PIXMAP_NONE = 2,
|
||||
/// there was an error trying to bind the images
|
||||
WIN_FLAGS_IMAGE_ERROR = 4,
|
||||
/// shadow is out of date, will be updated in win_process_flags
|
||||
WIN_FLAGS_SHADOW_STALE = 8,
|
||||
/// shadow has not been generated
|
||||
WIN_FLAGS_SHADOW_NONE = 16,
|
||||
/// the client window needs to be updated
|
||||
WIN_FLAGS_CLIENT_STALE = 32,
|
||||
/// the window is mapped by X, we need to call map_win_start for it
|
||||
WIN_FLAGS_MAPPED = 64,
|
||||
/// this window has properties which needs to be updated
|
||||
WIN_FLAGS_PROPERTY_STALE = 128,
|
||||
// TODO(yshui) _maybe_ split SIZE_STALE into SIZE_STALE and SHAPE_STALE
|
||||
/// this window has an unhandled size/shape change
|
||||
WIN_FLAGS_SIZE_STALE = 256,
|
||||
/// this window has an unhandled position (i.e. x and y) change
|
||||
WIN_FLAGS_POSITION_STALE = 512,
|
||||
/// need better name for this, is set when some aspects of the window changed
|
||||
WIN_FLAGS_FACTOR_CHANGED = 1024,
|
||||
};
|
||||
|
||||
static const uint64_t WIN_FLAGS_IMAGES_STALE =
|
||||
WIN_FLAGS_PIXMAP_STALE | WIN_FLAGS_SHADOW_STALE;
|
||||
|
||||
#define WIN_FLAGS_IMAGES_NONE (WIN_FLAGS_PIXMAP_NONE | WIN_FLAGS_SHADOW_NONE)
|
||||
@@ -0,0 +1,744 @@
|
||||
// SPDX-License-Identifier: MPL-2.0
|
||||
// Copyright (c) 2018 Yuxuan Shui <yshuiv7@gmail.com>
|
||||
#include <stdalign.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/Xutil.h>
|
||||
#include <pixman.h>
|
||||
#include <xcb/composite.h>
|
||||
#include <xcb/damage.h>
|
||||
#include <xcb/glx.h>
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/sync.h>
|
||||
#include <xcb/xcb.h>
|
||||
#include <xcb/xcb_renderutil.h>
|
||||
#include <xcb/xfixes.h>
|
||||
|
||||
#include "atom.h"
|
||||
#ifdef CONFIG_OPENGL
|
||||
#include "backend/gl/glx.h"
|
||||
#endif
|
||||
#include "common.h"
|
||||
#include "compiler.h"
|
||||
#include "kernel.h"
|
||||
#include "log.h"
|
||||
#include "region.h"
|
||||
#include "utils.h"
|
||||
#include "x.h"
|
||||
|
||||
/**
|
||||
* Get a specific attribute of a window.
|
||||
*
|
||||
* Returns a blank structure if the returned type and format does not
|
||||
* match the requested type and format.
|
||||
*
|
||||
* @param ps current session
|
||||
* @param w window
|
||||
* @param atom atom of attribute to fetch
|
||||
* @param length length to read
|
||||
* @param rtype atom of the requested type
|
||||
* @param rformat requested format
|
||||
* @return a <code>winprop_t</code> structure containing the attribute
|
||||
* and number of items. A blank one on failure.
|
||||
*/
|
||||
winprop_t x_get_prop_with_offset(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom,
|
||||
int offset, int length, xcb_atom_t rtype, int rformat) {
|
||||
xcb_get_property_reply_t *r = xcb_get_property_reply(
|
||||
c,
|
||||
xcb_get_property(c, 0, w, atom, rtype, to_u32_checked(offset),
|
||||
to_u32_checked(length)),
|
||||
NULL);
|
||||
|
||||
if (r && xcb_get_property_value_length(r) &&
|
||||
(rtype == XCB_GET_PROPERTY_TYPE_ANY || r->type == rtype) &&
|
||||
(!rformat || r->format == rformat) &&
|
||||
(r->format == 8 || r->format == 16 || r->format == 32)) {
|
||||
auto len = xcb_get_property_value_length(r);
|
||||
return (winprop_t){
|
||||
.ptr = xcb_get_property_value(r),
|
||||
.nitems = (ulong)(len / (r->format / 8)),
|
||||
.type = r->type,
|
||||
.format = r->format,
|
||||
.r = r,
|
||||
};
|
||||
}
|
||||
|
||||
free(r);
|
||||
return (winprop_t){
|
||||
.ptr = NULL, .nitems = 0, .type = XCB_GET_PROPERTY_TYPE_ANY, .format = 0};
|
||||
}
|
||||
|
||||
/// Get the type, format and size in bytes of a window's specific attribute.
|
||||
winprop_info_t x_get_prop_info(xcb_connection_t *c, xcb_window_t w, xcb_atom_t atom) {
|
||||
xcb_generic_error_t *e = NULL;
|
||||
auto r = xcb_get_property_reply(
|
||||
c, xcb_get_property(c, 0, w, atom, XCB_ATOM_ANY, 0, 0), &e);
|
||||
if (!r) {
|
||||
log_debug_x_error(e, "Failed to get property info for window %#010x", w);
|
||||
free(e);
|
||||
return (winprop_info_t){
|
||||
.type = XCB_GET_PROPERTY_TYPE_ANY, .format = 0, .length = 0};
|
||||
}
|
||||
|
||||
winprop_info_t winprop_info = {
|
||||
.type = r->type, .format = r->format, .length = r->bytes_after};
|
||||
free(r);
|
||||
|
||||
return winprop_info;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the value of a type-<code>xcb_window_t</code> property of a window.
|
||||
*
|
||||
* @return the value if successful, 0 otherwise
|
||||
*/
|
||||
xcb_window_t wid_get_prop_window(xcb_connection_t *c, xcb_window_t wid, xcb_atom_t aprop) {
|
||||
// Get the attribute
|
||||
xcb_window_t p = XCB_NONE;
|
||||
winprop_t prop = x_get_prop(c, wid, aprop, 1L, XCB_ATOM_WINDOW, 32);
|
||||
|
||||
// Return it
|
||||
if (prop.nitems) {
|
||||
p = (xcb_window_t)*prop.p32;
|
||||
}
|
||||
|
||||
free_winprop(&prop);
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the value of a text property of a window.
|
||||
*/
|
||||
bool wid_get_text_prop(session_t *ps, xcb_window_t wid, xcb_atom_t prop, char ***pstrlst,
|
||||
int *pnstr) {
|
||||
assert(ps->server_grabbed);
|
||||
auto prop_info = x_get_prop_info(ps->c, wid, prop);
|
||||
auto type = prop_info.type;
|
||||
auto format = prop_info.format;
|
||||
auto length = prop_info.length;
|
||||
|
||||
if (type == XCB_ATOM_NONE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (type != XCB_ATOM_STRING && type != ps->atoms->aUTF8_STRING &&
|
||||
type != ps->atoms->aC_STRING) {
|
||||
log_warn("Text property %d of window %#010x has unsupported type: %d",
|
||||
prop, wid, type);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (format != 8) {
|
||||
log_warn("Text property %d of window %#010x has unexpected format: %d",
|
||||
prop, wid, format);
|
||||
return false;
|
||||
}
|
||||
|
||||
xcb_generic_error_t *e = NULL;
|
||||
auto word_count = (length + 4 - 1) / 4;
|
||||
auto r = xcb_get_property_reply(
|
||||
ps->c, xcb_get_property(ps->c, 0, wid, prop, type, 0, word_count), &e);
|
||||
if (!r) {
|
||||
log_debug_x_error(e, "Failed to get window property for %#010x", wid);
|
||||
free(e);
|
||||
return false;
|
||||
}
|
||||
|
||||
assert(length == (uint32_t)xcb_get_property_value_length(r));
|
||||
|
||||
void *data = xcb_get_property_value(r);
|
||||
unsigned int nstr = 0;
|
||||
uint32_t current_offset = 0;
|
||||
while (current_offset < length) {
|
||||
current_offset +=
|
||||
(uint32_t)strnlen(data + current_offset, length - current_offset) + 1;
|
||||
nstr += 1;
|
||||
}
|
||||
|
||||
if (nstr == 0) {
|
||||
// The property is set to an empty string, in that case, we return one
|
||||
// string
|
||||
char **strlst = malloc(sizeof(char *));
|
||||
strlst[0] = "";
|
||||
*pnstr = 1;
|
||||
*pstrlst = strlst;
|
||||
free(r);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Allocate the pointers and the strings together
|
||||
void *buf = NULL;
|
||||
if (posix_memalign(&buf, alignof(char *), length + sizeof(char *) * nstr + 1) != 0) {
|
||||
abort();
|
||||
}
|
||||
|
||||
char *strlst = buf + sizeof(char *) * nstr;
|
||||
memcpy(strlst, xcb_get_property_value(r), length);
|
||||
strlst[length] = '\0'; // X strings aren't guaranteed to be null terminated
|
||||
|
||||
char **ret = buf;
|
||||
current_offset = 0;
|
||||
nstr = 0;
|
||||
while (current_offset < length) {
|
||||
ret[nstr] = strlst + current_offset;
|
||||
current_offset += (uint32_t)strlen(strlst + current_offset) + 1;
|
||||
nstr += 1;
|
||||
}
|
||||
|
||||
*pnstr = to_int_checked(nstr);
|
||||
*pstrlst = ret;
|
||||
free(r);
|
||||
return true;
|
||||
}
|
||||
|
||||
// A cache of pict formats. We assume they don't change during the lifetime
|
||||
// of this program
|
||||
static thread_local xcb_render_query_pict_formats_reply_t *g_pictfmts = NULL;
|
||||
|
||||
static inline void x_get_server_pictfmts(xcb_connection_t *c) {
|
||||
if (g_pictfmts) {
|
||||
return;
|
||||
}
|
||||
xcb_generic_error_t *e = NULL;
|
||||
// Get window picture format
|
||||
g_pictfmts =
|
||||
xcb_render_query_pict_formats_reply(c, xcb_render_query_pict_formats(c), &e);
|
||||
if (e || !g_pictfmts) {
|
||||
log_fatal("failed to get pict formats\n");
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
const xcb_render_pictforminfo_t *
|
||||
x_get_pictform_for_visual(xcb_connection_t *c, xcb_visualid_t visual) {
|
||||
x_get_server_pictfmts(c);
|
||||
|
||||
xcb_render_pictvisual_t *pv = xcb_render_util_find_visual_format(g_pictfmts, visual);
|
||||
for (xcb_render_pictforminfo_iterator_t i =
|
||||
xcb_render_query_pict_formats_formats_iterator(g_pictfmts);
|
||||
i.rem; xcb_render_pictforminfo_next(&i)) {
|
||||
if (i.data->id == pv->format) {
|
||||
return i.data;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static xcb_visualid_t attr_pure x_get_visual_for_pictfmt(xcb_render_query_pict_formats_reply_t *r,
|
||||
xcb_render_pictformat_t fmt) {
|
||||
for (auto screen = xcb_render_query_pict_formats_screens_iterator(r); screen.rem;
|
||||
xcb_render_pictscreen_next(&screen)) {
|
||||
for (auto depth = xcb_render_pictscreen_depths_iterator(screen.data);
|
||||
depth.rem; xcb_render_pictdepth_next(&depth)) {
|
||||
for (auto pv = xcb_render_pictdepth_visuals_iterator(depth.data);
|
||||
pv.rem; xcb_render_pictvisual_next(&pv)) {
|
||||
if (pv.data->format == fmt) {
|
||||
return pv.data->visual;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return XCB_NONE;
|
||||
}
|
||||
|
||||
xcb_visualid_t x_get_visual_for_standard(xcb_connection_t *c, xcb_pict_standard_t std) {
|
||||
x_get_server_pictfmts(c);
|
||||
|
||||
auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, std);
|
||||
|
||||
return x_get_visual_for_pictfmt(g_pictfmts, pictfmt->id);
|
||||
}
|
||||
|
||||
xcb_render_pictformat_t
|
||||
x_get_pictfmt_for_standard(xcb_connection_t *c, xcb_pict_standard_t std) {
|
||||
x_get_server_pictfmts(c);
|
||||
|
||||
auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, std);
|
||||
|
||||
return pictfmt->id;
|
||||
}
|
||||
|
||||
int x_get_visual_depth(xcb_connection_t *c, xcb_visualid_t visual) {
|
||||
auto setup = xcb_get_setup(c);
|
||||
for (auto screen = xcb_setup_roots_iterator(setup); screen.rem;
|
||||
xcb_screen_next(&screen)) {
|
||||
for (auto depth = xcb_screen_allowed_depths_iterator(screen.data);
|
||||
depth.rem; xcb_depth_next(&depth)) {
|
||||
const int len = xcb_depth_visuals_length(depth.data);
|
||||
const xcb_visualtype_t *visuals = xcb_depth_visuals(depth.data);
|
||||
for (int i = 0; i < len; i++) {
|
||||
if (visual == visuals[i].visual_id) {
|
||||
return depth.data->depth;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_pictfmt_and_pixmap(xcb_connection_t *c,
|
||||
const xcb_render_pictforminfo_t *pictfmt,
|
||||
xcb_pixmap_t pixmap, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
void *buf = NULL;
|
||||
if (attr) {
|
||||
xcb_render_create_picture_value_list_serialize(&buf, valuemask, attr);
|
||||
if (!buf) {
|
||||
log_error("failed to serialize picture attributes");
|
||||
return XCB_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
xcb_render_picture_t tmp_picture = x_new_id(c);
|
||||
xcb_generic_error_t *e =
|
||||
xcb_request_check(c, xcb_render_create_picture_checked(
|
||||
c, tmp_picture, pixmap, pictfmt->id, valuemask, buf));
|
||||
free(buf);
|
||||
if (e) {
|
||||
log_error_x_error(e, "failed to create picture");
|
||||
return XCB_NONE;
|
||||
}
|
||||
return tmp_picture;
|
||||
}
|
||||
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_visual_and_pixmap(xcb_connection_t *c, xcb_visualid_t visual,
|
||||
xcb_pixmap_t pixmap, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
const xcb_render_pictforminfo_t *pictfmt = x_get_pictform_for_visual(c, visual);
|
||||
return x_create_picture_with_pictfmt_and_pixmap(c, pictfmt, pixmap, valuemask, attr);
|
||||
}
|
||||
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_standard_and_pixmap(xcb_connection_t *c, xcb_pict_standard_t standard,
|
||||
xcb_pixmap_t pixmap, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
x_get_server_pictfmts(c);
|
||||
|
||||
auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, standard);
|
||||
assert(pictfmt);
|
||||
return x_create_picture_with_pictfmt_and_pixmap(c, pictfmt, pixmap, valuemask, attr);
|
||||
}
|
||||
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_standard(xcb_connection_t *c, xcb_drawable_t d, int w, int h,
|
||||
xcb_pict_standard_t standard, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
x_get_server_pictfmts(c);
|
||||
|
||||
auto pictfmt = xcb_render_util_find_standard_format(g_pictfmts, standard);
|
||||
assert(pictfmt);
|
||||
return x_create_picture_with_pictfmt(c, d, w, h, pictfmt, valuemask, attr);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an picture.
|
||||
*/
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_pictfmt(xcb_connection_t *c, xcb_drawable_t d, int w, int h,
|
||||
const xcb_render_pictforminfo_t *pictfmt, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
uint8_t depth = pictfmt->depth;
|
||||
|
||||
xcb_pixmap_t tmp_pixmap = x_create_pixmap(c, depth, d, w, h);
|
||||
if (!tmp_pixmap) {
|
||||
return XCB_NONE;
|
||||
}
|
||||
|
||||
xcb_render_picture_t picture = x_create_picture_with_pictfmt_and_pixmap(
|
||||
c, pictfmt, tmp_pixmap, valuemask, attr);
|
||||
|
||||
xcb_free_pixmap(c, tmp_pixmap);
|
||||
|
||||
return picture;
|
||||
}
|
||||
|
||||
xcb_render_picture_t
|
||||
x_create_picture_with_visual(xcb_connection_t *c, xcb_drawable_t d, int w, int h,
|
||||
xcb_visualid_t visual, uint32_t valuemask,
|
||||
const xcb_render_create_picture_value_list_t *attr) {
|
||||
auto pictfmt = x_get_pictform_for_visual(c, visual);
|
||||
return x_create_picture_with_pictfmt(c, d, w, h, pictfmt, valuemask, attr);
|
||||
}
|
||||
|
||||
bool x_fetch_region(xcb_connection_t *c, xcb_xfixes_region_t r, pixman_region32_t *res) {
|
||||
xcb_generic_error_t *e = NULL;
|
||||
xcb_xfixes_fetch_region_reply_t *xr =
|
||||
xcb_xfixes_fetch_region_reply(c, xcb_xfixes_fetch_region(c, r), &e);
|
||||
if (!xr) {
|
||||
log_error_x_error(e, "Failed to fetch rectangles");
|
||||
return false;
|
||||
}
|
||||
|
||||
int nrect = xcb_xfixes_fetch_region_rectangles_length(xr);
|
||||
auto b = ccalloc(nrect, pixman_box32_t);
|
||||
xcb_rectangle_t *xrect = xcb_xfixes_fetch_region_rectangles(xr);
|
||||
for (int i = 0; i < nrect; i++) {
|
||||
b[i] = (pixman_box32_t){.x1 = xrect[i].x,
|
||||
.y1 = xrect[i].y,
|
||||
.x2 = xrect[i].x + xrect[i].width,
|
||||
.y2 = xrect[i].y + xrect[i].height};
|
||||
}
|
||||
bool ret = pixman_region32_init_rects(res, b, nrect);
|
||||
free(b);
|
||||
free(xr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void x_set_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict,
|
||||
int16_t clip_x_origin, int16_t clip_y_origin,
|
||||
const region_t *reg) {
|
||||
int nrects;
|
||||
const rect_t *rects = pixman_region32_rectangles((region_t *)reg, &nrects);
|
||||
auto xrects = ccalloc(nrects, xcb_rectangle_t);
|
||||
for (int i = 0; i < nrects; i++) {
|
||||
xrects[i] = (xcb_rectangle_t){
|
||||
.x = to_i16_checked(rects[i].x1),
|
||||
.y = to_i16_checked(rects[i].y1),
|
||||
.width = to_u16_checked(rects[i].x2 - rects[i].x1),
|
||||
.height = to_u16_checked(rects[i].y2 - rects[i].y1),
|
||||
};
|
||||
}
|
||||
|
||||
xcb_generic_error_t *e = xcb_request_check(
|
||||
c, xcb_render_set_picture_clip_rectangles_checked(
|
||||
c, pict, clip_x_origin, clip_y_origin, to_u32_checked(nrects), xrects));
|
||||
if (e) {
|
||||
log_error_x_error(e, "Failed to set clip region");
|
||||
free(e);
|
||||
}
|
||||
free(xrects);
|
||||
}
|
||||
|
||||
void x_clear_picture_clip_region(xcb_connection_t *c, xcb_render_picture_t pict) {
|
||||
xcb_render_change_picture_value_list_t v = {.clipmask = XCB_NONE};
|
||||
xcb_generic_error_t *e = xcb_request_check(
|
||||
c, xcb_render_change_picture(c, pict, XCB_RENDER_CP_CLIP_MASK, &v));
|
||||
if (e) {
|
||||
log_error_x_error(e, "failed to clear clip region");
|
||||
free(e);
|
||||
}
|
||||
}
|
||||
|
||||
enum {
|
||||
XSyncBadCounter = 0,
|
||||
XSyncBadAlarm = 1,
|
||||
XSyncBadFence = 2,
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a X11 error to string
|
||||
*
|
||||
* @return a pointer to a string. this pointer shouldn NOT be freed, same buffer is used
|
||||
* for multiple calls to this function,
|
||||
*/
|
||||
static const char *
|
||||
_x_strerror(unsigned long serial, uint8_t major, uint16_t minor, uint8_t error_code) {
|
||||
session_t *const ps = ps_g;
|
||||
|
||||
int o = 0;
|
||||
const char *name = "Unknown";
|
||||
|
||||
#define CASESTRRET(s) \
|
||||
case s: \
|
||||
name = #s; \
|
||||
break
|
||||
|
||||
#define CASESTRRET2(s) \
|
||||
case XCB_##s: name = #s; break
|
||||
|
||||
// TODO(yshui) separate error code out from session_t
|
||||
o = error_code - ps->xfixes_error;
|
||||
switch (o) { CASESTRRET2(XFIXES_BAD_REGION); }
|
||||
|
||||
o = error_code - ps->damage_error;
|
||||
switch (o) { CASESTRRET2(DAMAGE_BAD_DAMAGE); }
|
||||
|
||||
o = error_code - ps->render_error;
|
||||
switch (o) {
|
||||
CASESTRRET2(RENDER_PICT_FORMAT);
|
||||
CASESTRRET2(RENDER_PICTURE);
|
||||
CASESTRRET2(RENDER_PICT_OP);
|
||||
CASESTRRET2(RENDER_GLYPH_SET);
|
||||
CASESTRRET2(RENDER_GLYPH);
|
||||
}
|
||||
|
||||
if (ps->glx_exists) {
|
||||
o = error_code - ps->glx_error;
|
||||
switch (o) {
|
||||
CASESTRRET2(GLX_BAD_CONTEXT);
|
||||
CASESTRRET2(GLX_BAD_CONTEXT_STATE);
|
||||
CASESTRRET2(GLX_BAD_DRAWABLE);
|
||||
CASESTRRET2(GLX_BAD_PIXMAP);
|
||||
CASESTRRET2(GLX_BAD_CONTEXT_TAG);
|
||||
CASESTRRET2(GLX_BAD_CURRENT_WINDOW);
|
||||
CASESTRRET2(GLX_BAD_RENDER_REQUEST);
|
||||
CASESTRRET2(GLX_BAD_LARGE_REQUEST);
|
||||
CASESTRRET2(GLX_UNSUPPORTED_PRIVATE_REQUEST);
|
||||
CASESTRRET2(GLX_BAD_FB_CONFIG);
|
||||
CASESTRRET2(GLX_BAD_PBUFFER);
|
||||
CASESTRRET2(GLX_BAD_CURRENT_DRAWABLE);
|
||||
CASESTRRET2(GLX_BAD_WINDOW);
|
||||
CASESTRRET2(GLX_GLX_BAD_PROFILE_ARB);
|
||||
}
|
||||
}
|
||||
|
||||
if (ps->xsync_exists) {
|
||||
o = error_code - ps->xsync_error;
|
||||
switch (o) {
|
||||
CASESTRRET(XSyncBadCounter);
|
||||
CASESTRRET(XSyncBadAlarm);
|
||||
CASESTRRET(XSyncBadFence);
|
||||
}
|
||||
}
|
||||
|
||||
switch (error_code) {
|
||||
CASESTRRET2(ACCESS);
|
||||
CASESTRRET2(ALLOC);
|
||||
CASESTRRET2(ATOM);
|
||||
CASESTRRET2(COLORMAP);
|
||||
CASESTRRET2(CURSOR);
|
||||
CASESTRRET2(DRAWABLE);
|
||||
CASESTRRET2(FONT);
|
||||
CASESTRRET2(G_CONTEXT);
|
||||
CASESTRRET2(ID_CHOICE);
|
||||
CASESTRRET2(IMPLEMENTATION);
|
||||
CASESTRRET2(LENGTH);
|
||||
CASESTRRET2(MATCH);
|
||||
CASESTRRET2(NAME);
|
||||
CASESTRRET2(PIXMAP);
|
||||
CASESTRRET2(REQUEST);
|
||||
CASESTRRET2(VALUE);
|
||||
CASESTRRET2(WINDOW);
|
||||
}
|
||||
|
||||
#undef CASESTRRET
|
||||
#undef CASESTRRET2
|
||||
|
||||
thread_local static char buffer[256];
|
||||
snprintf(buffer, sizeof(buffer), "X error %d %s request %d minor %d serial %lu",
|
||||
error_code, name, major, minor, serial);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Log a X11 error
|
||||
*/
|
||||
void x_print_error(unsigned long serial, uint8_t major, uint16_t minor, uint8_t error_code) {
|
||||
log_debug("%s", _x_strerror(serial, major, minor, error_code));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a xcb_generic_error_t to a string that describes the error
|
||||
*
|
||||
* @return a pointer to a string. this pointer shouldn NOT be freed, same buffer is used
|
||||
* for multiple calls to this function,
|
||||
*/
|
||||
const char *x_strerror(xcb_generic_error_t *e) {
|
||||
if (!e) {
|
||||
return "No error";
|
||||
}
|
||||
return _x_strerror(e->full_sequence, e->major_code, e->minor_code, e->error_code);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a pixmap and check that creation succeeded.
|
||||
*/
|
||||
xcb_pixmap_t x_create_pixmap(xcb_connection_t *c, uint8_t depth, xcb_drawable_t drawable,
|
||||
int width, int height) {
|
||||
xcb_pixmap_t pix = x_new_id(c);
|
||||
xcb_void_cookie_t cookie = xcb_create_pixmap_checked(
|
||||
c, depth, pix, drawable, to_u16_checked(width), to_u16_checked(height));
|
||||
xcb_generic_error_t *err = xcb_request_check(c, cookie);
|
||||
if (err == NULL) {
|
||||
return pix;
|
||||
}
|
||||
|
||||
log_error_x_error(err, "Failed to create pixmap");
|
||||
free(err);
|
||||
return XCB_NONE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate a pixmap.
|
||||
*
|
||||
* Detect whether the pixmap is valid with XGetGeometry. Well, maybe there
|
||||
* are better ways.
|
||||
*/
|
||||
bool x_validate_pixmap(xcb_connection_t *c, xcb_pixmap_t pixmap) {
|
||||
if (pixmap == XCB_NONE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
auto r = xcb_get_geometry_reply(c, xcb_get_geometry(c, pixmap), NULL);
|
||||
if (!r) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ret = r->width && r->height;
|
||||
free(r);
|
||||
return ret;
|
||||
}
|
||||
/// Names of root window properties that could point to a pixmap of
|
||||
/// background.
|
||||
static const char *background_props_str[] = {
|
||||
"_XROOTPMAP_ID",
|
||||
"_XSETROOT_ID",
|
||||
0,
|
||||
};
|
||||
|
||||
xcb_pixmap_t
|
||||
x_get_root_back_pixmap(xcb_connection_t *c, xcb_window_t root, struct atom *atoms) {
|
||||
xcb_pixmap_t pixmap = XCB_NONE;
|
||||
|
||||
// Get the values of background attributes
|
||||
for (int p = 0; background_props_str[p]; p++) {
|
||||
xcb_atom_t prop_atom = get_atom(atoms, background_props_str[p]);
|
||||
winprop_t prop = x_get_prop(c, root, prop_atom, 1, XCB_ATOM_PIXMAP, 32);
|
||||
if (prop.nitems) {
|
||||
pixmap = (xcb_pixmap_t)*prop.p32;
|
||||
free_winprop(&prop);
|
||||
break;
|
||||
}
|
||||
free_winprop(&prop);
|
||||
}
|
||||
|
||||
return pixmap;
|
||||
}
|
||||
|
||||
bool x_is_root_back_pixmap_atom(struct atom *atoms, xcb_atom_t atom) {
|
||||
for (int p = 0; background_props_str[p]; p++) {
|
||||
xcb_atom_t prop_atom = get_atom(atoms, background_props_str[p]);
|
||||
if (prop_atom == atom) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Synchronizes a X Render drawable to ensure all pending painting requests
|
||||
* are completed.
|
||||
*/
|
||||
bool x_fence_sync(xcb_connection_t *c, xcb_sync_fence_t f) {
|
||||
// TODO(richardgv): If everybody just follows the rules stated in X Sync
|
||||
// prototype, we need only one fence per screen, but let's stay a bit
|
||||
// cautious right now
|
||||
|
||||
auto e = xcb_request_check(c, xcb_sync_trigger_fence_checked(c, f));
|
||||
if (e) {
|
||||
log_error_x_error(e, "Failed to trigger the fence");
|
||||
goto err;
|
||||
}
|
||||
|
||||
e = xcb_request_check(c, xcb_sync_await_fence_checked(c, 1, &f));
|
||||
if (e) {
|
||||
log_error_x_error(e, "Failed to await on a fence");
|
||||
goto err;
|
||||
}
|
||||
|
||||
e = xcb_request_check(c, xcb_sync_reset_fence_checked(c, f));
|
||||
if (e) {
|
||||
log_error_x_error(e, "Failed to reset the fence");
|
||||
goto err;
|
||||
}
|
||||
return true;
|
||||
|
||||
err:
|
||||
free(e);
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a struct conv to a X picture convolution filter, normalizing the kernel
|
||||
* in the process. Allow the caller to specify the element at the center of the kernel,
|
||||
* for compatibility with legacy code.
|
||||
*
|
||||
* @param[in] kernel the convolution kernel
|
||||
* @param[in] center the element to put at the center of the matrix
|
||||
* @param[inout] ret pointer to an array of `size`, if `size` is too small, more space
|
||||
* will be allocated, and `*ret` will be updated
|
||||
* @param[inout] size size of the array pointed to by `ret`, in number of elements
|
||||
* @return number of elements filled into `*ret`
|
||||
*/
|
||||
void x_create_convolution_kernel(const conv *kernel, double center,
|
||||
struct x_convolution_kernel **ret) {
|
||||
assert(ret);
|
||||
if (!*ret || (*ret)->capacity < kernel->w * kernel->h + 2) {
|
||||
free(*ret);
|
||||
*ret =
|
||||
cvalloc(sizeof(struct x_convolution_kernel) +
|
||||
(size_t)(kernel->w * kernel->h + 2) * sizeof(xcb_render_fixed_t));
|
||||
(*ret)->capacity = kernel->w * kernel->h + 2;
|
||||
}
|
||||
|
||||
(*ret)->size = kernel->w * kernel->h + 2;
|
||||
|
||||
auto buf = (*ret)->kernel;
|
||||
buf[0] = DOUBLE_TO_XFIXED(kernel->w);
|
||||
buf[1] = DOUBLE_TO_XFIXED(kernel->h);
|
||||
|
||||
double sum = center;
|
||||
for (int i = 0; i < kernel->w * kernel->h; i++) {
|
||||
if (i == kernel->w * kernel->h / 2) {
|
||||
continue;
|
||||
}
|
||||
sum += kernel->data[i];
|
||||
}
|
||||
|
||||
// Note for floating points a / b != a * (1 / b), but this shouldn't have any real
|
||||
// impact on the result
|
||||
double factor = sum != 0 ? 1.0 / sum : 1;
|
||||
for (int i = 0; i < kernel->w * kernel->h; i++) {
|
||||
buf[i + 2] = DOUBLE_TO_XFIXED(kernel->data[i] * factor);
|
||||
}
|
||||
|
||||
buf[kernel->h / 2 * kernel->w + kernel->w / 2 + 2] =
|
||||
DOUBLE_TO_XFIXED(center * factor);
|
||||
}
|
||||
|
||||
/// Generate a search criteria for fbconfig from a X visual.
|
||||
/// Returns {-1, -1, -1, -1, -1, 0} on failure
|
||||
struct xvisual_info x_get_visual_info(xcb_connection_t *c, xcb_visualid_t visual) {
|
||||
auto pictfmt = x_get_pictform_for_visual(c, visual);
|
||||
auto depth = x_get_visual_depth(c, visual);
|
||||
if (!pictfmt || depth == -1) {
|
||||
log_error("Invalid visual %#03x", visual);
|
||||
return (struct xvisual_info){-1, -1, -1, -1, -1, 0};
|
||||
}
|
||||
if (pictfmt->type != XCB_RENDER_PICT_TYPE_DIRECT) {
|
||||
log_error("We cannot handle non-DirectColor visuals. Report an "
|
||||
"issue if you see this error message.");
|
||||
return (struct xvisual_info){-1, -1, -1, -1, -1, 0};
|
||||
}
|
||||
|
||||
int red_size = popcntul(pictfmt->direct.red_mask),
|
||||
blue_size = popcntul(pictfmt->direct.blue_mask),
|
||||
green_size = popcntul(pictfmt->direct.green_mask),
|
||||
alpha_size = popcntul(pictfmt->direct.alpha_mask);
|
||||
|
||||
return (struct xvisual_info){
|
||||
.red_size = red_size,
|
||||
.green_size = green_size,
|
||||
.blue_size = blue_size,
|
||||
.alpha_size = alpha_size,
|
||||
.visual_depth = depth,
|
||||
.visual = visual,
|
||||
};
|
||||
}
|
||||
|
||||
xcb_screen_t *x_screen_of_display(xcb_connection_t *c, int screen) {
|
||||
xcb_screen_iterator_t iter;
|
||||
|
||||
iter = xcb_setup_roots_iterator(xcb_get_setup(c));
|
||||
for (; iter.rem; --screen, xcb_screen_next(&iter)) {
|
||||
if (screen == 0) {
|
||||
return iter.data;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
Loaded 100 of 132 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user