swindle Commit - r0:54692361a243

init

Tsuki -

r0:54692361a243 default

parent child

.hgignore

0 created 644 +20 0

@@ -0,0 +1,20
	1	syntax: glob
	2	swindle
	3	smsg/smsg
	4	*.o
	5	*-protocol.c
	6	*-protocol.h
	7	smsg/*-protocol.c
	8	smsg/*-protocol.h
	9	result
	10	result-*
	11	.direnv/
	12	.vscode/
	13	.idea/
	14	.cache/
	15	compile_commands.json
	16	tags
	17	*.swp
	18	*.swo
	19	*~
	20	include/lua5.4/*

LICENSE

0 created 644 +693 0

This diff has been collapsed as it changes many lines, (693 lines changed) Show them Hide them
	@@ -0,0 +1,693
		1	swindle - wayland compositor base wlroots
		2
		3	Copyright © 2026 kantiankant
		4
		5	See also the files licenses/LICENSE.dwl, licenses/LICENSE.tinywl,
		6	licenses/LICENSE.dwm, licenses/LICENSE.sway, and licenses/LICENSE.mangowm
		7
		8	This program is free software: you can redistribute it and/or modify
		9	it under the terms of the GNU General Public License as published by
		10	the Free Software Foundation, either version 3 of the License, or
		11	(at your option) any later version.
		12
		13	This program is distributed in the hope that it will be useful,
		14	but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	GNU General Public License for more details.
		17
		18	----
		19
		20	GNU GENERAL PUBLIC LICENSE
		21	Version 3, 29 June 2007
		22
		23	Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
		24	Everyone is permitted to copy and distribute verbatim copies
		25	of this license document, but changing it is not allowed.
		26
		27	Preamble
		28
		29	The GNU General Public License is a free, copyleft license for
		30	software and other kinds of works.
		31
		32	The licenses for most software and other practical works are designed
		33	to take away your freedom to share and change the works. By contrast,
		34	the GNU General Public License is intended to guarantee your freedom to
		35	share and change all versions of a program--to make sure it remains free
		36	software for all its users. We, the Free Software Foundation, use the
		37	GNU General Public License for most of our software; it applies also to
		38	any other work released this way by its authors. You can apply it to
		39	your programs, too.
		40
		41	When we speak of free software, we are referring to freedom, not
		42	price. Our General Public Licenses are designed to make sure that you
		43	have the freedom to distribute copies of free software (and charge for
		44	them if you wish), that you receive source code or can get it if you
		45	want it, that you can change the software or use pieces of it in new
		46	free programs, and that you know you can do these things.
		47
		48	To protect your rights, we need to prevent others from denying you
		49	these rights or asking you to surrender the rights. Therefore, you have
		50	certain responsibilities if you distribute copies of the software, or if
		51	you modify it: responsibilities to respect the freedom of others.
		52
		53	For example, if you distribute copies of such a program, whether
		54	gratis or for a fee, you must pass on to the recipients the same
		55	freedoms that you received. You must make sure that they, too, receive
		56	or can get the source code. And you must show them these terms so they
		57	know their rights.
		58
		59	Developers that use the GNU GPL protect your rights with two steps:
		60	(1) assert copyright on the software, and (2) offer you this License
		61	giving you legal permission to copy, distribute and/or modify it.
		62
		63	For the developers' and authors' protection, the GPL clearly explains
		64	that there is no warranty for this free software. For both users' and
		65	authors' sake, the GPL requires that modified versions be marked as
		66	changed, so that their problems will not be attributed erroneously to
		67	authors of previous versions.
		68
		69	Some devices are designed to deny users access to install or run
		70	modified versions of the software inside them, although the manufacturer
		71	can do so. This is fundamentally incompatible with the aim of
		72	protecting users' freedom to change the software. The systematic
		73	pattern of such abuse occurs in the area of products for individuals to
		74	use, which is precisely where it is most unacceptable. Therefore, we
		75	have designed this version of the GPL to prohibit the practice for those
		76	products. If such problems arise substantially in other domains, we
		77	stand ready to extend this provision to those domains in future versions
		78	of the GPL, as needed to protect the freedom of users.
		79
		80	Finally, every program is threatened constantly by software patents.
		81	States should not allow patents to restrict development and use of
		82	software on general-purpose computers, but in those that do, we wish to
		83	avoid the special danger that patents applied to a free program could
		84	make it effectively proprietary. To prevent this, the GPL assures that
		85	patents cannot be used to render the program non-free.
		86
		87	The precise terms and conditions for copying, distribution and
		88	modification follow.
		89
		90	TERMS AND CONDITIONS
		91
		92	1. Definitions.
		93
		94	"This License" refers to version 3 of the GNU General Public License.
		95
		96	"Copyright" also means copyright-like laws that apply to other kinds of
		97	works, such as semiconductor masks.
		98
		99	"The Program" refers to any copyrightable work licensed under this
		100	License. Each licensee is addressed as "you". "Licensees" and
		101	"recipients" may be individuals or organizations.
		102
		103	To "modify" a work means to copy from or adapt all or part of the work
		104	in a fashion requiring copyright permission, other than the making of an
		105	exact copy. The resulting work is called a "modified version" of the
		106	earlier work or a work "based on" the earlier work.
		107
		108	A "covered work" means either the unmodified Program or a work based
		109	on the Program.
		110
		111	To "propagate" a work means to do anything with it that, without
		112	permission, would make you directly or secondarily liable for
		113	infringement under applicable copyright law, except executing it on a
		114	computer or modifying a private copy. Propagation includes copying,
		115	distribution (with or without modification), making available to the
		116	public, and in some countries other activities as well.
		117
		118	To "convey" a work means any kind of propagation that enables other
		119	parties to make or receive copies. Mere interaction with a user through
		120	a computer network, with no transfer of a copy, is not conveying.
		121
		122	An interactive user interface displays "Appropriate Legal Notices"
		123	to the extent that it includes a convenient and prominently visible
		124	feature that (1) displays an appropriate copyright notice, and (2)
		125	tells the user that there is no warranty for the work (except to the
		126	extent that warranties are provided), that licensees may convey the
		127	work under this License, and how to view a copy of this License. If
		128	the interface presents a list of user commands or options, such as a
		129	menu, a prominent item in the list meets this criterion.
		130
		131	1. Source Code.
		132
		133	The "source code" for a work means the preferred form of the work
		134	for making modifications to it. "Object code" means any non-source
		135	form of a work.
		136
		137	A "Standard Interface" means an interface that either is an official
		138	standard defined by a recognized standards body, or, in the case of
		139	interfaces specified for a particular programming language, one that
		140	is widely used among developers working in that language.
		141
		142	The "System Libraries" of an executable work include anything, other
		143	than the work as a whole, that (a) is included in the normal form of
		144	packaging a Major Component, but which is not part of that Major
		145	Component, and (b) serves only to enable use of the work with that
		146	Major Component, or to implement a Standard Interface for which an
		147	implementation is available to the public in source code form. A
		148	"Major Component", in this context, means a major essential component
		149	(kernel, window system, and so on) of the specific operating system
		150	(if any) on which the executable work runs, or a compiler used to
		151	produce the work, or an object code interpreter used to run it.
		152
		153	The "Corresponding Source" for a work in object code form means all
		154	the source code needed to generate, install, and (for an executable
		155	work) run the object code and to modify the work, including scripts to
		156	control those activities. However, it does not include the work's
		157	System Libraries, or general-purpose tools or generally available free
		158	programs which are used unmodified in performing those activities but
		159	which are not part of the work. For example, Corresponding Source
		160	includes interface definition files associated with source files for
		161	the work, and the source code for shared libraries and dynamically
		162	linked subprograms that the work is specifically designed to require,
		163	such as by intimate data communication or control flow between those
		164	subprograms and other parts of the work.
		165
		166	The Corresponding Source need not include anything that users
		167	can regenerate automatically from other parts of the Corresponding
		168	Source.
		169
		170	The Corresponding Source for a work in source code form is that
		171	same work.
		172
		173	2. Basic Permissions.
		174
		175	All rights granted under this License are granted for the term of
		176	copyright on the Program, and are irrevocable provided the stated
		177	conditions are met. This License explicitly affirms your unlimited
		178	permission to run the unmodified Program. The output from running a
		179	covered work is covered by this License only if the output, given its
		180	content, constitutes a covered work. This License acknowledges your
		181	rights of fair use or other equivalent, as provided by copyright law.
		182
		183	You may make, run and propagate covered works that you do not
		184	convey, without conditions so long as your license otherwise remains
		185	in force. You may convey covered works to others for the sole purpose
		186	of having them make modifications exclusively for you, or provide you
		187	with facilities for running those works, provided that you comply with
		188	the terms of this License in conveying all material for which you do
		189	not control copyright. Those thus making or running the covered works
		190	for you must do so exclusively on your behalf, under your direction
		191	and control, on terms that prohibit them from making any copies of
		192	your copyrighted material outside their relationship with you.
		193
		194	Conveying under any other circumstances is permitted solely under
		195	the conditions stated below. Sublicensing is not allowed; section 10
		196	makes it unnecessary.
		197
		198	3. Protecting Users' Legal Rights From Anti-Circumvention Law.
		199
		200	No covered work shall be deemed part of an effective technological
		201	measure under any applicable law fulfilling obligations under article
		202	11 of the WIPO copyright treaty adopted on 20 December 1996, or
		203	similar laws prohibiting or restricting circumvention of such
		204	measures.
		205
		206	When you convey a covered work, you waive any legal power to forbid
		207	circumvention of technological measures to the extent such circumvention
		208	is effected by exercising rights under this License with respect to
		209	the covered work, and you disclaim any intention to limit operation or
		210	modification of the work as a means of enforcing, against the work's
		211	users, your or third parties' legal rights to forbid circumvention of
		212	technological measures.
		213
		214	4. Conveying Verbatim Copies.
		215
		216	You may convey verbatim copies of the Program's source code as you
		217	receive it, in any medium, provided that you conspicuously and
		218	appropriately publish on each copy an appropriate copyright notice;
		219	keep intact all notices stating that this License and any
		220	non-permissive terms added in accord with section 7 apply to the code;
		221	keep intact all notices of the absence of any warranty; and give all
		222	recipients a copy of this License along with the Program.
		223
		224	You may charge any price or no price for each copy that you convey,
		225	and you may offer support or warranty protection for a fee.
		226
		227	5. Conveying Modified Source Versions.
		228
		229	You may convey a work based on the Program, or the modifications to
		230	produce it from the Program, in the form of source code under the
		231	terms of section 4, provided that you also meet all of these conditions:
		232
		233	a) The work must carry prominent notices stating that you modified
		234	it, and giving a relevant date.
		235
		236	b) The work must carry prominent notices stating that it is
		237	released under this License and any conditions added under section
		238	7. This requirement modifies the requirement in section 4 to
		239	"keep intact all notices".
		240
		241	c) You must license the entire work, as a whole, under this
		242	License to anyone who comes into possession of a copy. This
		243	License will therefore apply, along with any applicable section 7
		244	additional terms, to the whole of the work, and all its parts,
		245	regardless of how they are packaged. This License gives no
		246	permission to license the work in any other way, but it does not
		247	invalidate such permission if you have separately received it.
		248
		249	d) If the work has interactive user interfaces, each must display
		250	Appropriate Legal Notices; however, if the Program has interactive
		251	interfaces that do not display Appropriate Legal Notices, your
		252	work need not make them do so.
		253
		254	A compilation of a covered work with other separate and independent
		255	works, which are not by their nature extensions of the covered work,
		256	and which are not combined with it such as to form a larger program,
		257	in or on a volume of a storage or distribution medium, is called an
		258	"aggregate" if the compilation and its resulting copyright are not
		259	used to limit the access or legal rights of the compilation's users
		260	beyond what the individual works permit. Inclusion of a covered work
		261	in an aggregate does not cause this License to apply to the other
		262	parts of the aggregate.
		263
		264	6. Conveying Non-Source Forms.
		265
		266	You may convey a covered work in object code form under the terms
		267	of sections 4 and 5, provided that you also convey the
		268	machine-readable Corresponding Source under the terms of this License,
		269	in one of these ways:
		270
		271	a) Convey the object code in, or embodied in, a physical product
		272	(including a physical distribution medium), accompanied by the
		273	Corresponding Source fixed on a durable physical medium
		274	customarily used for software interchange.
		275
		276	b) Convey the object code in, or embodied in, a physical product
		277	(including a physical distribution medium), accompanied by a
		278	written offer, valid for at least three years and valid for as
		279	long as you offer spare parts or customer support for that product
		280	model, to give anyone who possesses the object code either (1) a
		281	copy of the Corresponding Source for all the software in the
		282	product that is covered by this License, on a durable physical
		283	medium customarily used for software interchange, for a price no
		284	more than your reasonable cost of physically performing this
		285	conveying of source, or (2) access to copy the
		286	Corresponding Source from a network server at no charge.
		287
		288	c) Convey individual copies of the object code with a copy of the
		289	written offer to provide the Corresponding Source. This
		290	alternative is allowed only occasionally and noncommercially, and
		291	only if you received the object code with such an offer, in accord
		292	with subsection 6b.
		293
		294	d) Convey the object code by offering access from a designated
		295	place (gratis or for a charge), and offer equivalent access to the
		296	Corresponding Source in the same way through the same place at no
		297	further charge. You need not require recipients to copy the
		298	Corresponding Source along with the object code. If the place to
		299	copy the object code is a network server, the Corresponding Source
		300	may be on a different server (operated by you or a third party)
		301	that supports equivalent copying facilities, provided you maintain
		302	clear directions next to the object code saying where to find the
		303	Corresponding Source. Regardless of what server hosts the
		304	Corresponding Source, you remain obligated to ensure that it is
		305	available for as long as needed to satisfy these requirements.
		306
		307	e) Convey the object code using peer-to-peer transmission, provided
		308	you inform other peers where the object code and Corresponding
		309	Source of the work are being offered to the general public at no
		310	charge under subsection 6d.
		311
		312	A separable portion of the object code, whose source code is excluded
		313	from the Corresponding Source as a System Library, need not be
		314	included in conveying the object code work.
		315
		316	A "User Product" is either (1) a "consumer product", which means any
		317	tangible personal property which is normally used for personal, family,
		318	or household purposes, or (2) anything designed or sold for incorporation
		319	into a dwelling. In determining whether a product is a consumer product,
		320	doubtful cases shall be resolved in favor of coverage. For a particular
		321	product received by a particular user, "normally used" refers to a
		322	typical or common use of that class of product, regardless of the status
		323	of the particular user or of the way in which the particular user
		324	actually uses, or expects or is expected to use, the product. A product
		325	is a consumer product regardless of whether the product has substantial
		326	commercial, industrial or non-consumer uses, unless such uses represent
		327	the only significant mode of use of the product.
		328
		329	"Installation Information" for a User Product means any methods,
		330	procedures, authorization keys, or other information required to install
		331	and execute modified versions of a covered work in that User Product from
		332	a modified version of its Corresponding Source. The information must
		333	suffice to ensure that the continued functioning of the modified object
		334	code is in no case prevented or interfered with solely because
		335	modification has been made.
		336
		337	If you convey an object code work under this section in, or with, or
		338	specifically for use in, a User Product, and the conveying occurs as
		339	part of a transaction in which the right of possession and use of the
		340	User Product is transferred to the recipient in perpetuity or for a
		341	fixed term (regardless of how the transaction is characterized), the
		342	Corresponding Source conveyed under this section must be accompanied
		343	by the Installation Information. But this requirement does not apply
		344	if neither you nor any third party retains the ability to install
		345	modified object code on the User Product (for example, the work has
		346	been installed in ROM).
		347
		348	The requirement to provide Installation Information does not include a
		349	requirement to continue to provide support service, warranty, or updates
		350	for a work that has been modified or installed by the recipient, or for
		351	the User Product in which it has been modified or installed. Access to a
		352	network may be denied when the modification itself materially and
		353	adversely affects the operation of the network or violates the rules and
		354	protocols for communication across the network.
		355
		356	Corresponding Source conveyed, and Installation Information provided,
		357	in accord with this section must be in a format that is publicly
		358	documented (and with an implementation available to the public in
		359	source code form), and must require no special password or key for
		360	unpacking, reading or copying.
		361
		362	7. Additional Terms.
		363
		364	"Additional permissions" are terms that supplement the terms of this
		365	License by making exceptions from one or more of its conditions.
		366	Additional permissions that are applicable to the entire Program shall
		367	be treated as though they were included in this License, to the extent
		368	that they are valid under applicable law. If additional permissions
		369	apply only to part of the Program, that part may be used separately
		370	under those permissions, but the entire Program remains governed by
		371	this License without regard to the additional permissions.
		372
		373	When you convey a copy of a covered work, you may at your option
		374	remove any additional permissions from that copy, or from any part of
		375	it. (Additional permissions may be written to require their own
		376	removal in certain cases when you modify the work.) You may place
		377	additional permissions on material, added by you to a covered work,
		378	for which you have or can give appropriate copyright permission.
		379
		380	Notwithstanding any other provision of this License, for material you
		381	add to a covered work, you may (if authorized by the copyright holders of
		382	that material) supplement the terms of this License with terms:
		383
		384	a) Disclaiming warranty or limiting liability differently from the
		385	terms of sections 15 and 16 of this License; or
		386
		387	b) Requiring preservation of specified reasonable legal notices or
		388	author attributions in that material or in the Appropriate Legal
		389	Notices displayed by works containing it; or
		390
		391	c) Prohibiting misrepresentation of the origin of that material, or
		392	requiring that modified versions of such material be marked in
		393	reasonable ways as different from the original version; or
		394
		395	d) Limiting the use for publicity purposes of names of licensors or
		396	authors of the material; or
		397
		398	e) Declining to grant rights under trademark law for use of some
		399	trade names, trademarks, or service marks; or
		400
		401	f) Requiring indemnification of licensors and authors of that
		402	material by anyone who conveys the material (or modified versions of
		403	it) with contractual assumptions of liability to the recipient, for
		404	any liability that these contractual assumptions directly impose on
		405	those licensors and authors.
		406
		407	All other non-permissive additional terms are considered "further
		408	restrictions" within the meaning of section 10. If the Program as you
		409	received it, or any part of it, contains a notice stating that it is
		410	governed by this License along with a term that is a further
		411	restriction, you may remove that term. If a license document contains
		412	a further restriction but permits relicensing or conveying under this
		413	License, you may add to a covered work material governed by the terms
		414	of that license document, provided that the further restriction does
		415	not survive such relicensing or conveying.
		416
		417	If you add terms to a covered work in accord with this section, you
		418	must place, in the relevant source files, a statement of the
		419	additional terms that apply to those files, or a notice indicating
		420	where to find the applicable terms.
		421
		422	Additional terms, permissive or non-permissive, may be stated in the
		423	form of a separately written license, or stated as exceptions;
		424	the above requirements apply either way.
		425
		426	8. Termination.
		427
		428	You may not propagate or modify a covered work except as expressly
		429	provided under this License. Any attempt otherwise to propagate or
		430	modify it is void, and will automatically terminate your rights under
		431	this License (including any patent licenses granted under the third
		432	paragraph of section 11).
		433
		434	However, if you cease all violation of this License, then your
		435	license from a particular copyright holder is reinstated (a)
		436	provisionally, unless and until the copyright holder explicitly and
		437	finally terminates your license, and (b) permanently, if the copyright
		438	holder fails to notify you of the violation by some reasonable means
		439	prior to 60 days after the cessation.
		440
		441	Moreover, your license from a particular copyright holder is
		442	reinstated permanently if the copyright holder notifies you of the
		443	violation by some reasonable means, this is the first time you have
		444	received notice of violation of this License (for any work) from that
		445	copyright holder, and you cure the violation prior to 30 days after
		446	your receipt of the notice.
		447
		448	Termination of your rights under this section does not terminate the
		449	licenses of parties who have received copies or rights from you under
		450	this License. If your rights have been terminated and not permanently
		451	reinstated, you do not qualify to receive new licenses for the same
		452	material under section 10.
		453
		454	9. Acceptance Not Required for Having Copies.
		455
		456	You are not required to accept this License in order to receive or
		457	run a copy of the Program. Ancillary propagation of a covered work
		458	occurring solely as a consequence of using peer-to-peer transmission
		459	to receive a copy likewise does not require acceptance. However,
		460	nothing other than this License grants you permission to propagate or
		461	modify any covered work. These actions infringe copyright if you do
		462	not accept this License. Therefore, by modifying or propagating a
		463	covered work, you indicate your acceptance of this License to do so.
		464
		465	10. Automatic Licensing of Downstream Recipients.
		466
		467	Each time you convey a covered work, the recipient automatically
		468	receives a license from the original licensors, to run, modify and
		469	propagate that work, subject to this License. You are not responsible
		470	for enforcing compliance by third parties with this License.
		471
		472	An "entity transaction" is a transaction transferring control of an
		473	organization, or substantially all assets of one, or subdividing an
		474	organization, or merging organizations. If propagation of a covered
		475	work results from an entity transaction, each party to that
		476	transaction who receives a copy of the work also receives whatever
		477	licenses to the work the party's predecessor in interest had or could
		478	give under the previous paragraph, plus a right to possession of the
		479	Corresponding Source of the work from the predecessor in interest, if
		480	the predecessor has it or can get it with reasonable efforts.
		481
		482	You may not impose any further restrictions on the exercise of the
		483	rights granted or affirmed under this License. For example, you may
		484	not impose a license fee, royalty, or other charge for exercise of
		485	rights granted under this License, and you may not initiate litigation
		486	(including a cross-claim or counterclaim in a lawsuit) alleging that
		487	any patent claim is infringed by making, using, selling, offering for
		488	sale, or importing the Program or any portion of it.
		489
		490	11. Patents.
		491
		492	A "contributor" is a copyright holder who authorizes use under this
		493	License of the Program or a work on which the Program is based. The
		494	work thus licensed is called the contributor's "contributor version".
		495
		496	A contributor's "essential patent claims" are all patent claims
		497	owned or controlled by the contributor, whether already acquired or
		498	hereafter acquired, that would be infringed by some manner, permitted
		499	by this License, of making, using, or selling its contributor version,
		500	but do not include claims that would be infringed only as a
		501	consequence of further modification of the contributor version. For
		502	purposes of this definition, "control" includes the right to grant
		503	patent sublicenses in a manner consistent with the requirements of
		504	this License.
		505
		506	Each contributor grants you a non-exclusive, worldwide, royalty-free
		507	patent license under the contributor's essential patent claims, to
		508	make, use, sell, offer for sale, import and otherwise run, modify and
		509	propagate the contents of its contributor version.
		510
		511	In the following three paragraphs, a "patent license" is any express
		512	agreement or commitment, however denominated, not to enforce a patent
		513	(such as an express permission to practice a patent or covenant not to
		514	sue for patent infringement). To "grant" such a patent license to a
		515	party means to make such an agreement or commitment not to enforce a
		516	patent against the party.
		517
		518	If you convey a covered work, knowingly relying on a patent license,
		519	and the Corresponding Source of the work is not available for anyone
		520	to copy, free of charge and under the terms of this License, through a
		521	publicly available network server or other readily accessible means,
		522	then you must either (1) cause the Corresponding Source to be so
		523	available, or (2) arrange to deprive yourself of the benefit of the
		524	patent license for this particular work, or (3) arrange, in a manner
		525	consistent with the requirements of this License, to extend the patent
		526	license to downstream recipients. "Knowingly relying" means you have
		527	actual knowledge that, but for the patent license, your conveying the
		528	covered work in a country, or your recipient's use of the covered work
		529	in a country, would infringe one or more identifiable patents in that
		530	country that you have reason to believe are valid.
		531
		532	If, pursuant to or in connection with a single transaction or
		533	arrangement, you convey, or propagate by procuring conveyance of, a
		534	covered work, and grant a patent license to some of the parties
		535	receiving the covered work authorizing them to use, propagate, modify
		536	or convey a specific copy of the covered work, then the patent license
		537	you grant is automatically extended to all recipients of the covered
		538	work and works based on it.
		539
		540	A patent license is "discriminatory" if it does not include within
		541	the scope of its coverage, prohibits the exercise of, or is
		542	conditioned on the non-exercise of one or more of the rights that are
		543	specifically granted under this License. You may not convey a covered
		544	work if you are a party to an arrangement with a third party that is
		545	in the business of distributing software, under which you make payment
		546	to the third party based on the extent of your activity of conveying
		547	the work, and under which the third party grants, to any of the
		548	parties who would receive the covered work from you, a discriminatory
		549	patent license (a) in connection with copies of the covered work
		550	conveyed by you (or copies made from those copies), or (b) primarily
		551	for and in connection with specific products or compilations that
		552	contain the covered work, unless you entered into that arrangement,
		553	or that patent license was granted, prior to 28 March 2007.
		554
		555	Nothing in this License shall be construed as excluding or limiting
		556	any implied license or other defenses to infringement that may
		557	otherwise be available to you under applicable patent law.
		558
		559	12. No Surrender of Others' Freedom.
		560
		561	If conditions are imposed on you (whether by court order, agreement or
		562	otherwise) that contradict the conditions of this License, they do not
		563	excuse you from the conditions of this License. If you cannot convey a
		564	covered work so as to satisfy simultaneously your obligations under this
		565	License and any other pertinent obligations, then as a consequence you may
		566	not convey it at all. For example, if you agree to terms that obligate you
		567	to collect a royalty for further conveying from those to whom you convey
		568	the Program, the only way you could satisfy both those terms and this
		569	License would be to refrain entirely from conveying the Program.
		570
		571	13. Use with the GNU Affero General Public License.
		572
		573	Notwithstanding any other provision of this License, you have
		574	permission to link or combine any covered work with a work licensed
		575	under version 3 of the GNU Affero General Public License into a single
		576	combined work, and to convey the resulting work. The terms of this
		577	License will continue to apply to the part which is the covered work,
		578	but the special requirements of the GNU Affero General Public License,
		579	section 13, concerning interaction through a network will apply to the
		580	combination as such.
		581
		582	14. Revised Versions of this License.
		583
		584	The Free Software Foundation may publish revised and/or new versions of
		585	the GNU General Public License from time to time. Such new versions will
		586	be similar in spirit to the present version, but may differ in detail to
		587	address new problems or concerns.
		588
		589	Each version is given a distinguishing version number. If the
		590	Program specifies that a certain numbered version of the GNU General
		591	Public License "or any later version" applies to it, you have the
		592	option of following the terms and conditions either of that numbered
		593	version or of any later version published by the Free Software
		594	Foundation. If the Program does not specify a version number of the
		595	GNU General Public License, you may choose any version ever published
		596	by the Free Software Foundation.
		597
		598	If the Program specifies that a proxy can decide which future
		599	versions of the GNU General Public License can be used, that proxy's
		600	public statement of acceptance of a version permanently authorizes you
		601	to choose that version for the Program.
		602
		603	Later license versions may give you additional or different
		604	permissions. However, no additional obligations are imposed on any
		605	author or copyright holder as a result of your choosing to follow a
		606	later version.
		607
		608	15. Disclaimer of Warranty.
		609
		610	THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
		611	APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
		612	HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
		613	OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
		614	THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		615	PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
		616	IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
		617	ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
		618
		619	16. Limitation of Liability.
		620
		621	IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
		622	WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
		623	THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
		624	GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
		625	USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
		626	DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
		627	PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
		628	EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
		629	SUCH DAMAGES.
		630
		631	17. Interpretation of Sections 15 and 16.
		632
		633	If the disclaimer of warranty and limitation of liability provided
		634	above cannot be given local legal effect according to their terms,
		635	reviewing courts shall apply local law that most closely approximates
		636	an absolute waiver of all civil liability in connection with the
		637	Program, unless a warranty or assumption of liability accompanies a
		638	copy of the Program in return for a fee.
		639
		640	END OF TERMS AND CONDITIONS
		641
		642	How to Apply These Terms to Your New Programs
		643
		644	If you develop a new program, and you want it to be of the greatest
		645	possible use to the public, the best way to achieve this is to make it
		646	free software which everyone can redistribute and change under these terms.
		647
		648	To do so, attach the following notices to the program. It is safest
		649	to attach them to the start of each source file to most effectively
		650	state the exclusion of warranty; and each file should have at least
		651	the "copyright" line and a pointer to where the full notice is found.
		652
		653	<one line to give the program's name and a brief idea of what it does.>
		654	Copyright (C) <year> <name of author>
		655
		656	This program is free software: you can redistribute it and/or modify
		657	it under the terms of the GNU General Public License as published by
		658	the Free Software Foundation, either version 3 of the License, or
		659	(at your option) any later version.
		660
		661	This program is distributed in the hope that it will be useful,
		662	but WITHOUT ANY WARRANTY; without even the implied warranty of
		663	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		664	GNU General Public License for more details.
		665
		666	You should have received a copy of the GNU General Public License
		667	along with this program. If not, see <https://www.gnu.org/licenses/>.
		668
		669	Also add information on how to contact you by electronic and paper mail.
		670
		671	If the program does terminal interaction, make it output a short
		672	notice like this when it starts in an interactive mode:
		673
		674	<program> Copyright (C) <year> <name of author>
		675	This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
		676	This is free software, and you are welcome to redistribute it
		677	under certain conditions; type `show c' for details.
		678
		679	The hypothetical commands `show w' and `show c' should show the appropriate
		680	parts of the General Public License. Of course, your program's commands
		681	might be different; for a GUI interface, you would use an "about box".
		682
		683	You should also get your employer (if you work as a programmer) or school,
		684	if any, to sign a "copyright disclaimer" for the program, if necessary.
		685	For more information on this, and how to apply and follow the GNU GPL, see
		686	<https://www.gnu.org/licenses/>.
		687
		688	The GNU General Public License does not permit incorporating your program
		689	into proprietary programs. If your program is a subroutine library, you
		690	may consider it more useful to permit linking proprietary applications with
		691	the library. If this is what you want to do, use the GNU Lesser General
		692	Public License instead of this License. But first, please read
		693	<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

0 created 644 +99 0

@@ -0,0 +1,99
	1	.POSIX:
	2	.SUFFIXES:
	3
	4	include config.mk
	5
	6	DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(WLR_INCS) \
	7	-I. -Iinclude -Isrc -Iparser -DWLR_USE_UNSTABLE -D_POSIX_C_SOURCE=200809L -DVERSION=\"$(VERSION)\" \
	8	$(XWAYLAND) -g -Wall -Wextra -Wno-unused-parameter -O1 -std=c11 $(CFLAGS)
	9	LDLIBS = `$(PKG_CONFIG) --libs $(PKGS)` $(WLR_LIBS) -lm $(LIBS)
	10
	11	SCANNER = `$(PKG_CONFIG) --variable=wayland_scanner wayland-scanner`
	12	PROTOCOLS = `$(PKG_CONFIG) --variable=pkgdatadir wayland-protocols`
	13
	14	SMSG_CFLAGS = `$(PKG_CONFIG) --cflags wayland-client` -Wall -Wextra -Wno-unused-parameter
	15	SMSG_LDLIBS = `$(PKG_CONFIG) --libs wayland-client`
	16
	17	all: swindle smsg/smsg
	18
	19	swindle: src/dwl.o src/util.o parser/parser.o dwl-ipc-unstable-v2-protocol.o src/wlr_ext_workspace_v1.o ext-workspace-v1-protocol.o
	20	$(CC) $^ $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
	21
	22	src/dwl.o: src/swindle.c include/client.h config.h include/dwl-ipc.h dwl-ipc-unstable-v2-protocol.h \
	23	include/ext-workspace.h src/wlr_ext_workspace_v1.h ext-workspace-v1-protocol.h \
	24	cursor-shape-v1-protocol.h pointer-constraints-unstable-v1-protocol.h \
	25	wlr-layer-shell-unstable-v1-protocol.h \
	26	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h \
	27	parser/parser.h
	28	$(CC) $(DWLCFLAGS) -o $@ -c $<
	29
	30	src/util.o: src/util.c src/util.h
	31	$(CC) $(DWLCFLAGS) -o $@ -c $<
	32
	33	src/wlr_ext_workspace_v1.o: src/wlr_ext_workspace_v1.c src/wlr_ext_workspace_v1.h ext-workspace-v1-protocol.h
	34	$(CC) $(DWLCFLAGS) -o $@ -c $<
	35
	36	parser/parser.o: parser/parser.c parser/parser.h
	37	$(CC) $(DWLCFLAGS) -o $@ -c $<
	38
	39	dwl-ipc-unstable-v2-protocol.o: dwl-ipc-unstable-v2-protocol.c
	40
	41	ext-workspace-v1-protocol.o: ext-workspace-v1-protocol.c
	42
	43	# protocol headers and glue
	44	cursor-shape-v1-protocol.h:
	45	$(SCANNER) enum-header $(PROTOCOLS)/staging/cursor-shape/cursor-shape-v1.xml $@
	46	pointer-constraints-unstable-v1-protocol.h:
	47	$(SCANNER) enum-header $(PROTOCOLS)/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml $@
	48	wlr-layer-shell-unstable-v1-protocol.h:
	49	$(SCANNER) enum-header protocols/wlr-layer-shell-unstable-v1.xml $@
	50	wlr-output-power-management-unstable-v1-protocol.h:
	51	$(SCANNER) server-header protocols/wlr-output-power-management-unstable-v1.xml $@
	52	xdg-shell-protocol.h:
	53	$(SCANNER) server-header $(PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
	54	dwl-ipc-unstable-v2-protocol.h:
	55	$(SCANNER) server-header protocols/dwl-ipc-unstable-v2.xml $@
	56	dwl-ipc-unstable-v2-protocol.c:
	57	$(SCANNER) private-code protocols/dwl-ipc-unstable-v2.xml $@
	58
	59	# smsg
	60	smsg/dwl-ipc-unstable-v2-protocol.h:
	61	$(SCANNER) client-header protocols/dwl-ipc-unstable-v2.xml $@
	62
	63	smsg/dwl-ipc-unstable-v2-protocol.c:
	64	$(SCANNER) private-code protocols/dwl-ipc-unstable-v2.xml $@
	65
	66	smsg/dwl-ipc-unstable-v2-protocol.o: smsg/dwl-ipc-unstable-v2-protocol.c
	67	$(CC) $(SMSG_CFLAGS) -o $@ -c $<
	68
	69	smsg/smsg.o: smsg/smsg.c smsg/dwl-ipc-unstable-v2-protocol.h
	70	$(CC) $(SMSG_CFLAGS) -o $@ -c $<
	71
	72	smsg/smsg: smsg/smsg.o smsg/dwl-ipc-unstable-v2-protocol.o
	73	$(CC) $^ $(SMSG_CFLAGS) $(SMSG_LDLIBS) -o $@
	74
	75	ext-workspace-v1-protocol.h:
	76	$(SCANNER) server-header protocols/ext-workspace-v1.xml $@
	77	ext-workspace-v1-protocol.c:
	78	$(SCANNER) private-code protocols/ext-workspace-v1.xml $@
	79
	80	clean:
	81	rm -f swindle smsg/smsg src/.o parser/.o smsg/.o smsg/-protocol.h smsg/-protocol.c .o -protocol.h -protocol.c
	82
	83	install: swindle smsg/smsg
	84	mkdir -p $(DESTDIR)$(PREFIX)/bin
	85	cp -f swindle $(DESTDIR)$(PREFIX)/bin
	86	chmod 755 $(DESTDIR)$(PREFIX)/bin/swindle
	87	cp -f smsg/smsg $(DESTDIR)$(PREFIX)/bin
	88	chmod 755 $(DESTDIR)$(PREFIX)/bin/smsg
	89	mkdir -p $(DESTDIR)/etc/swindle
	90	cp -r example/* $(DESTDIR)/etc/swindle
	91
	92	uninstall:
	93	rm -f $(DESTDIR)$(PREFIX)/bin/swindle
	94	rm -f $(DESTDIR)$(PREFIX)/bin/smsg
	95	rm -rf $(DESTDIR)/etc/swindle
	96
	97	.SUFFIXES: .c .o
	98	.c.o:
	99	$(CC) $(DWLCFLAGS) -o $@ -c $<

README.md

0 created 644 +56 0

@@ -0,0 +1,56
	1	## Swindle
	2
	3
	4
	5	> "It's so bad it's not even funny!" -kantiankant, 2026
	6
	7
	8	Swindle is a fork of [dwl](https://codeberg.org/dwl/dwl) that was designed from the start with one goal: to make it feel like the poor man's Hyprland. It has the following:
	9
	10	* NO cool vfx
	11	* nearly NO documentation
	12	* ZERO good original code
	13	* only ONE tiling layout (dwindle)
	14
	15	> Fun fact: I actually took some parts of [MangoWM](https://github.com/mangowm/mango) (such as the ext-workspaces implementation). hence why the LICENSE.mangowm exists
	16
	17	## Dependencies
	18
	19	* libinput
	20	* wayland
	21	* wlroots-0.20 (compiled with the libinput backend)
	22	* xkbcommon
	23	* wayland-protocols (compile-time only)
	24	* pkg-config (compile-time only)
	25
	26	Install these (and their `-devel` versions if your distro has separate
	27	development packages) and run `make` followed by `doas/sudo make install`, if you wish to install it (installs to /usr/local/bin/ by default).
	28
	29	## Things that are good to have
	30
	31	* [foot](https://codeberg.org/dnkl/foot)
	32
	33
	34	## Known Issues
	35
	36	N/A
	37
	38	## Configuration
	39
	40	read example/config.lua. It should give you a basic idea of how configuring swindle works.
	41
	42	> note: it's best to copy /etc/swindle/config.lua into XDG_HOME_DIR/.config/swindle/ before you attempt to
	43	start swindle because it (swindle) won't start without it
	44
	45	## Checklist
	46
	47	- [ ] separate the trackpad scroll from the mousee scroll
	48	- [x] Add ability to change your keymap
	49	- [ ] Add animations via [scenefx](https://github.com/wlrfx/scenefx) when 0.5 drops (in another branch)
	50	- [ ] Add the ability for the compositor to read a custom path for configs
	51	- [ ] Add /etc/swindle/config.lua as a fallback path if $HOME/.config/swindle/config.lua is not found
	52
	53
	54	## License
	55
	56	GPL-v3, probably

assets/log.txt

0 created 644 +4 0

@@ -0,0 +1,4
	1	████████ ██ ██
	2	██ ██ ██ ██
	3	██ ██ ██ ██
	4	████ ██████████

config.h

0 created 644 +6 0

@@ -0,0 +1,6
	1	static void dwindle(Monitor *m);
	2
	3	static const Layout layouts[] = {
	4	{"><>", NULL},
	5	{"[T]", dwindle},
	6	};

config.mk

0 created 644 +31 0

@@ -0,0 +1,31
	1	_VERSION = 0.1
	2	VERSION = `git describe --tags --dirty 2>/dev/null \|\| echo $(_VERSION)`
	3
	4	PKG_CONFIG = pkg-config
	5
	6	# paths
	7	PREFIX = /usr/local
	8	MANDIR = $(PREFIX)/share/man
	9	DATDIR = $(PREFIX)/share
	10
	11	WLR_INCS = `$(PKG_CONFIG) --cflags wlroots-0.20`
	12	WLR_LIBS = `$(PKG_CONFIG) --libs wlroots-0.20`
	13
	14	# Allow using an alternative wlroots installation
	15	#WLR_INCS = -I/usr/include/pixman-1 -I/usr/include/elogind -I/usr/include/libdrm \
	16	# -I$(PWD)/wlroots/include
	17	#WLR_LIBS = -Wl,-rpath,$(PWD)/wlroots/build -L$(PWD)/wlroots/build -lwlroots-0.19
	18
	19	#XWAYLAND =
	20	#XLIBS =
	21	# Uncomment to build XWayland support
	22	XWAYLAND = -DXWAYLAND
	23	XLIBS = xcb xcb-icccm
	24
	25	# lua
	26	LUA_PKG = lua5.4
	27
	28	PKGS = wayland-server xkbcommon libinput $(LUA_PKG) $(XLIBS)
	29
	30	# Requires C11: _Alignas and anonymous unions in wlroots headers.
	31	CC = cc

example/config.lua

0 created 644 +101 0

@@ -0,0 +1,101
	1	sloppy_focus = true
	2	bypass_surface_visibility = false
	3	log_level = "error" -- "silent", "error", "info", "debug"
	4
	5	appearance = {
	6	border_px = 2,
	7	gaps = 10, -- 0 = no gaps. simple as.
	8	smart_gaps = false,
	9
	10	root_color = 0x222222ff,
	11	border_color = 0x00000000,
	12	focus_color = 0xe8e8e8ff,
	13	urgent_color = 0xff0000ff,
	14
	15	fullscreen_bg = 0x000000ff,
	16	}
	17
	18
	19	-- Note: the entire input section requires you to restart
	20	-- the compositor once changed
	21	input = {
	22	repeat_rate = 50,
	23	repeat_delay = 150,
	24	tap_to_click = true,
	25	tap_and_drag = true,
	26	drag_lock = true,
	27	natural_scrolling = false,
	28	disable_while_typing = true,
	29	left_handed = false,
	30	middle_button_emulation = false,
	31	scroll_method = "2fg", -- "2fg", "edge", "button"
	32	click_method = "button_areas", -- "button_areas", "clickfinger"
	33	accel_profile = "adaptive", -- "adaptive", "flat"
	34	accel_speed = 0.0,
	35
	36	layout = "us", -- "us", "de", "de,us", ...
	37	-- variant = "nodeadkeys",
	38	-- options = "grp:alt_shift_toggle",
	39	}
	40
	41	rules = {
	42	-- { app_id = "Gimp", floating = true, monitor = -1 },
	43	-- { app_id = "firefox", tags = 1 << 8, floating = false, monitor = -1 },
	44	}
	45
	46	monitors = {
	47	-- catch-all rule; name = nil means match anything
	48	{ name = nil, mfact = 0.55, nmaster = 1, scale = 1.0,
	49	layout = "dwindle", x = -1, y = -1 },
	50
	51	-- HiDPI laptop example:
	52	-- { name = "eDP-1", mfact = 0.5, nmaster = 1, scale = 2.0,
	53	-- layout = "dwindle", x = -1, y = -1 },
	54	}
	55
	56	-- autostart: it starts stuff in sequence
	57	autostart = {
	58	"dbus-update-activation-environment --systemd WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_CURRENT_DESKTOP",
	59	"systemctl --user import-environment WAYLAND_DISPLAY XDG_SESSION_TYPE XDG_CURRENT_DESKTOP",
	60	"waybar",
	61	}
	62
	63
	64	keybinds = {
	65	{ mods = {"logo"}, key = "q", action = "spawn", args = {"alacritty"} },
	66	{ mods = {"logo"}, key = "space", action = "spawn", args = {"wofi", "--show", "drun"} },
	67	{ mods = {"logo"}, key = "w", action = "killclient" },
	68	{ mods = {"logo"}, key = "v", action = "togglefloating" },
	69	{ mods = {"logo"}, key = "f", action = "togglefullscreen" },
	70	{ mods = {"logo"}, key = "g", action = "togglegaps" },
	71	{ mods = {"logo"}, key = "h", action = "focusdir", args = {"left"} },
	72	{ mods = {"logo"}, key = "j", action = "focusdir", args = {"down"} },
	73	{ mods = {"logo"}, key = "k", action = "focusdir", args = {"up"} },
	74	{ mods = {"logo"}, key = "l", action = "focusdir", args = {"right"} },
	75	{ mods = {"logo", "shift"}, key = "H", action = "swapdir", args = {"left"} },
	76	{ mods = {"logo", "shift"}, key = "J", action = "swapdir", args = {"down"} },
	77	{ mods = {"logo", "shift"}, key = "K", action = "swapdir", args = {"up"} },
	78	{ mods = {"logo", "shift"}, key = "L", action = "swapdir", args = {"right"} },
	79	{ mods = {"logo"}, key = "Tab", action = "view" },
	80	{ mods = {"logo"}, key = "0", action = "view", args = {"all"} },
	81	{ mods = {"logo"}, key = "comma", action = "focusmon", args = {"left"} },
	82	{ mods = {"logo"}, key = "period", action = "focusmon", args = {"right"} },
	83	{ mods = {"logo", "shift"}, key = "less", action = "tagmon", args = {"left"} },
	84	{ mods = {"logo", "shift"}, key = "greater", action = "tagmon", args = {"right"} },
	85	{ mods = {"logo", "shift"}, key = "e", action = "quit" },
	86	}
	87
	88	for i = 1, 9 do
	89	local key = tostring(i)
	90	local mask = 1 << (i - 1)
	91	table.insert(keybinds, { mods = {"logo"}, key = key, action = "view", args = {tostring(mask)} })
	92	table.insert(keybinds, { mods = {"logo", "ctrl"}, key = key, action = "toggleview", args = {tostring(mask)} })
	93	table.insert(keybinds, { mods = {"logo", "shift"}, key = key, action = "tag", args = {tostring(mask)} })
	94	table.insert(keybinds, { mods = {"logo", "ctrl", "shift"}, key = key, action = "toggletag", args = {tostring(mask)} })
	95	end
	96
	97	buttons = {
	98	{ mods = {"logo"}, button = "left", action = "moveresize", args = {"move"} },
	99	{ mods = {"logo"}, button = "middle", action = "togglefloating" },
	100	{ mods = {"logo"}, button = "right", action = "moveresize", args = {"resize"} },
	101	}

flake.lock

0 created 644 +61 0

@@ -0,0 +1,61
	1	{
	2	"nodes": {
	3	"flake-utils": {
	4	"inputs": {
	5	"systems": "systems"
	6	},
	7	"locked": {
	8	"lastModified": 1731533236,
	9	"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
	10	"owner": "numtide",
	11	"repo": "flake-utils",
	12	"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
	13	"type": "github"
	14	},
	15	"original": {
	16	"owner": "numtide",
	17	"repo": "flake-utils",
	18	"type": "github"
	19	}
	20	},
	21	"nixpkgs": {
	22	"locked": {
	23	"lastModified": 1786106723,
	24	"narHash": "sha256-zDSUbpoeo/9ZmD2+wXnzxoo1+uhL8vxc0b8yuYMKYq0=",
	25	"owner": "NixOS",
	26	"repo": "nixpkgs",
	27	"rev": "f13ff45afd1bb73e640eaa08a7066dbed07e3238",
	28	"type": "github"
	29	},
	30	"original": {
	31	"owner": "NixOS",
	32	"ref": "nixos-unstable",
	33	"repo": "nixpkgs",
	34	"type": "github"
	35	}
	36	},
	37	"root": {
	38	"inputs": {
	39	"flake-utils": "flake-utils",
	40	"nixpkgs": "nixpkgs"
	41	}
	42	},
	43	"systems": {
	44	"locked": {
	45	"lastModified": 1681028828,
	46	"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
	47	"owner": "nix-systems",
	48	"repo": "default",
	49	"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
	50	"type": "github"
	51	},
	52	"original": {
	53	"owner": "nix-systems",
	54	"repo": "default",
	55	"type": "github"
	56	}
	57	}
	58	},
	59	"root": "root",
	60	"version": 7
	61	}

flake.nix

0 created 644 +65 0

@@ -0,0 +1,65
	1	{
	2	description = "swindle: a dwl fork with Lua config, IPC, and ext-workspace support, plus its smsg client";
	3
	4	inputs = {
	5	nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
	6	flake-utils.url = "github:numtide/flake-utils";
	7	};
	8
	9	outputs = { self, nixpkgs, flake-utils }:
	10	flake-utils.lib.eachDefaultSystem (system:
	11	let
	12	pkgs = nixpkgs.legacyPackages.${system};
	13	in
	14	{
	15	packages.default = pkgs.stdenv.mkDerivation rec {
	16	pname = "swindle";
	17	version = "0.1";
	18
	19	src = self;
	20
	21	nativeBuildInputs = with pkgs; [
	22	pkg-config
	23	wayland-scanner
	24	wayland-protocols
	25	];
	26
	27	buildInputs = with pkgs; [
	28	wayland
	29	wlroots_0_20
	30	pixman
	31	libxkbcommon
	32	libinput
	33	lua5_4
	34	libxcb
	35	libxcb-wm
	36	];
	37
	38	enableParallelBuilding = true;
	39
	40	postPatch = ''
	41	substituteInPlace Makefile \
	42	--replace '$(DESTDIR)/etc/swindle' '$(DESTDIR)$(PREFIX)/etc/swindle'
	43	'';
	44
	45	makeFlags = [ "PREFIX=${placeholder "out"}" ];
	46
	47	meta = with pkgs.lib; {
	48	description = "A dwl fork with Lua configuration, IPC support, and ext-workspace-v1";
	49	license = with licenses; [ gpl3Only mit isc ];
	50	platforms = platforms.linux;
	51	mainProgram = "swindle";
	52	};
	53	};
	54
	55	devShells.default = pkgs.mkShell {
	56	inputsFrom = [ self.packages.${system}.default ];
	57	packages = with pkgs; [ pkg-config gdb ];
	58	};
	59
	60	apps.default = flake-utils.lib.mkApp {
	61	drv = self.packages.${system}.default;
	62	};
	63	});
	64	}
	65

include/client.h

0 created 644 +447 0

@@ -0,0 +1,447
	1	/*
	2	* Attempt to consolidate unavoidable suck into one file, away from src/swindle.c. This
	3	* file is not meant to be pretty. We use a .h file with static inline
	4	* functions instead of a separate .c module, or function pointers like sway, so
	5	* that they will simply compile out if the chosen #defines leave them unused.
	6	*/
	7
	8	/* Leave these functions first; they're used in the others */
	9	static inline int
	10	client_is_x11(Client *c)
	11	{
	12	#ifdef XWAYLAND
	13	return c->type == X11;
	14	#endif
	15	return 0;
	16	}
	17
	18	static inline struct wlr_surface *
	19	client_surface(Client *c)
	20	{
	21	#ifdef XWAYLAND
	22	if (client_is_x11(c))
	23	return c->surface.xwayland->surface;
	24	#endif
	25	return c->surface.xdg->surface;
	26	}
	27
	28	static inline int
	29	toplevel_from_wlr_surface(struct wlr_surface s, Client pc, LayerSurface *pl)
	30	{
	31	struct wlr_xdg_surface xdg_surface, tmp_xdg_surface;
	32	struct wlr_surface *root_surface;
	33	struct wlr_layer_surface_v1 *layer_surface;
	34	Client *c = NULL;
	35	LayerSurface *l = NULL;
	36	int type = -1;
	37	#ifdef XWAYLAND
	38	struct wlr_xwayland_surface *xsurface;
	39	#endif
	40
	41	if (!s)
	42	return -1;
	43	root_surface = wlr_surface_get_root_surface(s);
	44
	45	#ifdef XWAYLAND
	46	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(root_surface))) {
	47	c = xsurface->data;
	48	type = c->type;
	49	goto end;
	50	}
	51	#endif
	52
	53	if ((layer_surface = wlr_layer_surface_v1_try_from_wlr_surface(root_surface))) {
	54	l = layer_surface->data;
	55	type = LayerShell;
	56	goto end;
	57	}
	58
	59	xdg_surface = wlr_xdg_surface_try_from_wlr_surface(root_surface);
	60	while (xdg_surface) {
	61	tmp_xdg_surface = NULL;
	62	switch (xdg_surface->role) {
	63	case WLR_XDG_SURFACE_ROLE_POPUP:
	64	if (!xdg_surface->popup \|\| !xdg_surface->popup->parent)
	65	return -1;
	66
	67	tmp_xdg_surface = wlr_xdg_surface_try_from_wlr_surface(xdg_surface->popup->parent);
	68
	69	if (!tmp_xdg_surface)
	70	return toplevel_from_wlr_surface(xdg_surface->popup->parent, pc, pl);
	71
	72	xdg_surface = tmp_xdg_surface;
	73	break;
	74	case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
	75	c = xdg_surface->data;
	76	type = c->type;
	77	goto end;
	78	case WLR_XDG_SURFACE_ROLE_NONE:
	79	return -1;
	80	}
	81	}
	82
	83	end:
	84	if (pl)
	85	*pl = l;
	86	if (pc)
	87	*pc = c;
	88	return type;
	89	}
	90
	91	/* The others */
	92	static inline void
	93	client_activate_surface(struct wlr_surface *s, int activated)
	94	{
	95	struct wlr_xdg_toplevel *toplevel;
	96	#ifdef XWAYLAND
	97	struct wlr_xwayland_surface *xsurface;
	98	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
	99	wlr_xwayland_surface_activate(xsurface, activated);
	100	return;
	101	}
	102	#endif
	103	if ((toplevel = wlr_xdg_toplevel_try_from_wlr_surface(s)))
	104	wlr_xdg_toplevel_set_activated(toplevel, activated);
	105	}
	106
	107	static inline uint32_t
	108	client_set_bounds(Client *c, int32_t width, int32_t height)
	109	{
	110	#ifdef XWAYLAND
	111	if (client_is_x11(c))
	112	return 0;
	113	#endif
	114	if (wl_resource_get_version(c->surface.xdg->toplevel->resource) >=
	115	XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION && width >= 0 && height >= 0
	116	&& (c->bounds.width != width \|\| c->bounds.height != height)) {
	117	c->bounds.width = width;
	118	c->bounds.height = height;
	119	return wlr_xdg_toplevel_set_bounds(c->surface.xdg->toplevel, width, height);
	120	}
	121	return 0;
	122	}
	123
	124	static inline const char *
	125	client_get_appid(Client *c)
	126	{
	127	#ifdef XWAYLAND
	128	if (client_is_x11(c))
	129	return c->surface.xwayland->class ? c->surface.xwayland->class : "broken";
	130	#endif
	131	return c->surface.xdg->toplevel->app_id ? c->surface.xdg->toplevel->app_id : "broken";
	132	}
	133
	134	static inline void
	135	client_get_clip(Client c, struct wlr_box clip)
	136	{
	137	*clip = (struct wlr_box){
	138	.x = 0,
	139	.y = 0,
	140	.width = c->geom.width - c->bw,
	141	.height = c->geom.height - c->bw,
	142	};
	143
	144	#ifdef XWAYLAND
	145	if (client_is_x11(c))
	146	return;
	147	#endif
	148
	149	clip->x = c->surface.xdg->geometry.x;
	150	clip->y = c->surface.xdg->geometry.y;
	151	}
	152
	153	static inline void
	154	client_get_geometry(Client c, struct wlr_box geom)
	155	{
	156	#ifdef XWAYLAND
	157	if (client_is_x11(c)) {
	158	geom->x = c->surface.xwayland->x;
	159	geom->y = c->surface.xwayland->y;
	160	geom->width = c->surface.xwayland->width;
	161	geom->height = c->surface.xwayland->height;
	162	return;
	163	}
	164	#endif
	165	*geom = c->surface.xdg->geometry;
	166	}
	167
	168	static inline Client *
	169	client_get_parent(Client *c)
	170	{
	171	Client *p = NULL;
	172	#ifdef XWAYLAND
	173	if (client_is_x11(c)) {
	174	if (c->surface.xwayland->parent)
	175	toplevel_from_wlr_surface(c->surface.xwayland->parent->surface, &p, NULL);
	176	return p;
	177	}
	178	#endif
	179	if (c->surface.xdg->toplevel->parent)
	180	toplevel_from_wlr_surface(c->surface.xdg->toplevel->parent->base->surface, &p, NULL);
	181	return p;
	182	}
	183
	184	static inline int
	185	client_has_children(Client *c)
	186	{
	187	#ifdef XWAYLAND
	188	if (client_is_x11(c))
	189	return !wl_list_empty(&c->surface.xwayland->children);
	190	#endif
	191	/* surface.xdg->link is never empty because it always contains at least the
	192	* surface itself. */
	193	return wl_list_length(&c->surface.xdg->link) > 1;
	194	}
	195
	196	static inline const char *
	197	client_get_title(Client *c)
	198	{
	199	#ifdef XWAYLAND
	200	if (client_is_x11(c))
	201	return c->surface.xwayland->title ? c->surface.xwayland->title : "broken";
	202	#endif
	203	return c->surface.xdg->toplevel->title ? c->surface.xdg->toplevel->title : "broken";
	204	}
	205
	206	static inline int
	207	client_is_float_type(Client *c)
	208	{
	209	struct wlr_xdg_toplevel *toplevel;
	210	struct wlr_xdg_toplevel_state state;
	211
	212	#ifdef XWAYLAND
	213	if (client_is_x11(c)) {
	214	struct wlr_xwayland_surface *surface = c->surface.xwayland;
	215	xcb_size_hints_t *size_hints = surface->size_hints;
	216	if (surface->modal)
	217	return 1;
	218
	219	if (wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DIALOG)
	220	\|\| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_SPLASH)
	221	\|\| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLBAR)
	222	\|\| wlr_xwayland_surface_has_window_type(surface, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_UTILITY)) {
	223	return 1;
	224	}
	225
	226	return size_hints && size_hints->min_width > 0 && size_hints->min_height > 0
	227	&& (size_hints->max_width == size_hints->min_width
	228	\|\| size_hints->max_height == size_hints->min_height);
	229	}
	230	#endif
	231
	232	toplevel = c->surface.xdg->toplevel;
	233	state = toplevel->current;
	234	return toplevel->parent \|\| (state.min_width != 0 && state.min_height != 0
	235	&& (state.min_width == state.max_width
	236	\|\| state.min_height == state.max_height));
	237	}
	238
	239	static inline int
	240	client_is_rendered_on_mon(Client c, Monitor m)
	241	{
	242	/* This is needed for when you don't want to check formal assignment,
	243	* but rather actual displaying of the pixels.
	244	* Usually VISIBLEON suffices and is also faster. */
	245	struct wlr_surface_output *s;
	246	int unused_lx, unused_ly;
	247	if (!wlr_scene_node_coords(&c->scene->node, &unused_lx, &unused_ly))
	248	return 0;
	249	wl_list_for_each(s, &client_surface(c)->current_outputs, link)
	250	if (s->output == m->wlr_output)
	251	return 1;
	252	return 0;
	253	}
	254
	255	static inline int
	256	client_is_stopped(Client *c)
	257	{
	258	int pid;
	259	siginfo_t in = {0};
	260	#ifdef XWAYLAND
	261	if (client_is_x11(c))
	262	return 0;
	263	#endif
	264
	265	wl_client_get_credentials(c->surface.xdg->client->client, &pid, NULL, NULL);
	266	if (waitid(P_PID, pid, &in, WNOHANG\|WCONTINUED\|WSTOPPED\|WNOWAIT) < 0) {
	267	/* This process is not our child process, while is very unlikely that
	268	* it is stopped, in order to do not skip frames, assume that it is. */
	269	if (errno == ECHILD)
	270	return 1;
	271	} else if (in.si_pid) {
	272	if (in.si_code == CLD_STOPPED \|\| in.si_code == CLD_TRAPPED)
	273	return 1;
	274	if (in.si_code == CLD_CONTINUED)
	275	return 0;
	276	}
	277
	278	return 0;
	279	}
	280
	281	static inline int
	282	client_is_unmanaged(Client *c)
	283	{
	284	#ifdef XWAYLAND
	285	if (client_is_x11(c))
	286	return c->surface.xwayland->override_redirect;
	287	#endif
	288	return 0;
	289	}
	290
	291	static inline void
	292	client_notify_enter(struct wlr_surface s, struct wlr_keyboard kb)
	293	{
	294	if (kb)
	295	wlr_seat_keyboard_notify_enter(seat, s, kb->keycodes,
	296	kb->num_keycodes, &kb->modifiers);
	297	else
	298	wlr_seat_keyboard_notify_enter(seat, s, NULL, 0, NULL);
	299	}
	300
	301	static inline void
	302	client_send_close(Client *c)
	303	{
	304	#ifdef XWAYLAND
	305	if (client_is_x11(c)) {
	306	wlr_xwayland_surface_close(c->surface.xwayland);
	307	return;
	308	}
	309	#endif
	310	wlr_xdg_toplevel_send_close(c->surface.xdg->toplevel);
	311	}
	312
	313	static inline void
	314	client_set_border_color(Client *c, const float inner[static 4], const float outer[static 4])
	315	{
	316	int i;
	317	for (i = 0; i < 4; i++) {
	318	wlr_scene_rect_set_color(c->inner_border[i], inner);
	319	wlr_scene_rect_set_color(c->outer_border[i], outer);
	320	}
	321	}
	322
	323
	324	/* Opacity black magic I cooked up half asleep. Idk how this works so uhm
	325	* baii */
	326
	327	static inline void
	328	client_node_apply_opacity(struct wlr_scene_node *node, float opacity)
	329	{
	330	struct wlr_scene_tree *tree;
	331	struct wlr_scene_node *child;
	332
	333	if (!node->enabled && node->type != WLR_SCENE_NODE_TREE)
	334	return;
	335
	336	switch (node->type) {
	337	case WLR_SCENE_NODE_BUFFER:
	338	wlr_scene_buffer_set_opacity(wlr_scene_buffer_from_node(node), opacity);
	339	break;
	340	case WLR_SCENE_NODE_TREE:
	341	tree = wlr_scene_tree_from_node(node);
	342	wl_list_for_each(child, &tree->children, link)
	343	client_node_apply_opacity(child, opacity);
	344	break;
	345	case WLR_SCENE_NODE_RECT:
	346	default:
	347	break;
	348	}
	349	}
	350
	351	static inline void
	352	client_apply_opacity(Client *c)
	353	{
	354	client_node_apply_opacity(&c->scene_surface->node, c->isfullscreen ? 1.0f : c->opacity);
	355	}
	356
	357	static inline void
	358	client_set_opacity(Client *c, float opacity)
	359	{
	360	c->opacity = opacity;
	361	client_apply_opacity(c);
	362	}
	363
	364	static inline void
	365	client_set_fullscreen(Client *c, int fullscreen)
	366	{
	367	#ifdef XWAYLAND
	368	if (client_is_x11(c)) {
	369	wlr_xwayland_surface_set_fullscreen(c->surface.xwayland, fullscreen);
	370	return;
	371	}
	372	#endif
	373	wlr_xdg_toplevel_set_fullscreen(c->surface.xdg->toplevel, fullscreen);
	374	}
	375
	376	static inline void
	377	client_set_scale(struct wlr_surface *s, float scale)
	378	{
	379	wlr_fractional_scale_v1_notify_scale(s, scale);
	380	wlr_surface_set_preferred_buffer_scale(s, (int32_t)ceilf(scale));
	381	}
	382
	383	static inline uint32_t
	384	client_set_size(Client *c, uint32_t width, uint32_t height)
	385	{
	386	#ifdef XWAYLAND
	387	if (client_is_x11(c)) {
	388	wlr_xwayland_surface_configure(c->surface.xwayland,
	389	c->geom.x + c->bw, c->geom.y + c->bw, width, height);
	390	return 0;
	391	}
	392	#endif
	393	if ((int32_t)width == c->surface.xdg->toplevel->current.width
	394	&& (int32_t)height == c->surface.xdg->toplevel->current.height)
	395	return 0;
	396	return wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, (int32_t)width, (int32_t)height);
	397	}
	398
	399	static inline void
	400	client_set_tiled(Client *c, uint32_t edges)
	401	{
	402	#ifdef XWAYLAND
	403	if (client_is_x11(c)) {
	404	wlr_xwayland_surface_set_maximized(c->surface.xwayland,
	405	edges != WLR_EDGE_NONE, edges != WLR_EDGE_NONE);
	406	return;
	407	}
	408	#endif
	409	if (wl_resource_get_version(c->surface.xdg->toplevel->resource)
	410	>= XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) {
	411	wlr_xdg_toplevel_set_tiled(c->surface.xdg->toplevel, edges);
	412	} else {
	413	wlr_xdg_toplevel_set_maximized(c->surface.xdg->toplevel, edges != WLR_EDGE_NONE);
	414	}
	415	}
	416
	417	static inline void
	418	client_set_suspended(Client *c, int suspended)
	419	{
	420	#ifdef XWAYLAND
	421	if (client_is_x11(c))
	422	return;
	423	#endif
	424
	425	wlr_xdg_toplevel_set_suspended(c->surface.xdg->toplevel, suspended);
	426	}
	427
	428	static inline int
	429	client_wants_focus(Client *c)
	430	{
	431	#ifdef XWAYLAND
	432	return client_is_unmanaged(c)
	433	&& wlr_xwayland_surface_override_redirect_wants_focus(c->surface.xwayland)
	434	&& wlr_xwayland_surface_icccm_input_model(c->surface.xwayland) != WLR_ICCCM_INPUT_MODEL_NONE;
	435	#endif
	436	return 0;
	437	}
	438
	439	static inline int
	440	client_wants_fullscreen(Client *c)
	441	{
	442	#ifdef XWAYLAND
	443	if (client_is_x11(c))
	444	return c->surface.xwayland->fullscreen;
	445	#endif
	446	return c->surface.xdg->toplevel->requested.fullscreen;
	447	}

include/dwl-ipc.h

0 created 644 +284 0

@@ -0,0 +1,284
	1	#include "dwl-ipc-unstable-v2-protocol.h"
	2
	3	/* Forward declarations for dwl.c static functions */
	4
	5	static void arrange(Monitor *m);
	6	static void focusclient(Client *c, int lift);
	7	static Client focustop(Monitor m);
	8	static void printstatus(void);
	9
	10	/* globals */
	11
	12	static struct wl_global *ipc_global = NULL;
	13	/* All bound manager objects */
	14	static struct wl_list ipc_managers; /* IpcManager.link */
	15
	16	typedef struct {
	17	struct wl_resource *resource;
	18	struct wl_list link; /* ipc_managers */
	19	struct wl_list outputs; /* IpcOutput.link */
	20	} IpcManager;
	21
	22	typedef struct {
	23	struct wl_resource *resource;
	24	Monitor *mon;
	25	struct wl_list link; /* IpcManager.outputs */
	26	} IpcOutput;
	27
	28	/* helpers */
	29
	30	static IpcOutput *
	31	ipc_output_for_mon(IpcManager mgr, Monitor m)
	32	{
	33	IpcOutput *o;
	34	wl_list_for_each(o, &mgr->outputs, link)
	35	if (o->mon == m)
	36	return o;
	37	return NULL;
	38	}
	39
	40	/* Send the full state of monitor m to one IpcOutput resource */
	41	static void
	42	ipc_send_output_state(IpcOutput *ipc_out)
	43	{
	44	Monitor *m = ipc_out->mon;
	45	struct wl_resource *res = ipc_out->resource;
	46	Client *c;
	47	uint32_t occ = 0, urg = 0, sel_tags = 0;
	48	int tag, focused;
	49
	50	/* Compute occupancy/urgency (same logic as printstatus, I think) */
	51	wl_list_for_each(c, &clients, link) {
	52	if (c->mon != m)
	53	continue;
	54	occ \|= c->tags;
	55	if (c->isurgent)
	56	urg \|= c->tags;
	57	}
	58
	59	c = focustop(m);
	60	sel_tags = c ? c->tags : 0;
	61
	62	/* active */
	63	zdwl_ipc_output_v2_send_active(res, m == selmon ? 1 : 0);
	64
	65	/* per-tag state */
	66	for (tag = 0; tag < TAGCOUNT; tag++) {
	67	uint32_t mask = 1u << tag;
	68	uint32_t state = ZDWL_IPC_OUTPUT_V2_TAG_STATE_NONE;
	69	uint32_t clients_on_tag = 0;
	70
	71	if (m->tagset[m->seltags] & mask)
	72	state = ZDWL_IPC_OUTPUT_V2_TAG_STATE_ACTIVE;
	73	if (urg & mask)
	74	state = ZDWL_IPC_OUTPUT_V2_TAG_STATE_URGENT;
	75	if (occ & mask)
	76	clients_on_tag = 1; /* report ≥1, not exact count */
	77
	78	focused = (sel_tags & mask) ? 1 : 0;
	79	zdwl_ipc_output_v2_send_tag(res, tag, state, clients_on_tag, focused);
	80	}
	81
	82	/* layout index */
	83	{
	84	uint32_t i;
	85	for (i = 0; i < LENGTH(layouts); i++)
	86	if (&layouts[i] == m->lt[m->sellt])
	87	break;
	88	zdwl_ipc_output_v2_send_layout(res, i);
	89	}
	90
	91	/* layout symbol */
	92	zdwl_ipc_output_v2_send_layout_symbol(res, m->ltsymbol);
	93
	94	/* title/appid/fullscreen/floating */
	95	if (c) {
	96	zdwl_ipc_output_v2_send_title(res, client_get_title(c));
	97	zdwl_ipc_output_v2_send_appid(res, client_get_appid(c));
	98	if (wl_resource_get_version(res) >= 2) {
	99	zdwl_ipc_output_v2_send_fullscreen(res, c->isfullscreen ? 1 : 0);
	100	zdwl_ipc_output_v2_send_floating(res, c->isfloating ? 1 : 0);
	101	}
	102	} else {
	103	zdwl_ipc_output_v2_send_title(res, "");
	104	zdwl_ipc_output_v2_send_appid(res, "");
	105	if (wl_resource_get_version(res) >= 2) {
	106	zdwl_ipc_output_v2_send_fullscreen(res, 0);
	107	zdwl_ipc_output_v2_send_floating(res, 0);
	108	}
	109	}
	110
	111	/* frame — signals end of this batch of events */
	112	zdwl_ipc_output_v2_send_frame(res);
	113	}
	114
	115	/* Called instead of (or alongside) the old printstatus() */
	116	static void
	117	ipc_printstatus(void)
	118	{
	119	IpcManager *mgr;
	120	Monitor *m;
	121
	122	wl_list_for_each(mgr, &ipc_managers, link) {
	123	wl_list_for_each(m, &mons, link) {
	124	IpcOutput *out = ipc_output_for_mon(mgr, m);
	125	if (out)
	126	ipc_send_output_state(out);
	127	}
	128	}
	129	}
	130
	131	/* zdwl_ipc_output_v2 requests */
	132
	133	static void
	134	ipc_output_handle_release(struct wl_client client, struct wl_resource resource)
	135	{
	136	wl_resource_destroy(resource);
	137	}
	138
	139	static void
	140	ipc_output_handle_set_tags(struct wl_client client, struct wl_resource resource,
	141	uint32_t tagmask, uint32_t toggle_tagset)
	142	{
	143	IpcOutput *out = wl_resource_get_user_data(resource);
	144	Monitor *m = out->mon;
	145	if (!m) return;
	146
	147	if (toggle_tagset)
	148	m->seltags ^= 1;
	149	m->tagset[m->seltags] = tagmask & TAGMASK;
	150	focusclient(focustop(m), 1);
	151	arrange(m);
	152	printstatus();
	153	}
	154
	155	static void
	156	ipc_output_handle_set_client_tags(struct wl_client *client,
	157	struct wl_resource *resource, uint32_t and_tags, uint32_t xor_tags)
	158	{
	159	IpcOutput *out = wl_resource_get_user_data(resource);
	160	Monitor *m = out->mon;
	161	Client *sel;
	162	uint32_t newtags;
	163	if (!m) return;
	164
	165	sel = focustop(m);
	166	if (!sel) return;
	167
	168	newtags = (sel->tags & and_tags) ^ xor_tags;
	169	if (!newtags) return;
	170	sel->tags = newtags;
	171	focusclient(focustop(m), 1);
	172	arrange(m);
	173	printstatus();
	174	}
	175
	176	static void
	177	ipc_output_handle_set_layout(struct wl_client *client,
	178	struct wl_resource *resource, uint32_t idx)
	179	{
	180	IpcOutput *out = wl_resource_get_user_data(resource);
	181	Monitor *m = out->mon;
	182	if (!m \|\| idx >= LENGTH(layouts)) return;
	183
	184	m->lt[m->sellt] = &layouts[idx];
	185	strncpy(m->ltsymbol, layouts[idx].symbol, LENGTH(m->ltsymbol));
	186	arrange(m);
	187	printstatus();
	188	}
	189
	190	static const struct zdwl_ipc_output_v2_interface ipc_output_impl = {
	191	.release = ipc_output_handle_release,
	192	.set_tags = ipc_output_handle_set_tags,
	193	.set_client_tags = ipc_output_handle_set_client_tags,
	194	.set_layout = ipc_output_handle_set_layout,
	195	};
	196
	197	static void
	198	ipc_output_destroy(struct wl_resource *resource)
	199	{
	200	IpcOutput *out = wl_resource_get_user_data(resource);
	201	wl_list_remove(&out->link);
	202	free(out);
	203	}
	204
	205	/* zdwl_ipc_manager_v2 requests */
	206
	207	static void
	208	ipc_manager_handle_release(struct wl_client client, struct wl_resource resource)
	209	{
	210	wl_resource_destroy(resource);
	211	}
	212
	213	static void
	214	ipc_manager_handle_get_output(struct wl_client client, struct wl_resource resource,
	215	uint32_t id, struct wl_resource *output_resource)
	216	{
	217	IpcManager *mgr = wl_resource_get_user_data(resource);
	218	struct wlr_output *wlr_out = wlr_output_from_resource(output_resource);
	219	Monitor *m = (wlr_out && wlr_out->data) ? wlr_out->data : NULL;
	220
	221	IpcOutput out = ecalloc(1, sizeof(out));
	222	out->mon = m;
	223	out->resource = wl_resource_create(client, &zdwl_ipc_output_v2_interface,
	224	wl_resource_get_version(resource), id);
	225	if (!out->resource) {
	226	free(out);
	227	wl_client_post_no_memory(client);
	228	return;
	229	}
	230	wl_resource_set_implementation(out->resource, &ipc_output_impl,
	231	out, ipc_output_destroy);
	232	wl_list_insert(&mgr->outputs, &out->link);
	233
	234	if (m)
	235	ipc_send_output_state(out);
	236	}
	237
	238	static const struct zdwl_ipc_manager_v2_interface ipc_manager_impl = {
	239	.release = ipc_manager_handle_release,
	240	.get_output = ipc_manager_handle_get_output,
	241	};
	242
	243	static void
	244	ipc_manager_destroy(struct wl_resource *resource)
	245	{
	246	IpcManager *mgr = wl_resource_get_user_data(resource);
	247	IpcOutput out, tmp;
	248	wl_list_for_each_safe(out, tmp, &mgr->outputs, link)
	249	wl_resource_destroy(out->resource);
	250	wl_list_remove(&mgr->link);
	251	free(mgr);
	252	}
	253
	254	/* global bind */
	255
	256	static void
	257	ipc_bind(struct wl_client client, void data, uint32_t version, uint32_t id)
	258	{
	259	IpcManager mgr = ecalloc(1, sizeof(mgr));
	260	wl_list_init(&mgr->outputs);
	261	mgr->resource = wl_resource_create(client, &zdwl_ipc_manager_v2_interface,
	262	version, id);
	263	if (!mgr->resource) {
	264	free(mgr);
	265	wl_client_post_no_memory(client);
	266	return;
	267	}
	268	wl_resource_set_implementation(mgr->resource, &ipc_manager_impl,
	269	mgr, ipc_manager_destroy);
	270	wl_list_insert(&ipc_managers, &mgr->link);
	271
	272	/* Announce tags and layouts */
	273	zdwl_ipc_manager_v2_send_tags(mgr->resource, TAGCOUNT);
	274	for (uint32_t i = 0; i < LENGTH(layouts); i++)
	275	zdwl_ipc_manager_v2_send_layout(mgr->resource, layouts[i].symbol);
	276	}
	277
	278	static void
	279	ipc_init(void)
	280	{
	281	wl_list_init(&ipc_managers);
	282	ipc_global = wl_global_create(dpy, &zdwl_ipc_manager_v2_interface,
	283	2, NULL, ipc_bind);
	284	}

include/ext-workspace.h

0 created 644 +210 0

@@ -0,0 +1,210
	1	/* My shitty port of Mango's ext-workspace.h for my compositor;
	2	* thanks DreamMaoMao for doing most of the heavy lifting
	3	* by actually writing the thing, it didn't work the first
	4	* few tries and I barely have any idea how this code works anyway.
	5	* To say that it's the eighth wonder of the world
	6	* would be an understatement
	7	*/
	8
	9	#include "wlr_ext_workspace_v1.h"
	10
	11	#define EXT_WORKSPACE_CAPS \
	12	(EXT_WORKSPACE_HANDLE_V1_WORKSPACE_CAPABILITIES_ACTIVATE \| \
	13	EXT_WORKSPACE_HANDLE_V1_WORKSPACE_CAPABILITIES_DEACTIVATE)
	14
	15	/* types */
	16
	17	struct ext_workspace {
	18	struct wl_list link;
	19	uint32_t tag;
	20	Monitor *m;
	21	struct wlr_ext_workspace_handle_v1 *handle;
	22	};
	23
	24	/* global */
	25
	26	static struct wlr_ext_workspace_manager_v1 *ext_workspace_manager;
	27	static struct wl_list ext_workspaces;
	28	static struct wl_listener ext_commit_listener;
	29	static struct wl_listener ext_destroy_listener;
	30
	31	/* helpers */
	32
	33
	34	static int
	35	get_tag_status(uint32_t tag, Monitor *m)
	36	{
	37	Client *c;
	38	uint32_t mask = 1 << (tag - 1);
	39
	40	wl_list_for_each(c, &clients, link) {
	41	if (c->mon != m)
	42	continue;
	43	if (!(c->tags & mask))
	44	continue;
	45	if (c->isurgent)
	46	return 2;
	47	return 1;
	48	}
	49	return 0;
	50	}
	51
	52	static const char *
	53	tag_name(uint32_t tag)
	54	{
	55	static const char *names[] = {
	56	"1", "2", "3", "4", "5", "6", "7", "8", "9",
	57	};
	58	if (tag >= 1 && tag <= LENGTH(names))
	59	return names[tag - 1];
	60	return "?";
	61	}
	62
	63	/* workspace lifecycle */
	64
	65	static void
	66	ext_workspace_destroy(struct ext_workspace *ws)
	67	{
	68	wlr_ext_workspace_handle_v1_destroy(ws->handle);
	69	wl_list_remove(&ws->link);
	70	free(ws);
	71	}
	72
	73	static void
	74	ext_workspace_create(uint32_t tag, Monitor *m)
	75	{
	76	const char *name = tag_name(tag);
	77
	78	struct ext_workspace ws = ecalloc(1, sizeof(ws));
	79	ws->tag = tag;
	80	ws->m = m;
	81	ws->handle = wlr_ext_workspace_handle_v1_create(
	82	ext_workspace_manager, name, EXT_WORKSPACE_CAPS);
	83	ws->handle->data = ws;
	84
	85	wlr_ext_workspace_handle_v1_set_group(ws->handle, m->ext_group);
	86	wlr_ext_workspace_handle_v1_set_name(ws->handle, name);
	87
	88	wl_list_insert(ext_workspaces.prev, &ws->link);
	89	}
	90
	91	/* monitor integration */
	92
	93	static void
	94	ext_workspace_createmon(Monitor *m)
	95	{
	96	uint32_t i;
	97
	98	m->ext_group = wlr_ext_workspace_group_handle_v1_create(
	99	ext_workspace_manager, 0);
	100	wlr_ext_workspace_group_handle_v1_output_enter(
	101	m->ext_group, m->wlr_output);
	102
	103	for (i = 1; i <= TAGCOUNT; i++)
	104	ext_workspace_create(i, m);
	105	}
	106
	107	static void
	108	ext_workspace_cleanupmon(Monitor *m)
	109	{
	110	struct ext_workspace ws, tmp;
	111	wl_list_for_each_safe(ws, tmp, &ext_workspaces, link)
	112	if (ws->m == m)
	113	ext_workspace_destroy(ws);
	114
	115	wlr_ext_workspace_group_handle_v1_output_leave(
	116	m->ext_group, m->wlr_output);
	117	wlr_ext_workspace_group_handle_v1_destroy(m->ext_group);
	118	m->ext_group = NULL;
	119	}
	120
	121	/* status */
	122
	123	static void
	124	ext_workspace_printstatus(Monitor *m)
	125	{
	126	struct ext_workspace *ws;
	127
	128	wl_list_for_each(ws, &ext_workspaces, link) {
	129	if (ws->m != m)
	130	continue;
	131
	132	int status = get_tag_status(ws->tag, m);
	133	int active = !!(m->tagset[m->seltags] & (1 << (ws->tag - 1)) & TAGMASK);
	134
	135	wlr_ext_workspace_handle_v1_set_urgent(ws->handle, status == 2);
	136	wlr_ext_workspace_handle_v1_set_hidden(ws->handle, 0);
	137	wlr_ext_workspace_handle_v1_set_active(ws->handle, active);
	138	}
	139	}
	140
	141	/* commit handler */
	142
	143	static void
	144	handle_ext_commit(struct wl_listener listener, void data)
	145	{
	146	struct wlr_ext_workspace_v1_commit_event *event = data;
	147	struct wlr_ext_workspace_v1_request *req;
	148
	149	wl_list_for_each(req, event->requests, link) {
	150	struct ext_workspace *ws = NULL;
	151	struct ext_workspace *w;
	152
	153	switch (req->type) {
	154	case WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE:
	155	if (!req->activate.workspace)
	156	break;
	157	wl_list_for_each(w, &ext_workspaces, link) {
	158	if (w->handle == req->activate.workspace) {
	159	ws = w;
	160	break;
	161	}
	162	}
	163	if (!ws)
	164	break;
	165	view(&(Arg){.ui = 1 << (ws->tag - 1)});
	166	break;
	167
	168	case WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE:
	169	if (!req->deactivate.workspace)
	170	break;
	171	wl_list_for_each(w, &ext_workspaces, link) {
	172	if (w->handle == req->deactivate.workspace) {
	173	ws = w;
	174	break;
	175	}
	176	}
	177	if (!ws)
	178	break;
	179	toggleview(&(Arg){.ui = 1 << (ws->tag - 1)});
	180	break;
	181
	182	default:
	183	break;
	184	}
	185	}
	186	}
	187
	188	/* init */
	189
	190	static void
	191	handle_ext_destroy(struct wl_listener listener, void data)
	192	{
	193	wl_list_remove(&ext_commit_listener.link);
	194	wl_list_remove(&ext_destroy_listener.link);
	195	}
	196
	197	static void
	198	workspaces_init(void)
	199	{
	200	ext_workspace_manager = wlr_ext_workspace_manager_v1_create(dpy, 1);
	201	wl_list_init(&ext_workspaces);
	202
	203	ext_commit_listener.notify = handle_ext_commit;
	204	wl_signal_add(&ext_workspace_manager->events.commit,
	205	&ext_commit_listener);
	206
	207	ext_destroy_listener.notify = handle_ext_destroy;
	208	wl_signal_add(&ext_workspace_manager->events.destroy,
	209	&ext_destroy_listener);
	210	}

licenses/LICENSE

0 created 644 +351 0

@@ -0,0 +1,351
	1	swindle - wayland compositor
	2
	3	Copyright © 2026 kantiankant
	4
	5	See also the files LICENSE.dwl, LICENSE.dwm,
	6	LICENSE.tinywl, LICENSE.sway, LICENSE.wlroots, LICENSE.mangowm.
	7
	8	This program is free software: you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation, version 2 of the License.
	11
	12	----
	13
	14	GNU GENERAL PUBLIC LICENSE
	15	Version 2, June 1991
	16
	17	Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
	18	<https://fsf.org/>
	19	Everyone is permitted to copy and distribute verbatim copies
	20	of this license document, but changing it is not allowed.
	21
	22	Preamble
	23
	24	The licenses for most software are designed to take away your
	25	freedom to share and change it. By contrast, the GNU General Public
	26	License is intended to guarantee your freedom to share and change free
	27	software--to make sure the software is free for all its users. This
	28	General Public License applies to most of the Free Software
	29	Foundation's software and to any other program whose authors commit to
	30	using it. (Some other Free Software Foundation software is covered by
	31	the GNU Lesser General Public License instead.) You can apply it to
	32	your programs, too.
	33
	34	When we speak of free software, we are referring to freedom, not
	35	price. Our General Public Licenses are designed to make sure that you
	36	have the freedom to distribute copies of free software (and charge for
	37	this service if you wish), that you receive source code or can get it
	38	if you want it, that you can change the software or use pieces of it
	39	in new free programs; and that you know you can do these things.
	40
	41	To protect your rights, we need to make restrictions that forbid
	42	anyone to deny you these rights or to ask you to surrender the rights.
	43	These restrictions translate to certain responsibilities for you if you
	44	distribute copies of the software, or if you modify it.
	45
	46	For example, if you distribute copies of such a program, whether
	47	gratis or for a fee, you must give the recipients all the rights that
	48	you have. You must make sure that they, too, receive or can get the
	49	source code. And you must show them these terms so they know their
	50	rights.
	51
	52	We protect your rights with two steps: (1) copyright the software, and
	53	(2) offer you this license which gives you legal permission to copy,
	54	distribute and/or modify the software.
	55
	56	Also, for each author's protection and ours, we want to make certain
	57	that everyone understands that there is no warranty for this free
	58	software. If the software is modified by someone else and passed on, we
	59	want its recipients to know that what they have is not the original, so
	60	that any problems introduced by others will not reflect on the original
	61	authors' reputations.
	62
	63	Finally, any free program is threatened constantly by software
	64	patents. We wish to avoid the danger that redistributors of a free
	65	program will individually obtain patent licenses, in effect making the
	66	program proprietary. To prevent this, we have made it clear that any
	67	patent must be licensed for everyone's free use or not licensed at all.
	68
	69	The precise terms and conditions for copying, distribution and
	70	modification follow.
	71
	72	GNU GENERAL PUBLIC LICENSE
	73	TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
	74
	75	0. This License applies to any program or other work which contains
	76	a notice placed by the copyright holder saying it may be distributed
	77	under the terms of this General Public License. The "Program", below,
	78	refers to any such program or work, and a "work based on the Program"
	79	means either the Program or any derivative work under copyright law:
	80	that is to say, a work containing the Program or a portion of it,
	81	either verbatim or with modifications and/or translated into another
	82	language. (Hereinafter, translation is included without limitation in
	83	the term "modification".) Each licensee is addressed as "you".
	84
	85	Activities other than copying, distribution and modification are not
	86	covered by this License; they are outside its scope. The act of
	87	running the Program is not restricted, and the output from the Program
	88	is covered only if its contents constitute a work based on the
	89	Program (independent of having been made by running the Program).
	90	Whether that is true depends on what the Program does.
	91
	92	1. You may copy and distribute verbatim copies of the Program's
	93	source code as you receive it, in any medium, provided that you
	94	conspicuously and appropriately publish on each copy an appropriate
	95	copyright notice and disclaimer of warranty; keep intact all the
	96	notices that refer to this License and to the absence of any warranty;
	97	and give any other recipients of the Program a copy of this License
	98	along with the Program.
	99
	100	You may charge a fee for the physical act of transferring a copy, and
	101	you may at your option offer warranty protection in exchange for a fee.
	102
	103	2. You may modify your copy or copies of the Program or any portion
	104	of it, thus forming a work based on the Program, and copy and
	105	distribute such modifications or work under the terms of Section 1
	106	above, provided that you also meet all of these conditions:
	107
	108	a) You must cause the modified files to carry prominent notices
	109	stating that you changed the files and the date of any change.
	110
	111	b) You must cause any work that you distribute or publish, that in
	112	whole or in part contains or is derived from the Program or any
	113	part thereof, to be licensed as a whole at no charge to all third
	114	parties under the terms of this License.
	115
	116	c) If the modified program normally reads commands interactively
	117	when run, you must cause it, when started running for such
	118	interactive use in the most ordinary way, to print or display an
	119	announcement including an appropriate copyright notice and a
	120	notice that there is no warranty (or else, saying that you provide
	121	a warranty) and that users may redistribute the program under
	122	these conditions, and telling the user how to view a copy of this
	123	License. (Exception: if the Program itself is interactive but
	124	does not normally print such an announcement, your work based on
	125	the Program is not required to print an announcement.)
	126
	127	These requirements apply to the modified work as a whole. If
	128	identifiable sections of that work are not derived from the Program,
	129	and can be reasonably considered independent and separate works in
	130	themselves, then this License, and its terms, do not apply to those
	131	sections when you distribute them as separate works. But when you
	132	distribute the same sections as part of a whole which is a work based
	133	on the Program, the distribution of the whole must be on the terms of
	134	this License, whose permissions for other licensees extend to the
	135	entire whole, and thus to each and every part regardless of who wrote it.
	136
	137	Thus, it is not the intent of this section to claim rights or contest
	138	your rights to work written entirely by you; rather, the intent is to
	139	exercise the right to control the distribution of derivative or
	140	collective works based on the Program.
	141
	142	In addition, mere aggregation of another work not based on the Program
	143	with the Program (or with a work based on the Program) on a volume of
	144	a storage or distribution medium does not bring the other work under
	145	the scope of this License.
	146
	147	3. You may copy and distribute the Program (or a work based on it,
	148	under Section 2) in object code or executable form under the terms of
	149	Sections 1 and 2 above provided that you also do one of the following:
	150
	151	a) Accompany it with the complete corresponding machine-readable
	152	source code, which must be distributed under the terms of Sections
	153	1 and 2 above on a medium customarily used for software interchange; or,
	154
	155	b) Accompany it with a written offer, valid for at least three
	156	years, to give any third party, for a charge no more than your
	157	cost of physically performing source distribution, a complete
	158	machine-readable copy of the corresponding source code, to be
	159	distributed under the terms of Sections 1 and 2 above on a medium
	160	customarily used for software interchange; or,
	161
	162	c) Accompany it with the information you received as to the offer
	163	to distribute corresponding source code. (This alternative is
	164	allowed only for noncommercial distribution and only if you
	165	received the program in object code or executable form with such
	166	an offer, in accord with Subsection b above.)
	167
	168	The source code for a work means the preferred form of the work for
	169	making modifications to it. For an executable work, complete source
	170	code means all the source code for all modules it contains, plus any
	171	associated interface definition files, plus the scripts used to
	172	control compilation and installation of the executable. However, as a
	173	special exception, the source code distributed need not include
	174	anything that is normally distributed (in either source or binary
	175	form) with the major components (compiler, kernel, and so on) of the
	176	operating system on which the executable runs, unless that component
	177	itself accompanies the executable.
	178
	179	If distribution of executable or object code is made by offering
	180	access to copy from a designated place, then offering equivalent
	181	access to copy the source code from the same place counts as
	182	distribution of the source code, even though third parties are not
	183	compelled to copy the source along with the object code.
	184
	185	4. You may not copy, modify, sublicense, or distribute the Program
	186	except as expressly provided under this License. Any attempt
	187	otherwise to copy, modify, sublicense or distribute the Program is
	188	void, and will automatically terminate your rights under this License.
	189	However, parties who have received copies, or rights, from you under
	190	this License will not have their licenses terminated so long as such
	191	parties remain in full compliance.
	192
	193	5. You are not required to accept this License, since you have not
	194	signed it. However, nothing else grants you permission to modify or
	195	distribute the Program or its derivative works. These actions are
	196	prohibited by law if you do not accept this License. Therefore, by
	197	modifying or distributing the Program (or any work based on the
	198	Program), you indicate your acceptance of this License to do so, and
	199	all its terms and conditions for copying, distributing or modifying
	200	the Program or works based on it.
	201
	202	6. Each time you redistribute the Program (or any work based on the
	203	Program), the recipient automatically receives a license from the
	204	original licensor to copy, distribute or modify the Program subject to
	205	these terms and conditions. You may not impose any further
	206	restrictions on the recipients' exercise of the rights granted herein.
	207	You are not responsible for enforcing compliance by third parties to
	208	this License.
	209
	210	7. If, as a consequence of a court judgment or allegation of patent
	211	infringement or for any other reason (not limited to patent issues),
	212	conditions are imposed on you (whether by court order, agreement or
	213	otherwise) that contradict the conditions of this License, they do not
	214	excuse you from the conditions of this License. If you cannot
	215	distribute so as to satisfy simultaneously your obligations under this
	216	License and any other pertinent obligations, then as a consequence you
	217	may not distribute the Program at all. For example, if a patent
	218	license would not permit royalty-free redistribution of the Program by
	219	all those who receive copies directly or indirectly through you, then
	220	the only way you could satisfy both it and this License would be to
	221	refrain entirely from distribution of the Program.
	222
	223	If any portion of this section is held invalid or unenforceable under
	224	any particular circumstance, the balance of the section is intended to
	225	apply and the section as a whole is intended to apply in other
	226	circumstances.
	227
	228	It is not the purpose of this section to induce you to infringe any
	229	patents or other property right claims or to contest validity of any
	230	such claims; this section has the sole purpose of protecting the
	231	integrity of the free software distribution system, which is
	232	implemented by public license practices. Many people have made
	233	generous contributions to the wide range of software distributed
	234	through that system in reliance on consistent application of that
	235	system; it is up to the author/donor to decide if he or she is willing
	236	to distribute software through any other system and a licensee cannot
	237	impose that choice.
	238
	239	This section is intended to make thoroughly clear what is believed to
	240	be a consequence of the rest of this License.
	241
	242	8. If the distribution and/or use of the Program is restricted in
	243	certain countries either by patents or by copyrighted interfaces, the
	244	original copyright holder who places the Program under this License
	245	may add an explicit geographical distribution limitation excluding
	246	those countries, so that distribution is permitted only in or among
	247	countries not thus excluded. In such case, this License incorporates
	248	the limitation as if written in the body of this License.
	249
	250	9. The Free Software Foundation may publish revised and/or new versions
	251	of the General Public License from time to time. Such new versions will
	252	be similar in spirit to the present version, but may differ in detail to
	253	address new problems or concerns.
	254
	255	Each version is given a distinguishing version number. If the Program
	256	specifies a version number of this License which applies to it and "any
	257	later version", you have the option of following the terms and conditions
	258	either of that version or of any later version published by the Free
	259	Software Foundation. If the Program does not specify a version number of
	260	this License, you may choose any version ever published by the Free Software
	261	Foundation.
	262
	263	10. If you wish to incorporate parts of the Program into other free
	264	programs whose distribution conditions are different, write to the author
	265	to ask for permission. For software which is copyrighted by the Free
	266	Software Foundation, write to the Free Software Foundation; we sometimes
	267	make exceptions for this. Our decision will be guided by the two goals
	268	of preserving the free status of all derivatives of our free software and
	269	of promoting the sharing and reuse of software generally.
	270
	271	NO WARRANTY
	272
	273	11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
	274	FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
	275	OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
	276	PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
	277	OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	278	MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
	279	TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
	280	PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
	281	REPAIR OR CORRECTION.
	282
	283	12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
	284	WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
	285	REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
	286	INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
	287	OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
	288	TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
	289	YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
	290	PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
	291	POSSIBILITY OF SUCH DAMAGES.
	292
	293	END OF TERMS AND CONDITIONS
	294
	295	How to Apply These Terms to Your New Programs
	296
	297	If you develop a new program, and you want it to be of the greatest
	298	possible use to the public, the best way to achieve this is to make it
	299	free software which everyone can redistribute and change under these terms.
	300
	301	To do so, attach the following notices to the program. It is safest
	302	to attach them to the start of each source file to most effectively
	303	convey the exclusion of warranty; and each file should have at least
	304	the "copyright" line and a pointer to where the full notice is found.
	305
	306	<one line to give the program's name and a brief idea of what it does.>
	307	Copyright (C) <year> <name of author>
	308
	309	This program is free software; you can redistribute it and/or modify
	310	it under the terms of the GNU General Public License as published by
	311	the Free Software Foundation; either version 2 of the License, or
	312	(at your option) any later version.
	313
	314	This program is distributed in the hope that it will be useful,
	315	but WITHOUT ANY WARRANTY; without even the implied warranty of
	316	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	317	GNU General Public License for more details.
	318
	319	You should have received a copy of the GNU General Public License along
	320	with this program; if not, see <https://www.gnu.org/licenses/>.
	321
	322	Also add information on how to contact you by electronic and paper mail.
	323
	324	If the program is interactive, make it output a short notice like this
	325	when it starts in an interactive mode:
	326
	327	Gnomovision version 69, Copyright (C) year name of author
	328	Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
	329	This is free software, and you are welcome to redistribute it
	330	under certain conditions; type `show c' for details.
	331
	332	The hypothetical commands `show w' and `show c' should show the appropriate
	333	parts of the General Public License. Of course, the commands you use may
	334	be called something other than `show w' and `show c'; they could even be
	335	mouse-clicks or menu items--whatever suits your program.
	336
	337	You should also get your employer (if you work as a programmer) or your
	338	school, if any, to sign a "copyright disclaimer" for the program, if
	339	necessary. Here is a sample; alter the names:
	340
	341	Yoyodyne, Inc., hereby disclaims all copyright interest in the program
	342	`Gnomovision' (which makes passes at compilers) written by James Hacker.
	343
	344	<signature of Moe Ghoul>, 1 April 1989
	345	Moe Ghoul, President of Vice
	346
	347	This General Public License does not permit incorporating your program into
	348	proprietary programs. If your program is a subroutine library, you may
	349	consider it more useful to permit linking proprietary applications with the
	350	library. If this is what you want to do, use the GNU Lesser General
	351	Public License instead of this License.

licenses/LICENSE.dwl

0 created 644 +692 0

This diff has been collapsed as it changes many lines, (692 lines changed) Show them Hide them
	@@ -0,0 +1,692
		1	dwl - dwm for Wayland
		2
		3	Copyright © 2020 dwl team
		4
		5	See also the files LICENSE.tinywl, LICENSE.dwm and LICENSE.sway.
		6
		7	This program is free software: you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation, either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	----
		18
		19	GNU GENERAL PUBLIC LICENSE
		20	Version 3, 29 June 2007
		21
		22	Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
		23	Everyone is permitted to copy and distribute verbatim copies
		24	of this license document, but changing it is not allowed.
		25
		26	Preamble
		27
		28	The GNU General Public License is a free, copyleft license for
		29	software and other kinds of works.
		30
		31	The licenses for most software and other practical works are designed
		32	to take away your freedom to share and change the works. By contrast,
		33	the GNU General Public License is intended to guarantee your freedom to
		34	share and change all versions of a program--to make sure it remains free
		35	software for all its users. We, the Free Software Foundation, use the
		36	GNU General Public License for most of our software; it applies also to
		37	any other work released this way by its authors. You can apply it to
		38	your programs, too.
		39
		40	When we speak of free software, we are referring to freedom, not
		41	price. Our General Public Licenses are designed to make sure that you
		42	have the freedom to distribute copies of free software (and charge for
		43	them if you wish), that you receive source code or can get it if you
		44	want it, that you can change the software or use pieces of it in new
		45	free programs, and that you know you can do these things.
		46
		47	To protect your rights, we need to prevent others from denying you
		48	these rights or asking you to surrender the rights. Therefore, you have
		49	certain responsibilities if you distribute copies of the software, or if
		50	you modify it: responsibilities to respect the freedom of others.
		51
		52	For example, if you distribute copies of such a program, whether
		53	gratis or for a fee, you must pass on to the recipients the same
		54	freedoms that you received. You must make sure that they, too, receive
		55	or can get the source code. And you must show them these terms so they
		56	know their rights.
		57
		58	Developers that use the GNU GPL protect your rights with two steps:
		59	(1) assert copyright on the software, and (2) offer you this License
		60	giving you legal permission to copy, distribute and/or modify it.
		61
		62	For the developers' and authors' protection, the GPL clearly explains
		63	that there is no warranty for this free software. For both users' and
		64	authors' sake, the GPL requires that modified versions be marked as
		65	changed, so that their problems will not be attributed erroneously to
		66	authors of previous versions.
		67
		68	Some devices are designed to deny users access to install or run
		69	modified versions of the software inside them, although the manufacturer
		70	can do so. This is fundamentally incompatible with the aim of
		71	protecting users' freedom to change the software. The systematic
		72	pattern of such abuse occurs in the area of products for individuals to
		73	use, which is precisely where it is most unacceptable. Therefore, we
		74	have designed this version of the GPL to prohibit the practice for those
		75	products. If such problems arise substantially in other domains, we
		76	stand ready to extend this provision to those domains in future versions
		77	of the GPL, as needed to protect the freedom of users.
		78
		79	Finally, every program is threatened constantly by software patents.
		80	States should not allow patents to restrict development and use of
		81	software on general-purpose computers, but in those that do, we wish to
		82	avoid the special danger that patents applied to a free program could
		83	make it effectively proprietary. To prevent this, the GPL assures that
		84	patents cannot be used to render the program non-free.
		85
		86	The precise terms and conditions for copying, distribution and
		87	modification follow.
		88
		89	TERMS AND CONDITIONS
		90
		91	0. Definitions.
		92
		93	"This License" refers to version 3 of the GNU General Public License.
		94
		95	"Copyright" also means copyright-like laws that apply to other kinds of
		96	works, such as semiconductor masks.
		97
		98	"The Program" refers to any copyrightable work licensed under this
		99	License. Each licensee is addressed as "you". "Licensees" and
		100	"recipients" may be individuals or organizations.
		101
		102	To "modify" a work means to copy from or adapt all or part of the work
		103	in a fashion requiring copyright permission, other than the making of an
		104	exact copy. The resulting work is called a "modified version" of the
		105	earlier work or a work "based on" the earlier work.
		106
		107	A "covered work" means either the unmodified Program or a work based
		108	on the Program.
		109
		110	To "propagate" a work means to do anything with it that, without
		111	permission, would make you directly or secondarily liable for
		112	infringement under applicable copyright law, except executing it on a
		113	computer or modifying a private copy. Propagation includes copying,
		114	distribution (with or without modification), making available to the
		115	public, and in some countries other activities as well.
		116
		117	To "convey" a work means any kind of propagation that enables other
		118	parties to make or receive copies. Mere interaction with a user through
		119	a computer network, with no transfer of a copy, is not conveying.
		120
		121	An interactive user interface displays "Appropriate Legal Notices"
		122	to the extent that it includes a convenient and prominently visible
		123	feature that (1) displays an appropriate copyright notice, and (2)
		124	tells the user that there is no warranty for the work (except to the
		125	extent that warranties are provided), that licensees may convey the
		126	work under this License, and how to view a copy of this License. If
		127	the interface presents a list of user commands or options, such as a
		128	menu, a prominent item in the list meets this criterion.
		129
		130	1. Source Code.
		131
		132	The "source code" for a work means the preferred form of the work
		133	for making modifications to it. "Object code" means any non-source
		134	form of a work.
		135
		136	A "Standard Interface" means an interface that either is an official
		137	standard defined by a recognized standards body, or, in the case of
		138	interfaces specified for a particular programming language, one that
		139	is widely used among developers working in that language.
		140
		141	The "System Libraries" of an executable work include anything, other
		142	than the work as a whole, that (a) is included in the normal form of
		143	packaging a Major Component, but which is not part of that Major
		144	Component, and (b) serves only to enable use of the work with that
		145	Major Component, or to implement a Standard Interface for which an
		146	implementation is available to the public in source code form. A
		147	"Major Component", in this context, means a major essential component
		148	(kernel, window system, and so on) of the specific operating system
		149	(if any) on which the executable work runs, or a compiler used to
		150	produce the work, or an object code interpreter used to run it.
		151
		152	The "Corresponding Source" for a work in object code form means all
		153	the source code needed to generate, install, and (for an executable
		154	work) run the object code and to modify the work, including scripts to
		155	control those activities. However, it does not include the work's
		156	System Libraries, or general-purpose tools or generally available free
		157	programs which are used unmodified in performing those activities but
		158	which are not part of the work. For example, Corresponding Source
		159	includes interface definition files associated with source files for
		160	the work, and the source code for shared libraries and dynamically
		161	linked subprograms that the work is specifically designed to require,
		162	such as by intimate data communication or control flow between those
		163	subprograms and other parts of the work.
		164
		165	The Corresponding Source need not include anything that users
		166	can regenerate automatically from other parts of the Corresponding
		167	Source.
		168
		169	The Corresponding Source for a work in source code form is that
		170	same work.
		171
		172	2. Basic Permissions.
		173
		174	All rights granted under this License are granted for the term of
		175	copyright on the Program, and are irrevocable provided the stated
		176	conditions are met. This License explicitly affirms your unlimited
		177	permission to run the unmodified Program. The output from running a
		178	covered work is covered by this License only if the output, given its
		179	content, constitutes a covered work. This License acknowledges your
		180	rights of fair use or other equivalent, as provided by copyright law.
		181
		182	You may make, run and propagate covered works that you do not
		183	convey, without conditions so long as your license otherwise remains
		184	in force. You may convey covered works to others for the sole purpose
		185	of having them make modifications exclusively for you, or provide you
		186	with facilities for running those works, provided that you comply with
		187	the terms of this License in conveying all material for which you do
		188	not control copyright. Those thus making or running the covered works
		189	for you must do so exclusively on your behalf, under your direction
		190	and control, on terms that prohibit them from making any copies of
		191	your copyrighted material outside their relationship with you.
		192
		193	Conveying under any other circumstances is permitted solely under
		194	the conditions stated below. Sublicensing is not allowed; section 10
		195	makes it unnecessary.
		196
		197	3. Protecting Users' Legal Rights From Anti-Circumvention Law.
		198
		199	No covered work shall be deemed part of an effective technological
		200	measure under any applicable law fulfilling obligations under article
		201	11 of the WIPO copyright treaty adopted on 20 December 1996, or
		202	similar laws prohibiting or restricting circumvention of such
		203	measures.
		204
		205	When you convey a covered work, you waive any legal power to forbid
		206	circumvention of technological measures to the extent such circumvention
		207	is effected by exercising rights under this License with respect to
		208	the covered work, and you disclaim any intention to limit operation or
		209	modification of the work as a means of enforcing, against the work's
		210	users, your or third parties' legal rights to forbid circumvention of
		211	technological measures.
		212
		213	4. Conveying Verbatim Copies.
		214
		215	You may convey verbatim copies of the Program's source code as you
		216	receive it, in any medium, provided that you conspicuously and
		217	appropriately publish on each copy an appropriate copyright notice;
		218	keep intact all notices stating that this License and any
		219	non-permissive terms added in accord with section 7 apply to the code;
		220	keep intact all notices of the absence of any warranty; and give all
		221	recipients a copy of this License along with the Program.
		222
		223	You may charge any price or no price for each copy that you convey,
		224	and you may offer support or warranty protection for a fee.
		225
		226	5. Conveying Modified Source Versions.
		227
		228	You may convey a work based on the Program, or the modifications to
		229	produce it from the Program, in the form of source code under the
		230	terms of section 4, provided that you also meet all of these conditions:
		231
		232	a) The work must carry prominent notices stating that you modified
		233	it, and giving a relevant date.
		234
		235	b) The work must carry prominent notices stating that it is
		236	released under this License and any conditions added under section
		237	7. This requirement modifies the requirement in section 4 to
		238	"keep intact all notices".
		239
		240	c) You must license the entire work, as a whole, under this
		241	License to anyone who comes into possession of a copy. This
		242	License will therefore apply, along with any applicable section 7
		243	additional terms, to the whole of the work, and all its parts,
		244	regardless of how they are packaged. This License gives no
		245	permission to license the work in any other way, but it does not
		246	invalidate such permission if you have separately received it.
		247
		248	d) If the work has interactive user interfaces, each must display
		249	Appropriate Legal Notices; however, if the Program has interactive
		250	interfaces that do not display Appropriate Legal Notices, your
		251	work need not make them do so.
		252
		253	A compilation of a covered work with other separate and independent
		254	works, which are not by their nature extensions of the covered work,
		255	and which are not combined with it such as to form a larger program,
		256	in or on a volume of a storage or distribution medium, is called an
		257	"aggregate" if the compilation and its resulting copyright are not
		258	used to limit the access or legal rights of the compilation's users
		259	beyond what the individual works permit. Inclusion of a covered work
		260	in an aggregate does not cause this License to apply to the other
		261	parts of the aggregate.
		262
		263	6. Conveying Non-Source Forms.
		264
		265	You may convey a covered work in object code form under the terms
		266	of sections 4 and 5, provided that you also convey the
		267	machine-readable Corresponding Source under the terms of this License,
		268	in one of these ways:
		269
		270	a) Convey the object code in, or embodied in, a physical product
		271	(including a physical distribution medium), accompanied by the
		272	Corresponding Source fixed on a durable physical medium
		273	customarily used for software interchange.
		274
		275	b) Convey the object code in, or embodied in, a physical product
		276	(including a physical distribution medium), accompanied by a
		277	written offer, valid for at least three years and valid for as
		278	long as you offer spare parts or customer support for that product
		279	model, to give anyone who possesses the object code either (1) a
		280	copy of the Corresponding Source for all the software in the
		281	product that is covered by this License, on a durable physical
		282	medium customarily used for software interchange, for a price no
		283	more than your reasonable cost of physically performing this
		284	conveying of source, or (2) access to copy the
		285	Corresponding Source from a network server at no charge.
		286
		287	c) Convey individual copies of the object code with a copy of the
		288	written offer to provide the Corresponding Source. This
		289	alternative is allowed only occasionally and noncommercially, and
		290	only if you received the object code with such an offer, in accord
		291	with subsection 6b.
		292
		293	d) Convey the object code by offering access from a designated
		294	place (gratis or for a charge), and offer equivalent access to the
		295	Corresponding Source in the same way through the same place at no
		296	further charge. You need not require recipients to copy the
		297	Corresponding Source along with the object code. If the place to
		298	copy the object code is a network server, the Corresponding Source
		299	may be on a different server (operated by you or a third party)
		300	that supports equivalent copying facilities, provided you maintain
		301	clear directions next to the object code saying where to find the
		302	Corresponding Source. Regardless of what server hosts the
		303	Corresponding Source, you remain obligated to ensure that it is
		304	available for as long as needed to satisfy these requirements.
		305
		306	e) Convey the object code using peer-to-peer transmission, provided
		307	you inform other peers where the object code and Corresponding
		308	Source of the work are being offered to the general public at no
		309	charge under subsection 6d.
		310
		311	A separable portion of the object code, whose source code is excluded
		312	from the Corresponding Source as a System Library, need not be
		313	included in conveying the object code work.
		314
		315	A "User Product" is either (1) a "consumer product", which means any
		316	tangible personal property which is normally used for personal, family,
		317	or household purposes, or (2) anything designed or sold for incorporation
		318	into a dwelling. In determining whether a product is a consumer product,
		319	doubtful cases shall be resolved in favor of coverage. For a particular
		320	product received by a particular user, "normally used" refers to a
		321	typical or common use of that class of product, regardless of the status
		322	of the particular user or of the way in which the particular user
		323	actually uses, or expects or is expected to use, the product. A product
		324	is a consumer product regardless of whether the product has substantial
		325	commercial, industrial or non-consumer uses, unless such uses represent
		326	the only significant mode of use of the product.
		327
		328	"Installation Information" for a User Product means any methods,
		329	procedures, authorization keys, or other information required to install
		330	and execute modified versions of a covered work in that User Product from
		331	a modified version of its Corresponding Source. The information must
		332	suffice to ensure that the continued functioning of the modified object
		333	code is in no case prevented or interfered with solely because
		334	modification has been made.
		335
		336	If you convey an object code work under this section in, or with, or
		337	specifically for use in, a User Product, and the conveying occurs as
		338	part of a transaction in which the right of possession and use of the
		339	User Product is transferred to the recipient in perpetuity or for a
		340	fixed term (regardless of how the transaction is characterized), the
		341	Corresponding Source conveyed under this section must be accompanied
		342	by the Installation Information. But this requirement does not apply
		343	if neither you nor any third party retains the ability to install
		344	modified object code on the User Product (for example, the work has
		345	been installed in ROM).
		346
		347	The requirement to provide Installation Information does not include a
		348	requirement to continue to provide support service, warranty, or updates
		349	for a work that has been modified or installed by the recipient, or for
		350	the User Product in which it has been modified or installed. Access to a
		351	network may be denied when the modification itself materially and
		352	adversely affects the operation of the network or violates the rules and
		353	protocols for communication across the network.
		354
		355	Corresponding Source conveyed, and Installation Information provided,
		356	in accord with this section must be in a format that is publicly
		357	documented (and with an implementation available to the public in
		358	source code form), and must require no special password or key for
		359	unpacking, reading or copying.
		360
		361	7. Additional Terms.
		362
		363	"Additional permissions" are terms that supplement the terms of this
		364	License by making exceptions from one or more of its conditions.
		365	Additional permissions that are applicable to the entire Program shall
		366	be treated as though they were included in this License, to the extent
		367	that they are valid under applicable law. If additional permissions
		368	apply only to part of the Program, that part may be used separately
		369	under those permissions, but the entire Program remains governed by
		370	this License without regard to the additional permissions.
		371
		372	When you convey a copy of a covered work, you may at your option
		373	remove any additional permissions from that copy, or from any part of
		374	it. (Additional permissions may be written to require their own
		375	removal in certain cases when you modify the work.) You may place
		376	additional permissions on material, added by you to a covered work,
		377	for which you have or can give appropriate copyright permission.
		378
		379	Notwithstanding any other provision of this License, for material you
		380	add to a covered work, you may (if authorized by the copyright holders of
		381	that material) supplement the terms of this License with terms:
		382
		383	a) Disclaiming warranty or limiting liability differently from the
		384	terms of sections 15 and 16 of this License; or
		385
		386	b) Requiring preservation of specified reasonable legal notices or
		387	author attributions in that material or in the Appropriate Legal
		388	Notices displayed by works containing it; or
		389
		390	c) Prohibiting misrepresentation of the origin of that material, or
		391	requiring that modified versions of such material be marked in
		392	reasonable ways as different from the original version; or
		393
		394	d) Limiting the use for publicity purposes of names of licensors or
		395	authors of the material; or
		396
		397	e) Declining to grant rights under trademark law for use of some
		398	trade names, trademarks, or service marks; or
		399
		400	f) Requiring indemnification of licensors and authors of that
		401	material by anyone who conveys the material (or modified versions of
		402	it) with contractual assumptions of liability to the recipient, for
		403	any liability that these contractual assumptions directly impose on
		404	those licensors and authors.
		405
		406	All other non-permissive additional terms are considered "further
		407	restrictions" within the meaning of section 10. If the Program as you
		408	received it, or any part of it, contains a notice stating that it is
		409	governed by this License along with a term that is a further
		410	restriction, you may remove that term. If a license document contains
		411	a further restriction but permits relicensing or conveying under this
		412	License, you may add to a covered work material governed by the terms
		413	of that license document, provided that the further restriction does
		414	not survive such relicensing or conveying.
		415
		416	If you add terms to a covered work in accord with this section, you
		417	must place, in the relevant source files, a statement of the
		418	additional terms that apply to those files, or a notice indicating
		419	where to find the applicable terms.
		420
		421	Additional terms, permissive or non-permissive, may be stated in the
		422	form of a separately written license, or stated as exceptions;
		423	the above requirements apply either way.
		424
		425	8. Termination.
		426
		427	You may not propagate or modify a covered work except as expressly
		428	provided under this License. Any attempt otherwise to propagate or
		429	modify it is void, and will automatically terminate your rights under
		430	this License (including any patent licenses granted under the third
		431	paragraph of section 11).
		432
		433	However, if you cease all violation of this License, then your
		434	license from a particular copyright holder is reinstated (a)
		435	provisionally, unless and until the copyright holder explicitly and
		436	finally terminates your license, and (b) permanently, if the copyright
		437	holder fails to notify you of the violation by some reasonable means
		438	prior to 60 days after the cessation.
		439
		440	Moreover, your license from a particular copyright holder is
		441	reinstated permanently if the copyright holder notifies you of the
		442	violation by some reasonable means, this is the first time you have
		443	received notice of violation of this License (for any work) from that
		444	copyright holder, and you cure the violation prior to 30 days after
		445	your receipt of the notice.
		446
		447	Termination of your rights under this section does not terminate the
		448	licenses of parties who have received copies or rights from you under
		449	this License. If your rights have been terminated and not permanently
		450	reinstated, you do not qualify to receive new licenses for the same
		451	material under section 10.
		452
		453	9. Acceptance Not Required for Having Copies.
		454
		455	You are not required to accept this License in order to receive or
		456	run a copy of the Program. Ancillary propagation of a covered work
		457	occurring solely as a consequence of using peer-to-peer transmission
		458	to receive a copy likewise does not require acceptance. However,
		459	nothing other than this License grants you permission to propagate or
		460	modify any covered work. These actions infringe copyright if you do
		461	not accept this License. Therefore, by modifying or propagating a
		462	covered work, you indicate your acceptance of this License to do so.
		463
		464	10. Automatic Licensing of Downstream Recipients.
		465
		466	Each time you convey a covered work, the recipient automatically
		467	receives a license from the original licensors, to run, modify and
		468	propagate that work, subject to this License. You are not responsible
		469	for enforcing compliance by third parties with this License.
		470
		471	An "entity transaction" is a transaction transferring control of an
		472	organization, or substantially all assets of one, or subdividing an
		473	organization, or merging organizations. If propagation of a covered
		474	work results from an entity transaction, each party to that
		475	transaction who receives a copy of the work also receives whatever
		476	licenses to the work the party's predecessor in interest had or could
		477	give under the previous paragraph, plus a right to possession of the
		478	Corresponding Source of the work from the predecessor in interest, if
		479	the predecessor has it or can get it with reasonable efforts.
		480
		481	You may not impose any further restrictions on the exercise of the
		482	rights granted or affirmed under this License. For example, you may
		483	not impose a license fee, royalty, or other charge for exercise of
		484	rights granted under this License, and you may not initiate litigation
		485	(including a cross-claim or counterclaim in a lawsuit) alleging that
		486	any patent claim is infringed by making, using, selling, offering for
		487	sale, or importing the Program or any portion of it.
		488
		489	11. Patents.
		490
		491	A "contributor" is a copyright holder who authorizes use under this
		492	License of the Program or a work on which the Program is based. The
		493	work thus licensed is called the contributor's "contributor version".
		494
		495	A contributor's "essential patent claims" are all patent claims
		496	owned or controlled by the contributor, whether already acquired or
		497	hereafter acquired, that would be infringed by some manner, permitted
		498	by this License, of making, using, or selling its contributor version,
		499	but do not include claims that would be infringed only as a
		500	consequence of further modification of the contributor version. For
		501	purposes of this definition, "control" includes the right to grant
		502	patent sublicenses in a manner consistent with the requirements of
		503	this License.
		504
		505	Each contributor grants you a non-exclusive, worldwide, royalty-free
		506	patent license under the contributor's essential patent claims, to
		507	make, use, sell, offer for sale, import and otherwise run, modify and
		508	propagate the contents of its contributor version.
		509
		510	In the following three paragraphs, a "patent license" is any express
		511	agreement or commitment, however denominated, not to enforce a patent
		512	(such as an express permission to practice a patent or covenant not to
		513	sue for patent infringement). To "grant" such a patent license to a
		514	party means to make such an agreement or commitment not to enforce a
		515	patent against the party.
		516
		517	If you convey a covered work, knowingly relying on a patent license,
		518	and the Corresponding Source of the work is not available for anyone
		519	to copy, free of charge and under the terms of this License, through a
		520	publicly available network server or other readily accessible means,
		521	then you must either (1) cause the Corresponding Source to be so
		522	available, or (2) arrange to deprive yourself of the benefit of the
		523	patent license for this particular work, or (3) arrange, in a manner
		524	consistent with the requirements of this License, to extend the patent
		525	license to downstream recipients. "Knowingly relying" means you have
		526	actual knowledge that, but for the patent license, your conveying the
		527	covered work in a country, or your recipient's use of the covered work
		528	in a country, would infringe one or more identifiable patents in that
		529	country that you have reason to believe are valid.
		530
		531	If, pursuant to or in connection with a single transaction or
		532	arrangement, you convey, or propagate by procuring conveyance of, a
		533	covered work, and grant a patent license to some of the parties
		534	receiving the covered work authorizing them to use, propagate, modify
		535	or convey a specific copy of the covered work, then the patent license
		536	you grant is automatically extended to all recipients of the covered
		537	work and works based on it.
		538
		539	A patent license is "discriminatory" if it does not include within
		540	the scope of its coverage, prohibits the exercise of, or is
		541	conditioned on the non-exercise of one or more of the rights that are
		542	specifically granted under this License. You may not convey a covered
		543	work if you are a party to an arrangement with a third party that is
		544	in the business of distributing software, under which you make payment
		545	to the third party based on the extent of your activity of conveying
		546	the work, and under which the third party grants, to any of the
		547	parties who would receive the covered work from you, a discriminatory
		548	patent license (a) in connection with copies of the covered work
		549	conveyed by you (or copies made from those copies), or (b) primarily
		550	for and in connection with specific products or compilations that
		551	contain the covered work, unless you entered into that arrangement,
		552	or that patent license was granted, prior to 28 March 2007.
		553
		554	Nothing in this License shall be construed as excluding or limiting
		555	any implied license or other defenses to infringement that may
		556	otherwise be available to you under applicable patent law.
		557
		558	12. No Surrender of Others' Freedom.
		559
		560	If conditions are imposed on you (whether by court order, agreement or
		561	otherwise) that contradict the conditions of this License, they do not
		562	excuse you from the conditions of this License. If you cannot convey a
		563	covered work so as to satisfy simultaneously your obligations under this
		564	License and any other pertinent obligations, then as a consequence you may
		565	not convey it at all. For example, if you agree to terms that obligate you
		566	to collect a royalty for further conveying from those to whom you convey
		567	the Program, the only way you could satisfy both those terms and this
		568	License would be to refrain entirely from conveying the Program.
		569
		570	13. Use with the GNU Affero General Public License.
		571
		572	Notwithstanding any other provision of this License, you have
		573	permission to link or combine any covered work with a work licensed
		574	under version 3 of the GNU Affero General Public License into a single
		575	combined work, and to convey the resulting work. The terms of this
		576	License will continue to apply to the part which is the covered work,
		577	but the special requirements of the GNU Affero General Public License,
		578	section 13, concerning interaction through a network will apply to the
		579	combination as such.
		580
		581	14. Revised Versions of this License.
		582
		583	The Free Software Foundation may publish revised and/or new versions of
		584	the GNU General Public License from time to time. Such new versions will
		585	be similar in spirit to the present version, but may differ in detail to
		586	address new problems or concerns.
		587
		588	Each version is given a distinguishing version number. If the
		589	Program specifies that a certain numbered version of the GNU General
		590	Public License "or any later version" applies to it, you have the
		591	option of following the terms and conditions either of that numbered
		592	version or of any later version published by the Free Software
		593	Foundation. If the Program does not specify a version number of the
		594	GNU General Public License, you may choose any version ever published
		595	by the Free Software Foundation.
		596
		597	If the Program specifies that a proxy can decide which future
		598	versions of the GNU General Public License can be used, that proxy's
		599	public statement of acceptance of a version permanently authorizes you
		600	to choose that version for the Program.
		601
		602	Later license versions may give you additional or different
		603	permissions. However, no additional obligations are imposed on any
		604	author or copyright holder as a result of your choosing to follow a
		605	later version.
		606
		607	15. Disclaimer of Warranty.
		608
		609	THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
		610	APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
		611	HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
		612	OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
		613	THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		614	PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
		615	IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
		616	ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
		617
		618	16. Limitation of Liability.
		619
		620	IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
		621	WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
		622	THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
		623	GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
		624	USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
		625	DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
		626	PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
		627	EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
		628	SUCH DAMAGES.
		629
		630	17. Interpretation of Sections 15 and 16.
		631
		632	If the disclaimer of warranty and limitation of liability provided
		633	above cannot be given local legal effect according to their terms,
		634	reviewing courts shall apply local law that most closely approximates
		635	an absolute waiver of all civil liability in connection with the
		636	Program, unless a warranty or assumption of liability accompanies a
		637	copy of the Program in return for a fee.
		638
		639	END OF TERMS AND CONDITIONS
		640
		641	How to Apply These Terms to Your New Programs
		642
		643	If you develop a new program, and you want it to be of the greatest
		644	possible use to the public, the best way to achieve this is to make it
		645	free software which everyone can redistribute and change under these terms.
		646
		647	To do so, attach the following notices to the program. It is safest
		648	to attach them to the start of each source file to most effectively
		649	state the exclusion of warranty; and each file should have at least
		650	the "copyright" line and a pointer to where the full notice is found.
		651
		652	<one line to give the program's name and a brief idea of what it does.>
		653	Copyright (C) <year> <name of author>
		654
		655	This program is free software: you can redistribute it and/or modify
		656	it under the terms of the GNU General Public License as published by
		657	the Free Software Foundation, either version 3 of the License, or
		658	(at your option) any later version.
		659
		660	This program is distributed in the hope that it will be useful,
		661	but WITHOUT ANY WARRANTY; without even the implied warranty of
		662	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		663	GNU General Public License for more details.
		664
		665	You should have received a copy of the GNU General Public License
		666	along with this program. If not, see <https://www.gnu.org/licenses/>.
		667
		668	Also add information on how to contact you by electronic and paper mail.
		669
		670	If the program does terminal interaction, make it output a short
		671	notice like this when it starts in an interactive mode:
		672
		673	<program> Copyright (C) <year> <name of author>
		674	This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
		675	This is free software, and you are welcome to redistribute it
		676	under certain conditions; type `show c' for details.
		677
		678	The hypothetical commands `show w' and `show c' should show the appropriate
		679	parts of the General Public License. Of course, your program's commands
		680	might be different; for a GUI interface, you would use an "about box".
		681
		682	You should also get your employer (if you work as a programmer) or school,
		683	if any, to sign a "copyright disclaimer" for the program, if necessary.
		684	For more information on this, and how to apply and follow the GNU GPL, see
		685	<https://www.gnu.org/licenses/>.
		686
		687	The GNU General Public License does not permit incorporating your program
		688	into proprietary programs. If your program is a subroutine library, you
		689	may consider it more useful to permit linking proprietary applications with
		690	the library. If this is what you want to do, use the GNU Lesser General
		691	Public License instead of this License. But first, please read
		692	<https://www.gnu.org/licenses/why-not-lgpl.html>.

licenses/LICENSE.dwlmsg

0 created 644 +12 0

@@ -0,0 +1,12
	1	Copyright (C) 2025 by notchoc <[email protected]>
	2
	3	Permission to use, copy, modify, and/or distribute this software for any
	4	purpose with or without fee is hereby granted.
	5
	6	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	7	WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	8	MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	9	ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	10	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	11	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	12	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

licenses/LICENSE.dwm

0 created 644 +39 0

@@ -0,0 +1,39
	1	Portions of dwl based on dwm code are used under the following license:
	2
	3	MIT/X Consortium License
	4
	5	© 2006-2019 Anselm R Garbe <[email protected]>
	6	© 2006-2009 Jukka Salmi <jukka at salmi dot ch>
	7	© 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
	8	© 2007-2011 Peter Hartlich <sgkkr at hartlich dot com>
	9	© 2007-2009 Szabolcs Nagy <nszabolcs at gmail dot com>
	10	© 2007-2009 Christof Musik <christof at sendfax dot de>
	11	© 2007-2009 Premysl Hruby <dfenze at gmail dot com>
	12	© 2007-2008 Enno Gottox Boland <gottox at s01 dot de>
	13	© 2008 Martin Hurton <martin dot hurton at gmail dot com>
	14	© 2008 Neale Pickett <neale dot woozle dot org>
	15	© 2009 Mate Nagy <mnagy at port70 dot net>
	16	© 2010-2016 Hiltjo Posthuma <[email protected]>
	17	© 2010-2012 Connor Lane Smith <[email protected]>
	18	© 2011 Christoph Lohmann <[email protected]>
	19	© 2015-2016 Quentin Rameau <[email protected]>
	20	© 2015-2016 Eric Pruitt <[email protected]>
	21	© 2016-2017 Markus Teich <[email protected]>
	22
	23	Permission is hereby granted, free of charge, to any person obtaining a
	24	copy of this software and associated documentation files (the "Software"),
	25	to deal in the Software without restriction, including without limitation
	26	the rights to use, copy, modify, merge, publish, distribute, sublicense,
	27	and/or sell copies of the Software, and to permit persons to whom the
	28	Software is furnished to do so, subject to the following conditions:
	29
	30	The above copyright notice and this permission notice shall be included in
	31	all copies or substantial portions of the Software.
	32
	33	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	34	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	35	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	36	THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	37	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	38	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	39	DEALINGS IN THE SOFTWARE.

licenses/LICENSE.mangowm

0 created 644 +692 0

This diff has been collapsed as it changes many lines, (692 lines changed) Show them Hide them
	@@ -0,0 +1,692
		1	mango - wayland compositor base wlroots
		2
		3	Copyright © 2025 DreamMaoMao
		4
		5	See also the files LICENSE.dwl, LICENSE.tinywl, LICENSE.dwm and LICENSE.sway.
		6
		7	This program is free software: you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation, either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	----
		18
		19	GNU GENERAL PUBLIC LICENSE
		20	Version 3, 29 June 2007
		21
		22	Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
		23	Everyone is permitted to copy and distribute verbatim copies
		24	of this license document, but changing it is not allowed.
		25
		26	Preamble
		27
		28	The GNU General Public License is a free, copyleft license for
		29	software and other kinds of works.
		30
		31	The licenses for most software and other practical works are designed
		32	to take away your freedom to share and change the works. By contrast,
		33	the GNU General Public License is intended to guarantee your freedom to
		34	share and change all versions of a program--to make sure it remains free
		35	software for all its users. We, the Free Software Foundation, use the
		36	GNU General Public License for most of our software; it applies also to
		37	any other work released this way by its authors. You can apply it to
		38	your programs, too.
		39
		40	When we speak of free software, we are referring to freedom, not
		41	price. Our General Public Licenses are designed to make sure that you
		42	have the freedom to distribute copies of free software (and charge for
		43	them if you wish), that you receive source code or can get it if you
		44	want it, that you can change the software or use pieces of it in new
		45	free programs, and that you know you can do these things.
		46
		47	To protect your rights, we need to prevent others from denying you
		48	these rights or asking you to surrender the rights. Therefore, you have
		49	certain responsibilities if you distribute copies of the software, or if
		50	you modify it: responsibilities to respect the freedom of others.
		51
		52	For example, if you distribute copies of such a program, whether
		53	gratis or for a fee, you must pass on to the recipients the same
		54	freedoms that you received. You must make sure that they, too, receive
		55	or can get the source code. And you must show them these terms so they
		56	know their rights.
		57
		58	Developers that use the GNU GPL protect your rights with two steps:
		59	(1) assert copyright on the software, and (2) offer you this License
		60	giving you legal permission to copy, distribute and/or modify it.
		61
		62	For the developers' and authors' protection, the GPL clearly explains
		63	that there is no warranty for this free software. For both users' and
		64	authors' sake, the GPL requires that modified versions be marked as
		65	changed, so that their problems will not be attributed erroneously to
		66	authors of previous versions.
		67
		68	Some devices are designed to deny users access to install or run
		69	modified versions of the software inside them, although the manufacturer
		70	can do so. This is fundamentally incompatible with the aim of
		71	protecting users' freedom to change the software. The systematic
		72	pattern of such abuse occurs in the area of products for individuals to
		73	use, which is precisely where it is most unacceptable. Therefore, we
		74	have designed this version of the GPL to prohibit the practice for those
		75	products. If such problems arise substantially in other domains, we
		76	stand ready to extend this provision to those domains in future versions
		77	of the GPL, as needed to protect the freedom of users.
		78
		79	Finally, every program is threatened constantly by software patents.
		80	States should not allow patents to restrict development and use of
		81	software on general-purpose computers, but in those that do, we wish to
		82	avoid the special danger that patents applied to a free program could
		83	make it effectively proprietary. To prevent this, the GPL assures that
		84	patents cannot be used to render the program non-free.
		85
		86	The precise terms and conditions for copying, distribution and
		87	modification follow.
		88
		89	TERMS AND CONDITIONS
		90
		91	1. Definitions.
		92
		93	"This License" refers to version 3 of the GNU General Public License.
		94
		95	"Copyright" also means copyright-like laws that apply to other kinds of
		96	works, such as semiconductor masks.
		97
		98	"The Program" refers to any copyrightable work licensed under this
		99	License. Each licensee is addressed as "you". "Licensees" and
		100	"recipients" may be individuals or organizations.
		101
		102	To "modify" a work means to copy from or adapt all or part of the work
		103	in a fashion requiring copyright permission, other than the making of an
		104	exact copy. The resulting work is called a "modified version" of the
		105	earlier work or a work "based on" the earlier work.
		106
		107	A "covered work" means either the unmodified Program or a work based
		108	on the Program.
		109
		110	To "propagate" a work means to do anything with it that, without
		111	permission, would make you directly or secondarily liable for
		112	infringement under applicable copyright law, except executing it on a
		113	computer or modifying a private copy. Propagation includes copying,
		114	distribution (with or without modification), making available to the
		115	public, and in some countries other activities as well.
		116
		117	To "convey" a work means any kind of propagation that enables other
		118	parties to make or receive copies. Mere interaction with a user through
		119	a computer network, with no transfer of a copy, is not conveying.
		120
		121	An interactive user interface displays "Appropriate Legal Notices"
		122	to the extent that it includes a convenient and prominently visible
		123	feature that (1) displays an appropriate copyright notice, and (2)
		124	tells the user that there is no warranty for the work (except to the
		125	extent that warranties are provided), that licensees may convey the
		126	work under this License, and how to view a copy of this License. If
		127	the interface presents a list of user commands or options, such as a
		128	menu, a prominent item in the list meets this criterion.
		129
		130	1. Source Code.
		131
		132	The "source code" for a work means the preferred form of the work
		133	for making modifications to it. "Object code" means any non-source
		134	form of a work.
		135
		136	A "Standard Interface" means an interface that either is an official
		137	standard defined by a recognized standards body, or, in the case of
		138	interfaces specified for a particular programming language, one that
		139	is widely used among developers working in that language.
		140
		141	The "System Libraries" of an executable work include anything, other
		142	than the work as a whole, that (a) is included in the normal form of
		143	packaging a Major Component, but which is not part of that Major
		144	Component, and (b) serves only to enable use of the work with that
		145	Major Component, or to implement a Standard Interface for which an
		146	implementation is available to the public in source code form. A
		147	"Major Component", in this context, means a major essential component
		148	(kernel, window system, and so on) of the specific operating system
		149	(if any) on which the executable work runs, or a compiler used to
		150	produce the work, or an object code interpreter used to run it.
		151
		152	The "Corresponding Source" for a work in object code form means all
		153	the source code needed to generate, install, and (for an executable
		154	work) run the object code and to modify the work, including scripts to
		155	control those activities. However, it does not include the work's
		156	System Libraries, or general-purpose tools or generally available free
		157	programs which are used unmodified in performing those activities but
		158	which are not part of the work. For example, Corresponding Source
		159	includes interface definition files associated with source files for
		160	the work, and the source code for shared libraries and dynamically
		161	linked subprograms that the work is specifically designed to require,
		162	such as by intimate data communication or control flow between those
		163	subprograms and other parts of the work.
		164
		165	The Corresponding Source need not include anything that users
		166	can regenerate automatically from other parts of the Corresponding
		167	Source.
		168
		169	The Corresponding Source for a work in source code form is that
		170	same work.
		171
		172	2. Basic Permissions.
		173
		174	All rights granted under this License are granted for the term of
		175	copyright on the Program, and are irrevocable provided the stated
		176	conditions are met. This License explicitly affirms your unlimited
		177	permission to run the unmodified Program. The output from running a
		178	covered work is covered by this License only if the output, given its
		179	content, constitutes a covered work. This License acknowledges your
		180	rights of fair use or other equivalent, as provided by copyright law.
		181
		182	You may make, run and propagate covered works that you do not
		183	convey, without conditions so long as your license otherwise remains
		184	in force. You may convey covered works to others for the sole purpose
		185	of having them make modifications exclusively for you, or provide you
		186	with facilities for running those works, provided that you comply with
		187	the terms of this License in conveying all material for which you do
		188	not control copyright. Those thus making or running the covered works
		189	for you must do so exclusively on your behalf, under your direction
		190	and control, on terms that prohibit them from making any copies of
		191	your copyrighted material outside their relationship with you.
		192
		193	Conveying under any other circumstances is permitted solely under
		194	the conditions stated below. Sublicensing is not allowed; section 10
		195	makes it unnecessary.
		196
		197	3. Protecting Users' Legal Rights From Anti-Circumvention Law.
		198
		199	No covered work shall be deemed part of an effective technological
		200	measure under any applicable law fulfilling obligations under article
		201	11 of the WIPO copyright treaty adopted on 20 December 1996, or
		202	similar laws prohibiting or restricting circumvention of such
		203	measures.
		204
		205	When you convey a covered work, you waive any legal power to forbid
		206	circumvention of technological measures to the extent such circumvention
		207	is effected by exercising rights under this License with respect to
		208	the covered work, and you disclaim any intention to limit operation or
		209	modification of the work as a means of enforcing, against the work's
		210	users, your or third parties' legal rights to forbid circumvention of
		211	technological measures.
		212
		213	4. Conveying Verbatim Copies.
		214
		215	You may convey verbatim copies of the Program's source code as you
		216	receive it, in any medium, provided that you conspicuously and
		217	appropriately publish on each copy an appropriate copyright notice;
		218	keep intact all notices stating that this License and any
		219	non-permissive terms added in accord with section 7 apply to the code;
		220	keep intact all notices of the absence of any warranty; and give all
		221	recipients a copy of this License along with the Program.
		222
		223	You may charge any price or no price for each copy that you convey,
		224	and you may offer support or warranty protection for a fee.
		225
		226	5. Conveying Modified Source Versions.
		227
		228	You may convey a work based on the Program, or the modifications to
		229	produce it from the Program, in the form of source code under the
		230	terms of section 4, provided that you also meet all of these conditions:
		231
		232	a) The work must carry prominent notices stating that you modified
		233	it, and giving a relevant date.
		234
		235	b) The work must carry prominent notices stating that it is
		236	released under this License and any conditions added under section
		237	7. This requirement modifies the requirement in section 4 to
		238	"keep intact all notices".
		239
		240	c) You must license the entire work, as a whole, under this
		241	License to anyone who comes into possession of a copy. This
		242	License will therefore apply, along with any applicable section 7
		243	additional terms, to the whole of the work, and all its parts,
		244	regardless of how they are packaged. This License gives no
		245	permission to license the work in any other way, but it does not
		246	invalidate such permission if you have separately received it.
		247
		248	d) If the work has interactive user interfaces, each must display
		249	Appropriate Legal Notices; however, if the Program has interactive
		250	interfaces that do not display Appropriate Legal Notices, your
		251	work need not make them do so.
		252
		253	A compilation of a covered work with other separate and independent
		254	works, which are not by their nature extensions of the covered work,
		255	and which are not combined with it such as to form a larger program,
		256	in or on a volume of a storage or distribution medium, is called an
		257	"aggregate" if the compilation and its resulting copyright are not
		258	used to limit the access or legal rights of the compilation's users
		259	beyond what the individual works permit. Inclusion of a covered work
		260	in an aggregate does not cause this License to apply to the other
		261	parts of the aggregate.
		262
		263	6. Conveying Non-Source Forms.
		264
		265	You may convey a covered work in object code form under the terms
		266	of sections 4 and 5, provided that you also convey the
		267	machine-readable Corresponding Source under the terms of this License,
		268	in one of these ways:
		269
		270	a) Convey the object code in, or embodied in, a physical product
		271	(including a physical distribution medium), accompanied by the
		272	Corresponding Source fixed on a durable physical medium
		273	customarily used for software interchange.
		274
		275	b) Convey the object code in, or embodied in, a physical product
		276	(including a physical distribution medium), accompanied by a
		277	written offer, valid for at least three years and valid for as
		278	long as you offer spare parts or customer support for that product
		279	model, to give anyone who possesses the object code either (1) a
		280	copy of the Corresponding Source for all the software in the
		281	product that is covered by this License, on a durable physical
		282	medium customarily used for software interchange, for a price no
		283	more than your reasonable cost of physically performing this
		284	conveying of source, or (2) access to copy the
		285	Corresponding Source from a network server at no charge.
		286
		287	c) Convey individual copies of the object code with a copy of the
		288	written offer to provide the Corresponding Source. This
		289	alternative is allowed only occasionally and noncommercially, and
		290	only if you received the object code with such an offer, in accord
		291	with subsection 6b.
		292
		293	d) Convey the object code by offering access from a designated
		294	place (gratis or for a charge), and offer equivalent access to the
		295	Corresponding Source in the same way through the same place at no
		296	further charge. You need not require recipients to copy the
		297	Corresponding Source along with the object code. If the place to
		298	copy the object code is a network server, the Corresponding Source
		299	may be on a different server (operated by you or a third party)
		300	that supports equivalent copying facilities, provided you maintain
		301	clear directions next to the object code saying where to find the
		302	Corresponding Source. Regardless of what server hosts the
		303	Corresponding Source, you remain obligated to ensure that it is
		304	available for as long as needed to satisfy these requirements.
		305
		306	e) Convey the object code using peer-to-peer transmission, provided
		307	you inform other peers where the object code and Corresponding
		308	Source of the work are being offered to the general public at no
		309	charge under subsection 6d.
		310
		311	A separable portion of the object code, whose source code is excluded
		312	from the Corresponding Source as a System Library, need not be
		313	included in conveying the object code work.
		314
		315	A "User Product" is either (1) a "consumer product", which means any
		316	tangible personal property which is normally used for personal, family,
		317	or household purposes, or (2) anything designed or sold for incorporation
		318	into a dwelling. In determining whether a product is a consumer product,
		319	doubtful cases shall be resolved in favor of coverage. For a particular
		320	product received by a particular user, "normally used" refers to a
		321	typical or common use of that class of product, regardless of the status
		322	of the particular user or of the way in which the particular user
		323	actually uses, or expects or is expected to use, the product. A product
		324	is a consumer product regardless of whether the product has substantial
		325	commercial, industrial or non-consumer uses, unless such uses represent
		326	the only significant mode of use of the product.
		327
		328	"Installation Information" for a User Product means any methods,
		329	procedures, authorization keys, or other information required to install
		330	and execute modified versions of a covered work in that User Product from
		331	a modified version of its Corresponding Source. The information must
		332	suffice to ensure that the continued functioning of the modified object
		333	code is in no case prevented or interfered with solely because
		334	modification has been made.
		335
		336	If you convey an object code work under this section in, or with, or
		337	specifically for use in, a User Product, and the conveying occurs as
		338	part of a transaction in which the right of possession and use of the
		339	User Product is transferred to the recipient in perpetuity or for a
		340	fixed term (regardless of how the transaction is characterized), the
		341	Corresponding Source conveyed under this section must be accompanied
		342	by the Installation Information. But this requirement does not apply
		343	if neither you nor any third party retains the ability to install
		344	modified object code on the User Product (for example, the work has
		345	been installed in ROM).
		346
		347	The requirement to provide Installation Information does not include a
		348	requirement to continue to provide support service, warranty, or updates
		349	for a work that has been modified or installed by the recipient, or for
		350	the User Product in which it has been modified or installed. Access to a
		351	network may be denied when the modification itself materially and
		352	adversely affects the operation of the network or violates the rules and
		353	protocols for communication across the network.
		354
		355	Corresponding Source conveyed, and Installation Information provided,
		356	in accord with this section must be in a format that is publicly
		357	documented (and with an implementation available to the public in
		358	source code form), and must require no special password or key for
		359	unpacking, reading or copying.
		360
		361	7. Additional Terms.
		362
		363	"Additional permissions" are terms that supplement the terms of this
		364	License by making exceptions from one or more of its conditions.
		365	Additional permissions that are applicable to the entire Program shall
		366	be treated as though they were included in this License, to the extent
		367	that they are valid under applicable law. If additional permissions
		368	apply only to part of the Program, that part may be used separately
		369	under those permissions, but the entire Program remains governed by
		370	this License without regard to the additional permissions.
		371
		372	When you convey a copy of a covered work, you may at your option
		373	remove any additional permissions from that copy, or from any part of
		374	it. (Additional permissions may be written to require their own
		375	removal in certain cases when you modify the work.) You may place
		376	additional permissions on material, added by you to a covered work,
		377	for which you have or can give appropriate copyright permission.
		378
		379	Notwithstanding any other provision of this License, for material you
		380	add to a covered work, you may (if authorized by the copyright holders of
		381	that material) supplement the terms of this License with terms:
		382
		383	a) Disclaiming warranty or limiting liability differently from the
		384	terms of sections 15 and 16 of this License; or
		385
		386	b) Requiring preservation of specified reasonable legal notices or
		387	author attributions in that material or in the Appropriate Legal
		388	Notices displayed by works containing it; or
		389
		390	c) Prohibiting misrepresentation of the origin of that material, or
		391	requiring that modified versions of such material be marked in
		392	reasonable ways as different from the original version; or
		393
		394	d) Limiting the use for publicity purposes of names of licensors or
		395	authors of the material; or
		396
		397	e) Declining to grant rights under trademark law for use of some
		398	trade names, trademarks, or service marks; or
		399
		400	f) Requiring indemnification of licensors and authors of that
		401	material by anyone who conveys the material (or modified versions of
		402	it) with contractual assumptions of liability to the recipient, for
		403	any liability that these contractual assumptions directly impose on
		404	those licensors and authors.
		405
		406	All other non-permissive additional terms are considered "further
		407	restrictions" within the meaning of section 10. If the Program as you
		408	received it, or any part of it, contains a notice stating that it is
		409	governed by this License along with a term that is a further
		410	restriction, you may remove that term. If a license document contains
		411	a further restriction but permits relicensing or conveying under this
		412	License, you may add to a covered work material governed by the terms
		413	of that license document, provided that the further restriction does
		414	not survive such relicensing or conveying.
		415
		416	If you add terms to a covered work in accord with this section, you
		417	must place, in the relevant source files, a statement of the
		418	additional terms that apply to those files, or a notice indicating
		419	where to find the applicable terms.
		420
		421	Additional terms, permissive or non-permissive, may be stated in the
		422	form of a separately written license, or stated as exceptions;
		423	the above requirements apply either way.
		424
		425	8. Termination.
		426
		427	You may not propagate or modify a covered work except as expressly
		428	provided under this License. Any attempt otherwise to propagate or
		429	modify it is void, and will automatically terminate your rights under
		430	this License (including any patent licenses granted under the third
		431	paragraph of section 11).
		432
		433	However, if you cease all violation of this License, then your
		434	license from a particular copyright holder is reinstated (a)
		435	provisionally, unless and until the copyright holder explicitly and
		436	finally terminates your license, and (b) permanently, if the copyright
		437	holder fails to notify you of the violation by some reasonable means
		438	prior to 60 days after the cessation.
		439
		440	Moreover, your license from a particular copyright holder is
		441	reinstated permanently if the copyright holder notifies you of the
		442	violation by some reasonable means, this is the first time you have
		443	received notice of violation of this License (for any work) from that
		444	copyright holder, and you cure the violation prior to 30 days after
		445	your receipt of the notice.
		446
		447	Termination of your rights under this section does not terminate the
		448	licenses of parties who have received copies or rights from you under
		449	this License. If your rights have been terminated and not permanently
		450	reinstated, you do not qualify to receive new licenses for the same
		451	material under section 10.
		452
		453	9. Acceptance Not Required for Having Copies.
		454
		455	You are not required to accept this License in order to receive or
		456	run a copy of the Program. Ancillary propagation of a covered work
		457	occurring solely as a consequence of using peer-to-peer transmission
		458	to receive a copy likewise does not require acceptance. However,
		459	nothing other than this License grants you permission to propagate or
		460	modify any covered work. These actions infringe copyright if you do
		461	not accept this License. Therefore, by modifying or propagating a
		462	covered work, you indicate your acceptance of this License to do so.
		463
		464	10. Automatic Licensing of Downstream Recipients.
		465
		466	Each time you convey a covered work, the recipient automatically
		467	receives a license from the original licensors, to run, modify and
		468	propagate that work, subject to this License. You are not responsible
		469	for enforcing compliance by third parties with this License.
		470
		471	An "entity transaction" is a transaction transferring control of an
		472	organization, or substantially all assets of one, or subdividing an
		473	organization, or merging organizations. If propagation of a covered
		474	work results from an entity transaction, each party to that
		475	transaction who receives a copy of the work also receives whatever
		476	licenses to the work the party's predecessor in interest had or could
		477	give under the previous paragraph, plus a right to possession of the
		478	Corresponding Source of the work from the predecessor in interest, if
		479	the predecessor has it or can get it with reasonable efforts.
		480
		481	You may not impose any further restrictions on the exercise of the
		482	rights granted or affirmed under this License. For example, you may
		483	not impose a license fee, royalty, or other charge for exercise of
		484	rights granted under this License, and you may not initiate litigation
		485	(including a cross-claim or counterclaim in a lawsuit) alleging that
		486	any patent claim is infringed by making, using, selling, offering for
		487	sale, or importing the Program or any portion of it.
		488
		489	11. Patents.
		490
		491	A "contributor" is a copyright holder who authorizes use under this
		492	License of the Program or a work on which the Program is based. The
		493	work thus licensed is called the contributor's "contributor version".
		494
		495	A contributor's "essential patent claims" are all patent claims
		496	owned or controlled by the contributor, whether already acquired or
		497	hereafter acquired, that would be infringed by some manner, permitted
		498	by this License, of making, using, or selling its contributor version,
		499	but do not include claims that would be infringed only as a
		500	consequence of further modification of the contributor version. For
		501	purposes of this definition, "control" includes the right to grant
		502	patent sublicenses in a manner consistent with the requirements of
		503	this License.
		504
		505	Each contributor grants you a non-exclusive, worldwide, royalty-free
		506	patent license under the contributor's essential patent claims, to
		507	make, use, sell, offer for sale, import and otherwise run, modify and
		508	propagate the contents of its contributor version.
		509
		510	In the following three paragraphs, a "patent license" is any express
		511	agreement or commitment, however denominated, not to enforce a patent
		512	(such as an express permission to practice a patent or covenant not to
		513	sue for patent infringement). To "grant" such a patent license to a
		514	party means to make such an agreement or commitment not to enforce a
		515	patent against the party.
		516
		517	If you convey a covered work, knowingly relying on a patent license,
		518	and the Corresponding Source of the work is not available for anyone
		519	to copy, free of charge and under the terms of this License, through a
		520	publicly available network server or other readily accessible means,
		521	then you must either (1) cause the Corresponding Source to be so
		522	available, or (2) arrange to deprive yourself of the benefit of the
		523	patent license for this particular work, or (3) arrange, in a manner
		524	consistent with the requirements of this License, to extend the patent
		525	license to downstream recipients. "Knowingly relying" means you have
		526	actual knowledge that, but for the patent license, your conveying the
		527	covered work in a country, or your recipient's use of the covered work
		528	in a country, would infringe one or more identifiable patents in that
		529	country that you have reason to believe are valid.
		530
		531	If, pursuant to or in connection with a single transaction or
		532	arrangement, you convey, or propagate by procuring conveyance of, a
		533	covered work, and grant a patent license to some of the parties
		534	receiving the covered work authorizing them to use, propagate, modify
		535	or convey a specific copy of the covered work, then the patent license
		536	you grant is automatically extended to all recipients of the covered
		537	work and works based on it.
		538
		539	A patent license is "discriminatory" if it does not include within
		540	the scope of its coverage, prohibits the exercise of, or is
		541	conditioned on the non-exercise of one or more of the rights that are
		542	specifically granted under this License. You may not convey a covered
		543	work if you are a party to an arrangement with a third party that is
		544	in the business of distributing software, under which you make payment
		545	to the third party based on the extent of your activity of conveying
		546	the work, and under which the third party grants, to any of the
		547	parties who would receive the covered work from you, a discriminatory
		548	patent license (a) in connection with copies of the covered work
		549	conveyed by you (or copies made from those copies), or (b) primarily
		550	for and in connection with specific products or compilations that
		551	contain the covered work, unless you entered into that arrangement,
		552	or that patent license was granted, prior to 28 March 2007.
		553
		554	Nothing in this License shall be construed as excluding or limiting
		555	any implied license or other defenses to infringement that may
		556	otherwise be available to you under applicable patent law.
		557
		558	12. No Surrender of Others' Freedom.
		559
		560	If conditions are imposed on you (whether by court order, agreement or
		561	otherwise) that contradict the conditions of this License, they do not
		562	excuse you from the conditions of this License. If you cannot convey a
		563	covered work so as to satisfy simultaneously your obligations under this
		564	License and any other pertinent obligations, then as a consequence you may
		565	not convey it at all. For example, if you agree to terms that obligate you
		566	to collect a royalty for further conveying from those to whom you convey
		567	the Program, the only way you could satisfy both those terms and this
		568	License would be to refrain entirely from conveying the Program.
		569
		570	13. Use with the GNU Affero General Public License.
		571
		572	Notwithstanding any other provision of this License, you have
		573	permission to link or combine any covered work with a work licensed
		574	under version 3 of the GNU Affero General Public License into a single
		575	combined work, and to convey the resulting work. The terms of this
		576	License will continue to apply to the part which is the covered work,
		577	but the special requirements of the GNU Affero General Public License,
		578	section 13, concerning interaction through a network will apply to the
		579	combination as such.
		580
		581	14. Revised Versions of this License.
		582
		583	The Free Software Foundation may publish revised and/or new versions of
		584	the GNU General Public License from time to time. Such new versions will
		585	be similar in spirit to the present version, but may differ in detail to
		586	address new problems or concerns.
		587
		588	Each version is given a distinguishing version number. If the
		589	Program specifies that a certain numbered version of the GNU General
		590	Public License "or any later version" applies to it, you have the
		591	option of following the terms and conditions either of that numbered
		592	version or of any later version published by the Free Software
		593	Foundation. If the Program does not specify a version number of the
		594	GNU General Public License, you may choose any version ever published
		595	by the Free Software Foundation.
		596
		597	If the Program specifies that a proxy can decide which future
		598	versions of the GNU General Public License can be used, that proxy's
		599	public statement of acceptance of a version permanently authorizes you
		600	to choose that version for the Program.
		601
		602	Later license versions may give you additional or different
		603	permissions. However, no additional obligations are imposed on any
		604	author or copyright holder as a result of your choosing to follow a
		605	later version.
		606
		607	15. Disclaimer of Warranty.
		608
		609	THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
		610	APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
		611	HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
		612	OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
		613	THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		614	PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
		615	IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
		616	ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
		617
		618	16. Limitation of Liability.
		619
		620	IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
		621	WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
		622	THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
		623	GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
		624	USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
		625	DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
		626	PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
		627	EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
		628	SUCH DAMAGES.
		629
		630	17. Interpretation of Sections 15 and 16.
		631
		632	If the disclaimer of warranty and limitation of liability provided
		633	above cannot be given local legal effect according to their terms,
		634	reviewing courts shall apply local law that most closely approximates
		635	an absolute waiver of all civil liability in connection with the
		636	Program, unless a warranty or assumption of liability accompanies a
		637	copy of the Program in return for a fee.
		638
		639	END OF TERMS AND CONDITIONS
		640
		641	How to Apply These Terms to Your New Programs
		642
		643	If you develop a new program, and you want it to be of the greatest
		644	possible use to the public, the best way to achieve this is to make it
		645	free software which everyone can redistribute and change under these terms.
		646
		647	To do so, attach the following notices to the program. It is safest
		648	to attach them to the start of each source file to most effectively
		649	state the exclusion of warranty; and each file should have at least
		650	the "copyright" line and a pointer to where the full notice is found.
		651
		652	<one line to give the program's name and a brief idea of what it does.>
		653	Copyright (C) <year> <name of author>
		654
		655	This program is free software: you can redistribute it and/or modify
		656	it under the terms of the GNU General Public License as published by
		657	the Free Software Foundation, either version 3 of the License, or
		658	(at your option) any later version.
		659
		660	This program is distributed in the hope that it will be useful,
		661	but WITHOUT ANY WARRANTY; without even the implied warranty of
		662	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		663	GNU General Public License for more details.
		664
		665	You should have received a copy of the GNU General Public License
		666	along with this program. If not, see <https://www.gnu.org/licenses/>.
		667
		668	Also add information on how to contact you by electronic and paper mail.
		669
		670	If the program does terminal interaction, make it output a short
		671	notice like this when it starts in an interactive mode:
		672
		673	<program> Copyright (C) <year> <name of author>
		674	This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
		675	This is free software, and you are welcome to redistribute it
		676	under certain conditions; type `show c' for details.
		677
		678	The hypothetical commands `show w' and `show c' should show the appropriate
		679	parts of the General Public License. Of course, your program's commands
		680	might be different; for a GUI interface, you would use an "about box".
		681
		682	You should also get your employer (if you work as a programmer) or school,
		683	if any, to sign a "copyright disclaimer" for the program, if necessary.
		684	For more information on this, and how to apply and follow the GNU GPL, see
		685	<https://www.gnu.org/licenses/>.
		686
		687	The GNU General Public License does not permit incorporating your program
		688	into proprietary programs. If your program is a subroutine library, you
		689	may consider it more useful to permit linking proprietary applications with
		690	the library. If this is what you want to do, use the GNU Lesser General
		691	Public License instead of this License. But first, please read
		692	<https://www.gnu.org/licenses/why-not-lgpl.html>. No newline at end of file

licenses/LICENSE.sway

0 created 644 +19 0

@@ -0,0 +1,19
	1	Copyright (c) 2016-2017 Drew DeVault
	2
	3	Permission is hereby granted, free of charge, to any person obtaining a copy of
	4	this software and associated documentation files (the "Software"), to deal in
	5	the Software without restriction, including without limitation the rights to
	6	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
	7	of the Software, and to permit persons to whom the Software is furnished to do
	8	so, subject to the following conditions:
	9
	10	The above copyright notice and this permission notice shall be included in all
	11	copies or substantial portions of the Software.
	12
	13	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	14	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	15	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	16	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	17	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	18	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	19	SOFTWARE.

licenses/LICENSE.tinywl

0 created 644 +127 0

@@ -0,0 +1,127
	1	dwl is originally based on TinyWL, which is used under the following license:
	2
	3	This work is licensed under CC0, which effectively puts it in the public domain.
	4
	5	---
	6
	7	Creative Commons Legal Code
	8
	9	CC0 1.0 Universal
	10
	11	CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
	12	LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
	13	ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
	14	INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
	15	REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
	16	PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
	17	THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
	18	HEREUNDER.
	19
	20	Statement of Purpose
	21
	22	The laws of most jurisdictions throughout the world automatically confer
	23	exclusive Copyright and Related Rights (defined below) upon the creator
	24	and subsequent owner(s) (each and all, an "owner") of an original work of
	25	authorship and/or a database (each, a "Work").
	26
	27	Certain owners wish to permanently relinquish those rights to a Work for
	28	the purpose of contributing to a commons of creative, cultural and
	29	scientific works ("Commons") that the public can reliably and without fear
	30	of later claims of infringement build upon, modify, incorporate in other
	31	works, reuse and redistribute as freely as possible in any form whatsoever
	32	and for any purposes, including without limitation commercial purposes.
	33	These owners may contribute to the Commons to promote the ideal of a free
	34	culture and the further production of creative, cultural and scientific
	35	works, or to gain reputation or greater distribution for their Work in
	36	part through the use and efforts of others.
	37
	38	For these and/or other purposes and motivations, and without any
	39	expectation of additional consideration or compensation, the person
	40	associating CC0 with a Work (the "Affirmer"), to the extent that he or she
	41	is an owner of Copyright and Related Rights in the Work, voluntarily
	42	elects to apply CC0 to the Work and publicly distribute the Work under its
	43	terms, with knowledge of his or her Copyright and Related Rights in the
	44	Work and the meaning and intended legal effect of CC0 on those rights.
	45
	46	1. Copyright and Related Rights. A Work made available under CC0 may be
	47	protected by copyright and related or neighboring rights ("Copyright and
	48	Related Rights"). Copyright and Related Rights include, but are not
	49	limited to, the following:
	50
	51	i. the right to reproduce, adapt, distribute, perform, display,
	52	communicate, and translate a Work;
	53	ii. moral rights retained by the original author(s) and/or performer(s);
	54	iii. publicity and privacy rights pertaining to a person's image or
	55	likeness depicted in a Work;
	56	iv. rights protecting against unfair competition in regards to a Work,
	57	subject to the limitations in paragraph 4(a), below;
	58	v. rights protecting the extraction, dissemination, use and reuse of data
	59	in a Work;
	60	vi. database rights (such as those arising under Directive 96/9/EC of the
	61	European Parliament and of the Council of 11 March 1996 on the legal
	62	protection of databases, and under any national implementation
	63	thereof, including any amended or successor version of such
	64	directive); and
	65	vii. other similar, equivalent or corresponding rights throughout the
	66	world based on applicable law or treaty, and any national
	67	implementations thereof.
	68
	69	2. Waiver. To the greatest extent permitted by, but not in contravention
	70	of, applicable law, Affirmer hereby overtly, fully, permanently,
	71	irrevocably and unconditionally waives, abandons, and surrenders all of
	72	Affirmer's Copyright and Related Rights and associated claims and causes
	73	of action, whether now known or unknown (including existing as well as
	74	future claims and causes of action), in the Work (i) in all territories
	75	worldwide, (ii) for the maximum duration provided by applicable law or
	76	treaty (including future time extensions), (iii) in any current or future
	77	medium and for any number of copies, and (iv) for any purpose whatsoever,
	78	including without limitation commercial, advertising or promotional
	79	purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
	80	member of the public at large and to the detriment of Affirmer's heirs and
	81	successors, fully intending that such Waiver shall not be subject to
	82	revocation, rescission, cancellation, termination, or any other legal or
	83	equitable action to disrupt the quiet enjoyment of the Work by the public
	84	as contemplated by Affirmer's express Statement of Purpose.
	85
	86	3. Public License Fallback. Should any part of the Waiver for any reason
	87	be judged legally invalid or ineffective under applicable law, then the
	88	Waiver shall be preserved to the maximum extent permitted taking into
	89	account Affirmer's express Statement of Purpose. In addition, to the
	90	extent the Waiver is so judged Affirmer hereby grants to each affected
	91	person a royalty-free, non transferable, non sublicensable, non exclusive,
	92	irrevocable and unconditional license to exercise Affirmer's Copyright and
	93	Related Rights in the Work (i) in all territories worldwide, (ii) for the
	94	maximum duration provided by applicable law or treaty (including future
	95	time extensions), (iii) in any current or future medium and for any number
	96	of copies, and (iv) for any purpose whatsoever, including without
	97	limitation commercial, advertising or promotional purposes (the
	98	"License"). The License shall be deemed effective as of the date CC0 was
	99	applied by Affirmer to the Work. Should any part of the License for any
	100	reason be judged legally invalid or ineffective under applicable law, such
	101	partial invalidity or ineffectiveness shall not invalidate the remainder
	102	of the License, and in such case Affirmer hereby affirms that he or she
	103	will not (i) exercise any of his or her remaining Copyright and Related
	104	Rights in the Work or (ii) assert any associated claims and causes of
	105	action with respect to the Work, in either case contrary to Affirmer's
	106	express Statement of Purpose.
	107
	108	4. Limitations and Disclaimers.
	109
	110	a. No trademark or patent rights held by Affirmer are waived, abandoned,
	111	surrendered, licensed or otherwise affected by this document.
	112	b. Affirmer offers the Work as-is and makes no representations or
	113	warranties of any kind concerning the Work, express, implied,
	114	statutory or otherwise, including without limitation warranties of
	115	title, merchantability, fitness for a particular purpose, non
	116	infringement, or the absence of latent or other defects, accuracy, or
	117	the present or absence of errors, whether or not discoverable, all to
	118	the greatest extent permissible under applicable law.
	119	c. Affirmer disclaims responsibility for clearing rights of other persons
	120	that may apply to the Work or any use thereof, including without
	121	limitation any person's Copyright and Related Rights in the Work.
	122	Further, Affirmer disclaims responsibility for obtaining any necessary
	123	consents, permissions or other rights required for any use of the
	124	Work.
	125	d. Affirmer understands and acknowledges that Creative Commons is not a
	126	party to this document and has no duty or obligation with respect to
	127	this CC0 or use of the Work.

licenses/LICENSE.wlroots

0 created 644 +21 0

@@ -0,0 +1,21
	1	Copyright (c) 2017, 2018 Drew DeVault
	2	Copyright (c) 2014 Jari Vetoniemi
	3	Copyright (c) 2023 The wlroots contributors
	4
	5	Permission is hereby granted, free of charge, to any person obtaining a copy of
	6	this software and associated documentation files (the "Software"), to deal in
	7	the Software without restriction, including without limitation the rights to
	8	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
	9	of the Software, and to permit persons to whom the Software is furnished to do
	10	so, subject to the following conditions:
	11
	12	The above copyright notice and this permission notice shall be included in all
	13	copies or substantial portions of the Software.
	14
	15	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	21	SOFTWARE.

parser/parser.c

0 created 644 +757 0

This diff has been collapsed as it changes many lines, (757 lines changed) Show them Hide them
	@@ -0,0 +1,757
		1	/* Here be a small dragon.
		2	* Not as large as the monster
		3	* in src/swindle.c
		4	* but you get the idea */
		5
		6	#include "parser.h"
		7
		8	#include <stdio.h>
		9	#include <stdlib.h>
		10	#include <string.h>
		11	#include <errno.h>
		12	#include <time.h>
		13	#include <unistd.h>
		14	#include <signal.h>
		15	#include <sys/wait.h>
		16	#include <sys/inotify.h>
		17	#include <linux/input-event-codes.h>
		18	#include <xkbcommon/xkbcommon.h>
		19	#include <wayland-server-core.h>
		20
		21	/* Lua */
		22	#include <lua.h>
		23	#include <lauxlib.h>
		24	#include <lualib.h>
		25
		26	/* wlroots */
		27	#include <wlr/util/log.h>
		28	#include <wlr/types/wlr_keyboard.h>
		29	#include <libinput.h>
		30
		31	/* Forward declarations from src/swindle.c */
		32	extern struct wl_list mons;
		33	extern struct wl_list clients;
		34	void arrange(void *m);
		35
		36	/* Internal watcher state */
		37
		38	typedef struct {
		39	int inotify_fd;
		40	int watch_fd;
		41	char path[1024];
		42	config_reload_cb cb;
		43	void *userdata;
		44	struct wl_event_source *event_src;
		45	} WatchState;
		46
		47	/* Helpers */
		48
		49	static void
		50	lua_log_error(lua_State L, const char context)
		51	{
		52	fprintf(stderr, "swindle config [%s]: %s\n",
		53	context, lua_tostring(L, -1));
		54	lua_pop(L, 1);
		55	}
		56
		57	/* Get a string field from the table at the top of the stack
		58	* Writes into buf and returns false and leaves buf untouched on failure
		59	*/
		60
		61	static bool
		62	lua_get_string(lua_State L, const char key, char *buf, size_t bufsz)
		63	{
		64	lua_getfield(L, -1, key);
		65	bool ok = lua_isstring(L, -1);
		66	if (ok)
		67	strncpy(buf, lua_tostring(L, -1), bufsz - 1);
		68	lua_pop(L, 1);
		69	return ok;
		70	}
		71
		72	/* Get an integer field. It falls back to `def` if missing or wrong type */
		73
		74	static int
		75	lua_get_int(lua_State L, const char key, int def)
		76	{
		77	lua_getfield(L, -1, key);
		78	int val = lua_isnumber(L, -1) ? (int)lua_tointeger(L, -1) : def;
		79	lua_pop(L, 1);
		80	return val;
		81	}
		82
		83	static double
		84	lua_get_double(lua_State L, const char key, double def)
		85	{
		86	lua_getfield(L, -1, key);
		87	double val = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : def;
		88	lua_pop(L, 1);
		89	return val;
		90	}
		91
		92	static bool
		93	lua_get_bool(lua_State L, const char key, bool def)
		94	{
		95	lua_getfield(L, -1, key);
		96	bool val = lua_isboolean(L, -1) ? lua_toboolean(L, -1) : def;
		97	lua_pop(L, 1);
		98	return val;
		99	}
		100
		101	/* wlroots hard-asserts opacity is in [0,1] and takes the whole thing
		102	* down with it if it isn't (as it should), so it might as well clamp anything
		103	* a user's config throws at it because users are kinda unwise */
		104
		105	static float
		106	lua_get_opacity(lua_State L, const char key, float def)
		107	{
		108	double v = lua_get_double(L, key, (double)def);
		109	if (v < 0.0) {
		110	fprintf(stderr, "swindle config: '%s' below 0, clamping to 0\n", key);
		111	v = 0.0;
		112	} else if (v > 1.0) {
		113	fprintf(stderr, "swindle config: '%s' above 1, clamping to 1\n", key);
		114	v = 1.0;
		115	}
		116	return (float)v;
		117	}
		118
		119	static void
		120	parse_color_hex(uint32_t hex, float out[4])
		121	{
		122	out[0] = ((hex >> 24) & 0xFF) / 255.0f;
		123	out[1] = ((hex >> 16) & 0xFF) / 255.0f;
		124	out[2] = ((hex >> 8) & 0xFF) / 255.0f;
		125	out[3] = ( hex & 0xFF) / 255.0f;
		126	}
		127
		128	static void
		129	lua_get_color(lua_State L, const char key, float out[4],
		130	float r, float g, float b, float a)
		131	{
		132	lua_getfield(L, -1, key);
		133	if (lua_isnumber(L, -1))
		134	parse_color_hex((uint32_t)lua_tointeger(L, -1), out);
		135	else {
		136	out[0] = r; out[1] = g; out[2] = b; out[3] = a;
		137	}
		138	lua_pop(L, 1);
		139	}
		140
		141	static uint32_t
		142	parse_modifier(const char *name)
		143	{
		144	if (!strcmp(name, "shift")) return WLR_MODIFIER_SHIFT;
		145	if (!strcmp(name, "ctrl")) return WLR_MODIFIER_CTRL;
		146	if (!strcmp(name, "alt")) return WLR_MODIFIER_ALT;
		147	if (!strcmp(name, "logo")) return WLR_MODIFIER_LOGO;
		148	if (!strcmp(name, "mod2")) return WLR_MODIFIER_MOD2;
		149	if (!strcmp(name, "mod3")) return WLR_MODIFIER_MOD3;
		150	if (!strcmp(name, "mod5")) return WLR_MODIFIER_MOD5;
		151	fprintf(stderr, "swindle config: unknown modifier '%s', ignoring\n", name);
		152	return 0;
		153	}
		154
		155	/* Section parsers */
		156
		157	static void
		158	parse_appearance(lua_State L, CfgAppearance a)
		159	{
		160	lua_getglobal(L, "appearance");
		161	if (!lua_istable(L, -1)) {
		162	fprintf(stderr, "swindle config: 'appearance' table missing' \n");
		163	lua_pop(L, 1);
		164	/* defaults */
		165	a->inner_border_px = 1;
		166	a->outer_border_px = 1;
		167	a->gaps = 10;
		168	a->smart_gaps = false;
		169	parse_color_hex(0x222222ff, a->root_color);
		170	parse_color_hex(0x00000000, a->inner_border_color);
		171	parse_color_hex(0x00000000, a->outer_border_color);
		172	parse_color_hex(0xe8e8e8ff, a->inner_focus_color);
		173	parse_color_hex(0xe8e8e8ff, a->outer_focus_color);
		174	parse_color_hex(0xff0000ff, a->inner_urgent_color);
		175	parse_color_hex(0xff0000ff, a->outer_urgent_color);
		176	a->fullscreen_bg[3] = 1.0f;
		177	a->active_opacity = 1.0f;
		178	a->inactive_opacity = 1.0f;
		179	return;
		180	}
		181
		182	a->inner_border_px = (unsigned int)lua_get_int(L, "inner_border_px", 1);
		183	a->outer_border_px = (unsigned int)lua_get_int(L, "outer_border_px", 1);
		184	a->gaps = (unsigned int)lua_get_int(L, "gaps", 10);
		185	a->smart_gaps = lua_get_bool(L, "smart_gaps", false);
		186
		187	lua_get_color(L, "root_color", a->root_color, 0.133f,0.133f,0.133f,1.f);
		188	lua_get_color(L, "inner_border_color", a->inner_border_color, 0.f,0.f,0.f,0.f);
		189	lua_get_color(L, "outer_border_color", a->outer_border_color, 0.f,0.f,0.f,0.f);
		190	lua_get_color(L, "inner_focus_color", a->inner_focus_color, 0.91f,0.91f,0.91f,1.f);
		191	lua_get_color(L, "outer_focus_color", a->outer_focus_color, 0.91f,0.91f,0.91f,1.f);
		192	lua_get_color(L, "inner_urgent_color", a->inner_urgent_color, 1.f,0.f,0.f,1.f);
		193	lua_get_color(L, "outer_urgent_color", a->outer_urgent_color, 1.f,0.f,0.f,1.f);
		194
		195	a->active_opacity = lua_get_opacity(L, "active_opacity", 1.0f);
		196	a->inactive_opacity = lua_get_opacity(L, "inactive_opacity", 1.0f);
		197
		198	lua_getfield(L, -1, "fullscreen_bg");
		199	if (lua_isnumber(L, -1))
		200	parse_color_hex((uint32_t)lua_tointeger(L, -1), a->fullscreen_bg);
		201	else {
		202	a->fullscreen_bg[0] = 0.f;
		203	a->fullscreen_bg[1] = 0.f;
		204	a->fullscreen_bg[2] = 0.f;
		205	a->fullscreen_bg[3] = 1.f;
		206	}
		207	lua_pop(L, 1);
		208
		209	lua_pop(L, 1); /* pop appearance table */
		210	}
		211
		212	static void
		213	parse_input(lua_State L, CfgInput inp)
		214	{
		215	lua_getglobal(L, "input");
		216	if (!lua_istable(L, -1)) {
		217	fprintf(stderr, "swindle config: 'input' table missing, "
		218	"using defaults. You'll feel the repeat delay.\n");
		219	lua_pop(L, 1);
		220	inp->repeat_rate = 50;
		221	inp->repeat_delay = 150;
		222	inp->tap_to_click = true;
		223	inp->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
		224	strcpy(inp->layout, "us");
		225	return;
		226	}
		227
		228	inp->repeat_rate = lua_get_int (L, "repeat_rate", 50);
		229	inp->repeat_delay = lua_get_int (L, "repeat_delay", 150);
		230	inp->tap_to_click = lua_get_bool(L, "tap_to_click", true);
		231	inp->tap_and_drag = lua_get_bool(L, "tap_and_drag", true);
		232	inp->drag_lock = lua_get_bool(L, "drag_lock", true);
		233	inp->natural_scrolling = lua_get_bool(L, "natural_scrolling", false);
		234	inp->disable_while_typing = lua_get_bool(L, "disable_while_typing", true);
		235	inp->left_handed = lua_get_bool(L, "left_handed", false);
		236	inp->middle_button_emulation= lua_get_bool(L, "middle_button_emulation",false);
		237	inp->accel_speed = lua_get_double(L, "accel_speed", 0.0);
		238
		239	lua_get_string(L, "layout", inp->layout, sizeof(inp->layout));
		240	lua_get_string(L, "variant", inp->variant, sizeof(inp->variant));
		241	lua_get_string(L, "model", inp->model, sizeof(inp->model));
		242	lua_get_string(L, "options", inp->options, sizeof(inp->options));
		243	if (!inp->layout[0]) strcpy(inp->layout, "us");
		244
		245	char scratch[CFG_MAX_STRLEN] = {0};
		246
		247	lua_get_string(L, "scroll_method", scratch, sizeof(scratch));
		248	if (!strcmp(scratch, "2fg")) inp->scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
		249	else if (!strcmp(scratch, "edge")) inp->scroll_method = LIBINPUT_CONFIG_SCROLL_EDGE;
		250	else if (!strcmp(scratch, "button")) inp->scroll_method = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
		251	else inp->scroll_method = LIBINPUT_CONFIG_SCROLL_2FG;
		252
		253	lua_get_string(L, "accel_profile", scratch, sizeof(scratch));
		254	if (!strcmp(scratch, "flat")) inp->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
		255	else inp->accel_profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE;
		256
		257	lua_get_string(L, "click_method", scratch, sizeof(scratch));
		258	if (!strcmp(scratch, "clickfinger")) inp->click_method = LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER;
		259	else if (!strcmp(scratch, "button_areas")) inp->click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
		260	else inp->click_method = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
		261
		262	lua_get_string(L, "send_events_mode", scratch, sizeof(scratch));
		263	if (!strcmp(scratch, "disabled")) inp->send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
		264	else if (!strcmp(scratch, "disabled_on_external")) inp->send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
		265	else inp->send_events_mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
		266
		267	lua_get_string(L, "tap_button_map", scratch, sizeof(scratch));
		268	if (!strcmp(scratch, "lmr")) inp->tap_button_map = LIBINPUT_CONFIG_TAP_MAP_LMR;
		269	else inp->tap_button_map = LIBINPUT_CONFIG_TAP_MAP_LRM;
		270
		271	lua_pop(L, 1);
		272	}
		273
		274	static void
		275	parse_rules(lua_State L, Config cfg)
		276	{
		277	lua_getglobal(L, "rules");
		278	if (!lua_istable(L, -1)) {
		279	lua_pop(L, 1);
		280	return;
		281	}
		282
		283	cfg->nrules = 0;
		284	int n = (int)lua_rawlen(L, -1);
		285	for (int i = 1; i <= n && cfg->nrules < CFG_MAX_RULES; i++) {
		286	lua_rawgeti(L, -1, i);
		287	if (!lua_istable(L, -1)) { lua_pop(L, 1); continue; }
		288
		289	CfgRule *r = &cfg->rules[cfg->nrules++];
		290	memset(r, 0, sizeof(*r));
		291	lua_get_string(L, "app_id", r->app_id, sizeof(r->app_id));
		292	lua_get_string(L, "title", r->title, sizeof(r->title));
		293	r->tags = (uint32_t)lua_get_int(L, "tags", 0);
		294	r->floating = lua_get_bool(L, "floating", false);
		295	r->monitor = lua_get_int(L, "monitor", -1);
		296
		297	lua_pop(L, 1);
		298	}
		299	lua_pop(L, 1);
		300	}
		301
		302	static void
		303	parse_monitors(lua_State L, Config cfg)
		304	{
		305	lua_getglobal(L, "monitors");
		306	if (!lua_istable(L, -1)) {
		307	lua_pop(L, 1);
		308	cfg->nmonitors = 1;
		309	CfgMonitorRule *m = &cfg->monitors[0];
		310	memset(m, 0, sizeof(*m));
		311	m->mfact = 0.55f;
		312	m->nmaster = 1;
		313	m->scale = 1.0f;
		314	strcpy(m->layout, "dwindle");
		315	m->x = m->y = -1;
		316	return;
		317	}
		318
		319	cfg->nmonitors = 0;
		320	int n = (int)lua_rawlen(L, -1);
		321	for (int i = 1; i <= n && cfg->nmonitors < CFG_MAX_MONITORS; i++) {
		322	lua_rawgeti(L, -1, i);
		323	if (!lua_istable(L, -1)) { lua_pop(L, 1); continue; }
		324
		325	CfgMonitorRule *m = &cfg->monitors[cfg->nmonitors++];
		326	memset(m, 0, sizeof(*m));
		327
		328	lua_getfield(L, -1, "name");
		329	if (lua_isstring(L, -1))
		330	strncpy(m->name, lua_tostring(L, -1), sizeof(m->name)-1);
		331	lua_pop(L, 1);
		332
		333	m->mfact = (float)lua_get_double(L, "mfact", 0.55);
		334	m->nmaster = lua_get_int (L, "nmaster", 1);
		335	m->scale = (float)lua_get_double(L, "scale", 1.0);
		336	m->x = lua_get_int (L, "x", -1);
		337	m->y = lua_get_int (L, "y", -1);
		338	m->transform = lua_get_int (L, "transform", 0);
		339	lua_get_string(L, "layout", m->layout, sizeof(m->layout));
		340	if (!m->layout[0]) strcpy(m->layout, "dwindle");
		341
		342	lua_pop(L, 1);
		343	}
		344	lua_pop(L, 1);
		345	}
		346
		347	static void
		348	parse_keybinds(lua_State L, Config cfg)
		349	{
		350	lua_getglobal(L, "keybinds");
		351	if (!lua_istable(L, -1)) {
		352	lua_pop(L, 1);
		353	return;
		354	}
		355
		356	cfg->nkeybinds = 0;
		357	struct xkb_context *xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
		358
		359	int n = (int)lua_rawlen(L, -1);
		360	for (int i = 1; i <= n && cfg->nkeybinds < CFG_MAX_KEYBINDS; i++) {
		361	lua_rawgeti(L, -1, i);
		362	if (!lua_istable(L, -1)) { lua_pop(L, 1); continue; }
		363
		364	CfgKeybind *kb = &cfg->keybinds[cfg->nkeybinds];
		365	memset(kb, 0, sizeof(*kb));
		366
		367	/* mods: array of strings */
		368	kb->mods = 0;
		369	lua_getfield(L, -1, "mods");
		370	if (lua_istable(L, -1)) {
		371	int nm = (int)lua_rawlen(L, -1);
		372	for (int m = 1; m <= nm; m++) {
		373	lua_rawgeti(L, -1, m);
		374	if (lua_isstring(L, -1))
		375	kb->mods \|= parse_modifier(lua_tostring(L, -1));
		376	lua_pop(L, 1);
		377	}
		378	}
		379	lua_pop(L, 1);
		380
		381	/* key: string keysym name, e.g. "q", "Return", "XF86AudioMute" */
		382	char keyname[CFG_MAX_STRLEN] = {0};
		383	lua_get_string(L, "key", keyname, sizeof(keyname));
		384	kb->key = xkb_keysym_from_name(keyname, XKB_KEYSYM_CASE_INSENSITIVE);
		385	if (kb->key == XKB_KEY_NoSymbol) {
		386	fprintf(stderr, "swindle config: unknown key '%s', skipping bind\n",
		387	keyname);
		388	lua_pop(L, 1); /* keybind entry table */
		389	continue;
		390	}
		391
		392	lua_get_string(L, "action", kb->action, sizeof(kb->action));
		393
		394	/* args: optional array of strings */
		395	kb->nargs = 0;
		396	lua_getfield(L, -1, "args");
		397	if (lua_istable(L, -1)) {
		398	int na = (int)lua_rawlen(L, -1);
		399	for (int a = 1; a <= na && kb->nargs < CFG_MAX_ARGS; a++) {
		400	lua_rawgeti(L, -1, a);
		401	if (lua_isstring(L, -1))
		402	strncpy(kb->args[kb->nargs++],
		403	lua_tostring(L, -1),
		404	CFG_MAX_STRLEN - 1);
		405	lua_pop(L, 1);
		406	}
		407	}
		408	lua_pop(L, 1); /* args */
		409
		410	cfg->nkeybinds++;
		411	lua_pop(L, 1); /* keybind entry */
		412	}
		413
		414	xkb_context_unref(xkb_ctx);
		415	lua_pop(L, 1); /* keybinds table */
		416	}
		417
		418	static void
		419	parse_buttons(lua_State L, Config cfg)
		420	{
		421	lua_getglobal(L, "buttons");
		422	if (!lua_istable(L, -1)) {
		423	lua_pop(L, 1);
		424	return;
		425	}
		426
		427	cfg->nbuttons = 0;
		428	int n = (int)lua_rawlen(L, -1);
		429	for (int i = 1; i <= n && cfg->nbuttons < CFG_MAX_KEYBINDS; i++) {
		430	lua_rawgeti(L, -1, i);
		431	if (!lua_istable(L, -1)) { lua_pop(L, 1); continue; }
		432
		433	CfgButton *b = &cfg->buttons[cfg->nbuttons++];
		434	memset(b, 0, sizeof(*b));
		435
		436	b->mods = 0;
		437	lua_getfield(L, -1, "mods");
		438	if (lua_istable(L, -1)) {
		439	int nm = (int)lua_rawlen(L, -1);
		440	for (int m = 1; m <= nm; m++) {
		441	lua_rawgeti(L, -1, m);
		442	if (lua_isstring(L, -1))
		443	b->mods \|= parse_modifier(lua_tostring(L, -1));
		444	lua_pop(L, 1);
		445	}
		446	}
		447	lua_pop(L, 1);
		448
		449	char btnname[CFG_MAX_STRLEN] = {0};
		450	lua_get_string(L, "button", btnname, sizeof(btnname));
		451	if (!strcmp(btnname, "left")) b->button = BTN_LEFT;
		452	else if (!strcmp(btnname, "right")) b->button = BTN_RIGHT;
		453	else if (!strcmp(btnname, "middle")) b->button = BTN_MIDDLE;
		454	else b->button = (uint32_t)atoi(btnname);
		455
		456	lua_get_string(L, "action", b->action, sizeof(b->action));
		457
		458	b->nargs = 0;
		459	lua_getfield(L, -1, "args");
		460	if (lua_istable(L, -1)) {
		461	int na = (int)lua_rawlen(L, -1);
		462	for (int a = 1; a <= na && b->nargs < CFG_MAX_ARGS; a++) {
		463	lua_rawgeti(L, -1, a);
		464	if (lua_isstring(L, -1))
		465	strncpy(b->args[b->nargs++],
		466	lua_tostring(L, -1),
		467	CFG_MAX_STRLEN - 1);
		468	lua_pop(L, 1);
		469	}
		470	}
		471	lua_pop(L, 1); /* args */
		472
		473	lua_pop(L, 1);
		474	}
		475	lua_pop(L, 1);
		476	}
		477
		478	static void
		479	parse_autostart(lua_State L, Config cfg)
		480	{
		481	lua_getglobal(L, "autostart");
		482	if (!lua_istable(L, -1)) {
		483	lua_pop(L, 1);
		484	return;
		485	}
		486
		487	cfg->nautostart = 0;
		488	int n = (int)lua_rawlen(L, -1);
		489	for (int i = 1; i <= n && cfg->nautostart < CFG_MAX_AUTOSTART; i++) {
		490	lua_rawgeti(L, -1, i);
		491	if (!lua_isstring(L, -1)) {
		492	lua_pop(L, 1);
		493	continue;
		494	}
		495	strncpy(cfg->autostart[cfg->nautostart].cmd,
		496	lua_tostring(L, -1),
		497	CFG_MAX_AUTOSTART_CMD - 1);
		498	cfg->nautostart++;
		499	lua_pop(L, 1);
		500	}
		501	lua_pop(L, 1);
		502	}
		503
		504	/* Public API */
		505
		506	char *
		507	config_get_path(char *buf, size_t bufsz)
		508	{
		509	const char *xdg = getenv("XDG_CONFIG_HOME");
		510	if (xdg && *xdg)
		511	snprintf(buf, bufsz, "%s/swindle/config.lua", xdg);
		512	else {
		513	const char *home = getenv("HOME");
		514	if (!home) home = "/root"; /* you're probably root, aren't you */
		515	snprintf(buf, bufsz, "%s/.config/swindle/config.lua", home);
		516	}
		517	return buf;
		518	}
		519
		520	int
		521	config_load(const char path, Config cfg)
		522	{
		523	memset(cfg, 0, sizeof(*cfg));
		524
		525	lua_State *L = luaL_newstate();
		526	if (!L) {
		527	fprintf(stderr, "swindle config: failed to create Lua state. "
		528	"Truly rock bottom.\n");
		529	return -1;
		530	}
		531	luaL_openlibs(L);
		532
		533	if (luaL_dofile(L, path) != LUA_OK) {
		534	lua_log_error(L, "load");
		535	lua_close(L);
		536	return -1;
		537	}
		538
		539	/* Top-level booleans */
		540	lua_getglobal(L, "sloppy_focus");
		541	cfg->sloppyfocus = lua_isboolean(L, -1) ? lua_toboolean(L, -1) : true;
		542	lua_pop(L, 1);
		543
		544	lua_getglobal(L, "bypass_surface_visibility");
		545	cfg->bypass_surface_visibility = lua_isboolean(L, -1)
		546	? lua_toboolean(L, -1) : false;
		547	lua_pop(L, 1);
		548
		549	lua_getglobal(L, "log_level");
		550	if (lua_isstring(L, -1)) {
		551	const char *ll = lua_tostring(L, -1);
		552	if (!strcmp(ll, "silent")) cfg->log_level = WLR_SILENT;
		553	else if (!strcmp(ll, "info")) cfg->log_level = WLR_INFO;
		554	else if (!strcmp(ll, "debug")) cfg->log_level = WLR_DEBUG;
		555	else cfg->log_level = WLR_ERROR;
		556	} else {
		557	cfg->log_level = WLR_ERROR;
		558	}
		559	lua_pop(L, 1);
		560
		561	parse_appearance(L, &cfg->appearance);
		562	parse_input (L, &cfg->input);
		563	parse_rules (L, cfg);
		564	parse_monitors (L, cfg);
		565	parse_keybinds (L, cfg);
		566	parse_buttons (L, cfg);
		567	parse_autostart (L, cfg);
		568
		569	lua_close(L);
		570	return 0;
		571	}
		572
		573	/* Apply functions */
		574
		575	void
		576	config_apply_appearance(const Config *cfg)
		577	{
		578	(void)cfg;
		579	}
		580
		581	void
		582	config_apply_input(const Config *cfg)
		583	{
		584	(void)cfg;
		585	}
		586
		587	void
		588	config_apply_keybinds(const Config *cfg)
		589	{
		590	(void)cfg;
		591	}
		592
		593	void
		594	config_autostart_run(const Config *cfg)
		595	{
		596	if (cfg->nautostart == 0)
		597	return;
		598
		599	pid_t pid = fork();
		600	if (pid < 0) {
		601	perror("swindle autostart: fork");
		602	return;
		603	}
		604	if (pid != 0)
		605	return; /* compositor continues (sequencer runs in child) */
		606
		607	/* The sequencer child resets any inherited signal handlers and becomes
		608	* a new session so the compositor's SIGCHLD handling doesn't
		609	* interfere with our waitpid calls. */
		610	signal(SIGCHLD, SIG_DFL);
		611	setsid();
		612
		613	for (int i = 0; i < cfg->nautostart; i++) {
		614	const char *cmd = cfg->autostart[i].cmd;
		615
		616	pid_t cpid = fork();
		617	if (cpid < 0) {
		618	fprintf(stderr, "swindle autostart: fork for '%s': %s\n",
		619	cmd, strerror(errno));
		620	continue;
		621	}
		622	if (cpid == 0) {
		623	execl("/bin/sh", "sh", "-c", cmd, NULL);
		624	fprintf(stderr, "swindle autostart: exec '%s': %s\n",
		625	cmd, strerror(errno));
		626	_exit(1);
		627	}
		628
		629	/* wait a second because one shotters will fly past, but
		630	* daemon processes (some, like swaybg) won't because of
		631	* daemon black magic. To say the least, it's good for the soul */
		632	struct timespec deadline, now;
		633	clock_gettime(CLOCK_MONOTONIC, &deadline);
		634	deadline.tv_sec += 0.5;
		635
		636	int status;
		637	int done = 0;
		638	while (!done) {
		639	pid_t r = waitpid(cpid, &status, WNOHANG);
		640	if (r == cpid) {
		641	done = 1;
		642	if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
		643	fprintf(stderr, "swindle autostart: '%s' exited with status %d\n",
		644	cmd, WEXITSTATUS(status));
		645	} else {
		646	clock_gettime(CLOCK_MONOTONIC, &now);
		647	if (now.tv_sec > deadline.tv_sec \|\|
		648	(now.tv_sec == deadline.tv_sec &&
		649	now.tv_nsec >= deadline.tv_nsec))
		650	break; /* looks like a daemon, move on */
		651	struct timespec sl = { .tv_sec = 0, .tv_nsec = 50 * 1000 * 1000 };
		652	nanosleep(&sl, NULL);
		653	}
		654	}
		655	}
		656
		657	_exit(0);
		658	}
		659
		660	/* inotify watcher */
		661
		662	static int
		663	watch_dispatch(int fd, uint32_t mask, void *data)
		664	{
		665	WatchState *ws = data;
		666
		667	/* Drain the inotify events */
		668	_Alignas(struct inotify_event) char buf[4096];
		669	ssize_t len = read(fd, buf, sizeof(buf));
		670	if (len < 0) {
		671	if (errno != EAGAIN)
		672	perror("swindle config: inotify read");
		673	return 0;
		674	}
		675
		676	/* Re-parse */
		677	Config *fresh = calloc(1, sizeof(Config));
		678	if (!fresh) return 0;
		679
		680	if (config_load(ws->path, fresh) == 0) {
		681	fprintf(stderr, "swindle config: reloaded '%s'\n", ws->path);
		682	if (ws->cb)
		683	ws->cb(fresh, ws->userdata);
		684	} else {
		685	fprintf(stderr, "swindle config: reload failed, keeping old config. "
		686	"Story of my life.\n");
		687	}
		688
		689	free(fresh);
		690
		691	/*
		692	* Some editors (vim, nano) delete-and-recreate files on save,
		693	* which removes our watch (which is a pain in the ass.
		694	* Hence, re-add it defensively. It's good for the soul)
		695	*/
		696	inotify_rm_watch(ws->inotify_fd, ws->watch_fd);
		697	ws->watch_fd = inotify_add_watch(ws->inotify_fd, ws->path,
		698	IN_CLOSE_WRITE \| IN_MOVED_TO \| IN_CREATE);
		699
		700	return 0;
		701	}
		702
		703	struct wl_event_source *
		704	config_watch_start(struct wl_event_loop loop, const char path,
		705	config_reload_cb cb, void *userdata)
		706	{
		707	WatchState ws = calloc(1, sizeof(ws));
		708	if (!ws) return NULL;
		709
		710	ws->inotify_fd = inotify_init1(IN_NONBLOCK \| IN_CLOEXEC);
		711	if (ws->inotify_fd < 0) {
		712	perror("swindle config: inotify_init1");
		713	free(ws);
		714	return NULL;
		715	}
		716
		717	ws->watch_fd = inotify_add_watch(ws->inotify_fd, path,
		718	IN_CLOSE_WRITE \| IN_MOVED_TO \| IN_CREATE);
		719	if (ws->watch_fd < 0) {
		720	perror("swindle config: inotify_add_watch");
		721	close(ws->inotify_fd);
		722	free(ws);
		723	return NULL;
		724	}
		725
		726	strncpy(ws->path, path, sizeof(ws->path) - 1);
		727	ws->cb = cb;
		728	ws->userdata = userdata;
		729
		730	struct wl_event_source *src = wl_event_loop_add_fd(
		731	loop, ws->inotify_fd,
		732	WL_EVENT_READABLE,
		733	watch_dispatch, ws
		734	);
		735
		736	if (!src) {
		737	fprintf(stderr, "swindle config: failed to add inotify to event loop. "
		738	"Classic.\n");
		739	close(ws->inotify_fd);
		740	free(ws);
		741	return NULL;
		742	}
		743
		744	ws->event_src = src;
		745	fprintf(stderr, "swindle config: watching '%s'\n", path);
		746	return (struct wl_event_source *)ws;
		747	}
		748
		749	void
		750	config_watch_stop(struct wl_event_source *src)
		751	{
		752	if (!src) return;
		753	WatchState ws = (WatchState )src;
		754	wl_event_source_remove(ws->event_src);
		755	close(ws->inotify_fd);
		756	free(ws);
		757	}

parser/parser.h

0 created 644 +160 0

@@ -0,0 +1,160
	1	#ifndef SWINDLE_PARSER_H
	2	#define SWINDLE_PARSER_H
	3
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include <wayland-server-core.h>
	7
	8	/* Maximum lengths. Good for the soul, they say */
	9	#define CFG_MAX_RULES 64
	10	#define CFG_MAX_MONITORS 16
	11	#define CFG_MAX_KEYBINDS 256
	12	#define CFG_MAX_ARGS 16
	13	#define CFG_MAX_STRLEN 256
	14	#define CFG_MAX_AUTOSTART 32
	15	#define CFG_MAX_AUTOSTART_CMD 512
	16
	17	/* Appearance */
	18
	19	typedef struct {
	20	unsigned int inner_border_px;
	21	unsigned int outer_border_px;
	22	unsigned int gaps;
	23	bool smart_gaps;
	24	float inner_border_color[4];
	25	float outer_border_color[4];
	26	float inner_focus_color[4];
	27	float outer_focus_color[4];
	28	float inner_urgent_color[4];
	29	float outer_urgent_color[4];
	30	float root_color[4];
	31	float fullscreen_bg[4];
	32	float active_opacity;
	33	float inactive_opacity;
	34	} CfgAppearance;
	35
	36	/* Input */
	37
	38	typedef struct {
	39	int repeat_rate;
	40	int repeat_delay;
	41	bool tap_to_click;
	42	bool tap_and_drag;
	43	bool drag_lock;
	44	bool natural_scrolling;
	45	bool disable_while_typing;
	46	bool left_handed;
	47	bool middle_button_emulation;
	48	int scroll_method; /* libinput enum value */
	49	int click_method; /* libinput enum value */
	50	int send_events_mode;
	51	int accel_profile; /* libinput enum value */
	52	double accel_speed;
	53	int tap_button_map; /* libinput enum value */
	54	char layout[CFG_MAX_STRLEN]; /* "us", "de", "de,us", ... */
	55	char variant[CFG_MAX_STRLEN]; /* "nodeadkeys", "colemak", ... */
	56	char model[CFG_MAX_STRLEN]; /* "pc105", ... */
	57	char options[CFG_MAX_STRLEN]; /* "grp:alt_shift_toggle", ... */
	58	} CfgInput;
	59
	60	/* Window Rules */
	61
	62	typedef struct {
	63	char app_id[CFG_MAX_STRLEN];
	64	char title[CFG_MAX_STRLEN]; /* empty string = wildcard */
	65	uint32_t tags;
	66	bool floating;
	67	int monitor; /* -1 = current */
	68	} CfgRule;
	69
	70	/* Monitor Rules */
	71
	72	typedef struct {
	73	char name[CFG_MAX_STRLEN]; /* empty = catch-all */
	74	float mfact;
	75	int nmaster;
	76	float scale;
	77	char layout[CFG_MAX_STRLEN]; /* "dwindle", "floating", etc. */
	78	int transform; /* WL_OUTPUT_TRANSFORM_* */
	79	int x, y; /* -1,-1 = autoconfigure */
	80	} CfgMonitorRule;
	81
	82	/* keybinds */
	83
	84	typedef struct {
	85	uint32_t mods; /* WLR_MODIFIER_* bitmask */
	86	uint32_t key; /* XKB keysym */
	87	char action[CFG_MAX_STRLEN]; /* "spawn", "killclient", etc. */
	88	char args[CFG_MAX_ARGS][CFG_MAX_STRLEN];
	89	int nargs;
	90	} CfgKeybind;
	91
	92	/* mouse buttons */
	93
	94	typedef struct {
	95	uint32_t mods;
	96	uint32_t button;
	97	char action[CFG_MAX_STRLEN];
	98	char args[CFG_MAX_ARGS][CFG_MAX_STRLEN];
	99	int nargs;
	100	} CfgButton;
	101
	102	/* Autostart */
	103
	104	typedef struct {
	105	char cmd[CFG_MAX_AUTOSTART_CMD];
	106	} CfgAutostart;
	107
	108	/* the whole shebang */
	109
	110	typedef struct {
	111	CfgAppearance appearance;
	112
	113	CfgInput input;
	114
	115	CfgRule rules[CFG_MAX_RULES];
	116	int nrules;
	117
	118	CfgMonitorRule monitors[CFG_MAX_MONITORS];
	119	int nmonitors;
	120
	121	CfgKeybind keybinds[CFG_MAX_KEYBINDS];
	122	int nkeybinds;
	123
	124	CfgButton buttons[CFG_MAX_KEYBINDS];
	125	int nbuttons;
	126
	127	bool sloppyfocus;
	128	bool bypass_surface_visibility;
	129	int log_level; /* WLR_* log level */
	130
	131	CfgAutostart autostart[CFG_MAX_AUTOSTART];
	132	int nautostart;
	133	} Config;
	134
	135	/* Public API */
	136
	137	int config_load(const char path, Config cfg);
	138
	139	char config_get_path(char buf, size_t bufsz);
	140
	141	void config_apply_appearance(const Config *cfg);
	142
	143	void config_apply_input(const Config *cfg);
	144
	145	void config_apply_keybinds(const Config *cfg);
	146
	147	void config_autostart_run(const Config *cfg);
	148
	149	typedef void (config_reload_cb)(const Config cfg, void *userdata);
	150
	151	struct wl_event_source *config_watch_start(
	152	struct wl_event_loop *loop,
	153	const char *path,
	154	config_reload_cb cb,
	155	void *userdata
	156	);
	157
	158	void config_watch_stop(struct wl_event_source *src);
	159
	160	#endif

protocols/dwl-ipc-unstable-v2.xml

0 created 644 +184 0

@@ -0,0 +1,184
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<protocol name="dwl_ipc_unstable_v2">
	3	<copyright>
	4	Copyright (C) 2022 Russell Newcomb
	5
	6	Permission is hereby granted, free of charge, to any person obtaining a
	7	copy of this software and associated documentation files (the "Software"),
	8	to deal in the Software without restriction, including without limitation
	9	the rights to use, copy, modify, merge, publish, distribute, sublicense,
	10	and/or sell copies of the Software, and to permit persons to whom the
	11	Software is furnished to do so, subject to the following conditions:
	12
	13	The above copyright notice and this permission notice (including the next
	14	paragraph) shall be included in all copies or substantial portions of the
	15	Software.
	16
	17	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	18	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	19	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	20	THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	21	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	22	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	23	DEALINGS IN THE SOFTWARE.
	24	</copyright>
	25
	26	<interface name="zdwl_ipc_manager_v2" version="2">
	27	<description summary="manage dwl state">
	28	This interface is exposed as a global in the Wayland registry and allows
	29	clients to query and set dwl state.
	30
	31	Warning! The protocol described in this file is experimental and
	32	backward incompatible changes may be made. Backward compatible changes
	33	may be added together with the corresponding interface version bump.
	34	Backward incompatible changes are done by bumping the version number in
	35	the protocol and interface names and resetting the interface version.
	36	Once the protocol is to be declared stable, the 'z' prefix and the
	37	version number in the protocol and interface names are removed and the
	38	interface version is reset.
	39	</description>
	40
	41	<request name="release" type="destructor">
	42	<description summary="release dwl_ipc_manager">
	43	Indicates that the client will not use the manager object anymore.
	44	Objects created through this interface remain valid.
	45	</description>
	46	</request>
	47
	48	<request name="get_output">
	49	<description summary="get a dwl_ipc_output for a wl_output">
	50	Get a dwl_ipc_output for the given wl_output.
	51	</description>
	52	<arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
	53	<arg name="output" type="object" interface="wl_output"/>
	54	</request>
	55
	56	<event name="tags">
	57	<description summary="announces number of tags">
	58	This event is sent after binding and announces the number of tags.
	59	</description>
	60	<arg name="amount" type="uint"/>
	61	</event>
	62
	63	<event name="layout">
	64	<description summary="announces a layout">
	65	This event is sent after binding and announces a layout.
	66	Layouts are announced in order.
	67	</description>
	68	<arg name="name" type="string"/>
	69	</event>
	70	</interface>
	71
	72	<interface name="zdwl_ipc_output_v2" version="2">
	73	<description summary="interact with dwl output state">
	74	Observe and control a dwl output.
	75	</description>
	76
	77	<enum name="tag_state">
	78	<entry name="none" value="0" summary="no state"/>
	79	<entry name="active" value="1" summary="tag is active"/>
	80	<entry name="urgent" value="2" summary="tag has urgent client"/>
	81	</enum>
	82
	83	<request name="release" type="destructor">
	84	<description summary="release dwl_ipc_output">
	85	Indicates that the client will not use the dwl_ipc_output object
	86	anymore. Objects created through this interface remain valid.
	87	</description>
	88	</request>
	89
	90	<request name="set_tags">
	91	<description summary="set the active tags of this output">
	92	set the active tags of this output.
	93	</description>
	94	<arg name="tagmask" type="uint" summary="bitmask of the tags that should be set"/>
	95	<arg name="toggle_tagset" type="uint" summary="whether to toggle the tagset"/>
	96	</request>
	97
	98	<request name="set_client_tags">
	99	<description summary="set the tags of the focused client">
	100	Set the tags of the focused client.
	101	</description>
	102	<arg name="and_tags" type="uint"/>
	103	<arg name="xor_tags" type="uint"/>
	104	</request>
	105
	106	<request name="set_layout">
	107	<description summary="set the layout of this output">
	108	Set the layout of this output.
	109	</description>
	110	<arg name="index" type="uint"/>
	111	</request>
	112
	113	<event name="toggle_visibility">
	114	<description summary="dwl visibility has been toggled">
	115	Indicates that dwl visibility has been toggled.
	116	</description>
	117	</event>
	118
	119	<event name="active">
	120	<description summary="output is active">
	121	Indicates the output is active (selected monitor).
	122	</description>
	123	<arg name="active" type="uint"/>
	124	</event>
	125
	126	<event name="tag">
	127	<description summary="tag state changed">
	128	Indicates a tag state change.
	129	</description>
	130	<arg name="tag" type="uint" summary="index of the tag"/>
	131	<arg name="state" type="uint" enum="tag_state" summary="state of the tag"/>
	132	<arg name="clients" type="uint" summary="number of clients in tag"/>
	133	<arg name="focused" type="uint" summary="1 if focused client is in this tag"/>
	134	</event>
	135
	136	<event name="layout">
	137	<description summary="layout changed">
	138	Indicates the layout changed.
	139	</description>
	140	<arg name="layout" type="uint" summary="index of the layout"/>
	141	</event>
	142
	143	<event name="title">
	144	<description summary="title changed">
	145	Indicates the focused client title changed.
	146	</description>
	147	<arg name="title" type="string"/>
	148	</event>
	149
	150	<event name="appid">
	151	<description summary="appid changed">
	152	Indicates the focused client appid changed.
	153	</description>
	154	<arg name="appid" type="string"/>
	155	</event>
	156
	157	<event name="layout_symbol">
	158	<description summary="layout symbol changed">
	159	Indicates the layout symbol changed.
	160	</description>
	161	<arg name="layout" type="string"/>
	162	</event>
	163
	164	<event name="frame">
	165	<description summary="frame event">
	166	Sent after all state events have been sent for a given state change.
	167	</description>
	168	</event>
	169
	170	<event name="fullscreen" since="2">
	171	<description summary="fullscreen state changed">
	172	Indicates the fullscreen state changed.
	173	</description>
	174	<arg name="is_fullscreen" type="uint"/>
	175	</event>
	176
	177	<event name="floating" since="2">
	178	<description summary="floating state changed">
	179	Indicates the floating state changed.
	180	</description>
	181	<arg name="is_floating" type="uint"/>
	182	</event>
	183	</interface>
	184	</protocol>

protocols/ext-workspace-v1.xml

0 created 644 +422 0

@@ -0,0 +1,422
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<protocol name="ext_workspace_v1">
	3	<copyright>
	4	Copyright © 2019 Christopher Billington
	5	Copyright © 2020 Ilia Bozhinov
	6	Copyright © 2022 Victoria Brekenfeld
	7
	8	Permission to use, copy, modify, distribute, and sell this
	9	software and its documentation for any purpose is hereby granted
	10	without fee, provided that the above copyright notice appear in
	11	all copies and that both that copyright notice and this permission
	12	notice appear in supporting documentation, and that the name of
	13	the copyright holders not be used in advertising or publicity
	14	pertaining to distribution of the software without specific,
	15	written prior permission. The copyright holders make no
	16	representations about the suitability of this software for any
	17	purpose. It is provided "as is" without express or implied
	18	warranty.
	19
	20	THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
	21	SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	22	FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
	23	SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	24	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
	25	AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
	26	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
	27	THIS SOFTWARE.
	28	</copyright>
	29
	30	<interface name="ext_workspace_manager_v1" version="1">
	31	<description summary="list and control workspaces">
	32	Workspaces, also called virtual desktops, are groups of surfaces. A
	33	compositor with a concept of workspaces may only show some such groups of
	34	surfaces (those of 'active' workspaces) at a time. 'Activating' a
	35	workspace is a request for the compositor to display that workspace's
	36	surfaces as normal, whereas the compositor may hide or otherwise
	37	de-emphasise surfaces that are associated only with 'inactive' workspaces.
	38	Workspaces are grouped by which sets of outputs they correspond to, and
	39	may contain surfaces only from those outputs. In this way, it is possible
	40	for each output to have its own set of workspaces, or for all outputs (or
	41	any other arbitrary grouping) to share workspaces. Compositors may
	42	optionally conceptually arrange each group of workspaces in an
	43	N-dimensional grid.
	44
	45	The purpose of this protocol is to enable the creation of taskbars and
	46	docks by providing them with a list of workspaces and their properties,
	47	and allowing them to activate and deactivate workspaces.
	48
	49	After a client binds the ext_workspace_manager_v1, each workspace will be
	50	sent via the workspace event.
	51	</description>
	52
	53	<event name="workspace_group">
	54	<description summary="a workspace group has been created">
	55	This event is emitted whenever a new workspace group has been created.
	56
	57	All initial details of the workspace group (outputs) will be
	58	sent immediately after this event via the corresponding events in
	59	ext_workspace_group_handle_v1 and ext_workspace_handle_v1.
	60	</description>
	61	<arg name="workspace_group" type="new_id" interface="ext_workspace_group_handle_v1"/>
	62	</event>
	63
	64	<event name="workspace">
	65	<description summary="workspace has been created">
	66	This event is emitted whenever a new workspace has been created.
	67
	68	All initial details of the workspace (name, coordinates, state) will
	69	be sent immediately after this event via the corresponding events in
	70	ext_workspace_handle_v1.
	71
	72	Workspaces start off unassigned to any workspace group.
	73	</description>
	74	<arg name="workspace" type="new_id" interface="ext_workspace_handle_v1"/>
	75	</event>
	76
	77	<request name="commit">
	78	<description summary="all requests about the workspaces have been sent">
	79	The client must send this request after it has finished sending other
	80	requests. The compositor must process a series of requests preceding a
	81	commit request atomically.
	82
	83	This allows changes to the workspace properties to be seen as atomic,
	84	even if they happen via multiple events, and even if they involve
	85	multiple ext_workspace_handle_v1 objects, for example, deactivating one
	86	workspace and activating another.
	87	</description>
	88	</request>
	89
	90	<event name="done">
	91	<description summary="all information about the workspaces and workspace groups has been sent">
	92	This event is sent after all changes in all workspaces and workspace groups have been
	93	sent.
	94
	95	This allows changes to one or more ext_workspace_group_handle_v1
	96	properties and ext_workspace_handle_v1 properties
	97	to be seen as atomic, even if they happen via multiple events.
	98	In particular, an output moving from one workspace group to
	99	another sends an output_enter event and an output_leave event to the two
	100	ext_workspace_group_handle_v1 objects in question. The compositor sends
	101	the done event only after updating the output information in both
	102	workspace groups.
	103	</description>
	104	</event>
	105
	106	<event name="finished" type="destructor">
	107	<description summary="the compositor has finished with the workspace_manager">
	108	This event indicates that the compositor is done sending events to the
	109	ext_workspace_manager_v1. The server will destroy the object
	110	immediately after sending this request.
	111	</description>
	112	</event>
	113
	114	<request name="stop">
	115	<description summary="stop sending events">
	116	Indicates the client no longer wishes to receive events for new
	117	workspace groups. However the compositor may emit further workspace
	118	events, until the finished event is emitted. The compositor is expected
	119	to send the finished event eventually once the stop request has been processed.
	120
	121	The client must not send any requests after this one, doing so will raise a wl_display
	122	invalid_object error.
	123	</description>
	124	</request>
	125
	126	</interface>
	127
	128	<interface name="ext_workspace_group_handle_v1" version="1">
	129	<description summary="a workspace group assigned to a set of outputs">
	130	A ext_workspace_group_handle_v1 object represents a workspace group
	131	that is assigned a set of outputs and contains a number of workspaces.
	132
	133	The set of outputs assigned to the workspace group is conveyed to the client via
	134	output_enter and output_leave events, and its workspaces are conveyed with
	135	workspace events.
	136
	137	For example, a compositor which has a set of workspaces for each output may
	138	advertise a workspace group (and its workspaces) per output, whereas a compositor
	139	where a workspace spans all outputs may advertise a single workspace group for all
	140	outputs.
	141	</description>
	142
	143	<enum name="group_capabilities" bitfield="true">
	144	<entry name="create_workspace" value="1" summary="create_workspace request is available"/>
	145	</enum>
	146
	147	<event name="capabilities">
	148	<description summary="compositor capabilities">
	149	This event advertises the capabilities supported by the compositor. If
	150	a capability isn't supported, clients should hide or disable the UI
	151	elements that expose this functionality. For instance, if the
	152	compositor doesn't advertise support for creating workspaces, a button
	153	triggering the create_workspace request should not be displayed.
	154
	155	The compositor will ignore requests it doesn't support. For instance,
	156	a compositor which doesn't advertise support for creating workspaces will ignore
	157	create_workspace requests.
	158
	159	Compositors must send this event once after creation of an
	160	ext_workspace_group_handle_v1. When the capabilities change, compositors
	161	must send this event again.
	162	</description>
	163	<arg name="capabilities" type="uint" summary="capabilities" enum="group_capabilities"/>
	164	</event>
	165
	166	<event name="output_enter">
	167	<description summary="output assigned to workspace group">
	168	This event is emitted whenever an output is assigned to the workspace
	169	group or a new `wl_output` object is bound by the client, which was already
	170	assigned to this workspace_group.
	171	</description>
	172	<arg name="output" type="object" interface="wl_output"/>
	173	</event>
	174
	175	<event name="output_leave">
	176	<description summary="output removed from workspace group">
	177	This event is emitted whenever an output is removed from the workspace
	178	group.
	179	</description>
	180	<arg name="output" type="object" interface="wl_output"/>
	181	</event>
	182
	183	<event name="workspace_enter">
	184	<description summary="workspace added to workspace group">
	185	This event is emitted whenever a workspace is assigned to this group.
	186	A workspace may only ever be assigned to a single group at a single point
	187	in time, but can be re-assigned during its lifetime.
	188	</description>
	189	<arg name="workspace" type="object" interface="ext_workspace_handle_v1"/>
	190	</event>
	191
	192	<event name="workspace_leave">
	193	<description summary="workspace removed from workspace group">
	194	This event is emitted whenever a workspace is removed from this group.
	195	</description>
	196	<arg name="workspace" type="object" interface="ext_workspace_handle_v1"/>
	197	</event>
	198
	199	<event name="removed">
	200	<description summary="this workspace group has been removed">
	201	This event is send when the group associated with the ext_workspace_group_handle_v1
	202	has been removed. After sending this request the compositor will immediately consider
	203	the object inert. Any requests will be ignored except the destroy request.
	204	It is guaranteed there won't be any more events referencing this
	205	ext_workspace_group_handle_v1.
	206
	207	The compositor must remove all workspaces belonging to a workspace group
	208	via a workspace_leave event before removing the workspace group.
	209	</description>
	210	</event>
	211
	212	<request name="create_workspace">
	213	<description summary="create a new workspace">
	214	Request that the compositor create a new workspace with the given name
	215	and assign it to this group.
	216
	217	There is no guarantee that the compositor will create a new workspace,
	218	or that the created workspace will have the provided name.
	219	</description>
	220	<arg name="workspace" type="string"/>
	221	</request>
	222
	223	<request name="destroy" type="destructor">
	224	<description summary="destroy the ext_workspace_group_handle_v1 object">
	225	Destroys the ext_workspace_group_handle_v1 object.
	226
	227	This request should be send either when the client does not want to
	228	use the workspace group object any more or after the removed event to finalize
	229	the destruction of the object.
	230	</description>
	231	</request>
	232	</interface>
	233
	234	<interface name="ext_workspace_handle_v1" version="1">
	235	<description summary="a workspace handing a group of surfaces">
	236	A ext_workspace_handle_v1 object represents a workspace that handles a
	237	group of surfaces.
	238
	239	Each workspace has:
	240	- a name, conveyed to the client with the name event
	241	- potentially an id conveyed with the id event
	242	- a list of states, conveyed to the client with the state event
	243	- and optionally a set of coordinates, conveyed to the client with the
	244	coordinates event
	245
	246	The client may request that the compositor activate or deactivate the workspace.
	247
	248	Each workspace can belong to only a single workspace group.
	249	Depending on the compositor policy, there might be workspaces with
	250	the same name in different workspace groups, but these workspaces are still
	251	separate (e.g. one of them might be active while the other is not).
	252	</description>
	253
	254	<event name="id">
	255	<description summary="workspace id">
	256	If this event is emitted, it will be send immediately after the
	257	ext_workspace_handle_v1 is created or when an id is assigned to
	258	a workspace (at most once during its lifetime).
	259
	260	An id will never change during the lifetime of the `ext_workspace_handle_v1`
	261	and is guaranteed to be unique during its lifetime.
	262
	263	Ids are not human-readable and shouldn't be displayed, use `name` for that purpose.
	264
	265	Compositors are expected to only send ids for workspaces likely stable across multiple
	266	sessions and can be used by clients to store preferences for workspaces. Workspaces without
	267	ids should be considered temporary and any data associated with them should be deleted once
	268	the respective object is lost.
	269	</description>
	270	<arg name="id" type="string"/>
	271	</event>
	272
	273	<event name="name">
	274	<description summary="workspace name changed">
	275	This event is emitted immediately after the ext_workspace_handle_v1 is
	276	created and whenever the name of the workspace changes.
	277
	278	A name is meant to be human-readable and can be displayed to a user.
	279	Unlike the id it is neither stable nor unique.
	280	</description>
	281	<arg name="name" type="string"/>
	282	</event>
	283
	284	<event name="coordinates">
	285	<description summary="workspace coordinates changed">
	286	This event is used to organize workspaces into an N-dimensional grid
	287	within a workspace group, and if supported, is emitted immediately after
	288	the ext_workspace_handle_v1 is created and whenever the coordinates of
	289	the workspace change. Compositors may not send this event if they do not
	290	conceptually arrange workspaces in this way. If compositors simply
	291	number workspaces, without any geometric interpretation, they may send
	292	1D coordinates, which clients should not interpret as implying any
	293	geometry. Sending an empty array means that the compositor no longer
	294	orders the workspace geometrically.
	295
	296	Coordinates have an arbitrary number of dimensions N with an uint32
	297	position along each dimension. By convention if N > 1, the first
	298	dimension is X, the second Y, the third Z, and so on. The compositor may
	299	chose to utilize these events for a more novel workspace layout
	300	convention, however. No guarantee is made about the grid being filled or
	301	bounded; there may be a workspace at coordinate 1 and another at
	302	coordinate 1000 and none in between. Within a workspace group, however,
	303	workspaces must have unique coordinates of equal dimensionality.
	304	</description>
	305	<arg name="coordinates" type="array"/>
	306	</event>
	307
	308	<enum name="state" bitfield="true">
	309	<description summary="types of states on the workspace">
	310	The different states that a workspace can have.
	311	</description>
	312
	313	<entry name="active" value="1" summary="the workspace is active"/>
	314	<entry name="urgent" value="2" summary="the workspace requests attention"/>
	315	<entry name="hidden" value="4">
	316	<description summary="the workspace is not visible">
	317	The workspace is not visible in its workspace group, and clients
	318	attempting to visualize the compositor workspace state should not
	319	display such workspaces.
	320	</description>
	321	</entry>
	322	</enum>
	323
	324	<event name="state">
	325	<description summary="the state of the workspace changed">
	326	This event is emitted immediately after the ext_workspace_handle_v1 is
	327	created and each time the workspace state changes, either because of a
	328	compositor action or because of a request in this protocol.
	329
	330	Missing states convey the opposite meaning, e.g. an unset active bit
	331	means the workspace is currently inactive.
	332	</description>
	333	<arg name="state" type="uint" enum="state"/>
	334	</event>
	335
	336	<enum name="workspace_capabilities" bitfield="true">
	337	<entry name="activate" value="1" summary="activate request is available"/>
	338	<entry name="deactivate" value="2" summary="deactivate request is available"/>
	339	<entry name="remove" value="4" summary="remove request is available"/>
	340	<entry name="assign" value="8" summary="assign request is available"/>
	341	</enum>
	342
	343	<event name="capabilities">
	344	<description summary="compositor capabilities">
	345	This event advertises the capabilities supported by the compositor. If
	346	a capability isn't supported, clients should hide or disable the UI
	347	elements that expose this functionality. For instance, if the
	348	compositor doesn't advertise support for removing workspaces, a button
	349	triggering the remove request should not be displayed.
	350
	351	The compositor will ignore requests it doesn't support. For instance,
	352	a compositor which doesn't advertise support for remove will ignore
	353	remove requests.
	354
	355	Compositors must send this event once after creation of an
	356	ext_workspace_handle_v1 . When the capabilities change, compositors
	357	must send this event again.
	358	</description>
	359	<arg name="capabilities" type="uint" summary="capabilities" enum="workspace_capabilities"/>
	360	</event>
	361
	362	<event name="removed">
	363	<description summary="this workspace has been removed">
	364	This event is send when the workspace associated with the ext_workspace_handle_v1
	365	has been removed. After sending this request, the compositor will immediately consider
	366	the object inert. Any requests will be ignored except the destroy request.
	367
	368	It is guaranteed there won't be any more events referencing this
	369	ext_workspace_handle_v1.
	370
	371	The compositor must only remove a workspaces not currently belonging to any
	372	workspace_group.
	373	</description>
	374	</event>
	375
	376	<request name="destroy" type="destructor">
	377	<description summary="destroy the ext_workspace_handle_v1 object">
	378	Destroys the ext_workspace_handle_v1 object.
	379
	380	This request should be made either when the client does not want to
	381	use the workspace object any more or after the remove event to finalize
	382	the destruction of the object.
	383	</description>
	384	</request>
	385
	386	<request name="activate">
	387	<description summary="activate the workspace">
	388	Request that this workspace be activated.
	389
	390	There is no guarantee the workspace will be actually activated, and
	391	behaviour may be compositor-dependent. For example, activating a
	392	workspace may or may not deactivate all other workspaces in the same
	393	group.
	394	</description>
	395	</request>
	396
	397	<request name="deactivate">
	398	<description summary="deactivate the workspace">
	399	Request that this workspace be deactivated.
	400
	401	There is no guarantee the workspace will be actually deactivated.
	402	</description>
	403	</request>
	404
	405	<request name="assign">
	406	<description summary="assign workspace to group">
	407	Requests that this workspace is assigned to the given workspace group.
	408
	409	There is no guarantee the workspace will be assigned.
	410	</description>
	411	<arg name="workspace_group" type="object" interface="ext_workspace_group_handle_v1"/>
	412	</request>
	413
	414	<request name="remove">
	415	<description summary="remove the workspace">
	416	Request that this workspace be removed.
	417
	418	There is no guarantee the workspace will be actually removed.
	419	</description>
	420	</request>
	421	</interface>
	422	</protocol>

protocols/wlr-layer-shell-unstable-v1.xml

0 created 644 +390 0

@@ -0,0 +1,390
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<protocol name="wlr_layer_shell_unstable_v1">
	3	<copyright>
	4	Copyright © 2017 Drew DeVault
	5
	6	Permission to use, copy, modify, distribute, and sell this
	7	software and its documentation for any purpose is hereby granted
	8	without fee, provided that the above copyright notice appear in
	9	all copies and that both that copyright notice and this permission
	10	notice appear in supporting documentation, and that the name of
	11	the copyright holders not be used in advertising or publicity
	12	pertaining to distribution of the software without specific,
	13	written prior permission. The copyright holders make no
	14	representations about the suitability of this software for any
	15	purpose. It is provided "as is" without express or implied
	16	warranty.
	17
	18	THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
	19	SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	20	FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
	21	SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	22	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
	23	AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
	24	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
	25	THIS SOFTWARE.
	26	</copyright>
	27
	28	<interface name="zwlr_layer_shell_v1" version="4">
	29	<description summary="create surfaces that are layers of the desktop">
	30	Clients can use this interface to assign the surface_layer role to
	31	wl_surfaces. Such surfaces are assigned to a "layer" of the output and
	32	rendered with a defined z-depth respective to each other. They may also be
	33	anchored to the edges and corners of a screen and specify input handling
	34	semantics. This interface should be suitable for the implementation of
	35	many desktop shell components, and a broad number of other applications
	36	that interact with the desktop.
	37	</description>
	38
	39	<request name="get_layer_surface">
	40	<description summary="create a layer_surface from a surface">
	41	Create a layer surface for an existing surface. This assigns the role of
	42	layer_surface, or raises a protocol error if another role is already
	43	assigned.
	44
	45	Creating a layer surface from a wl_surface which has a buffer attached
	46	or committed is a client error, and any attempts by a client to attach
	47	or manipulate a buffer prior to the first layer_surface.configure call
	48	must also be treated as errors.
	49
	50	After creating a layer_surface object and setting it up, the client
	51	must perform an initial commit without any buffer attached.
	52	The compositor will reply with a layer_surface.configure event.
	53	The client must acknowledge it and is then allowed to attach a buffer
	54	to map the surface.
	55
	56	You may pass NULL for output to allow the compositor to decide which
	57	output to use. Generally this will be the one that the user most
	58	recently interacted with.
	59
	60	Clients can specify a namespace that defines the purpose of the layer
	61	surface.
	62	</description>
	63	<arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
	64	<arg name="surface" type="object" interface="wl_surface"/>
	65	<arg name="output" type="object" interface="wl_output" allow-null="true"/>
	66	<arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
	67	<arg name="namespace" type="string" summary="namespace for the layer surface"/>
	68	</request>
	69
	70	<enum name="error">
	71	<entry name="role" value="0" summary="wl_surface has another role"/>
	72	<entry name="invalid_layer" value="1" summary="layer value is invalid"/>
	73	<entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
	74	</enum>
	75
	76	<enum name="layer">
	77	<description summary="available layers for surfaces">
	78	These values indicate which layers a surface can be rendered in. They
	79	are ordered by z depth, bottom-most first. Traditional shell surfaces
	80	will typically be rendered between the bottom and top layers.
	81	Fullscreen shell surfaces are typically rendered at the top layer.
	82	Multiple surfaces can share a single layer, and ordering within a
	83	single layer is undefined.
	84	</description>
	85
	86	<entry name="background" value="0"/>
	87	<entry name="bottom" value="1"/>
	88	<entry name="top" value="2"/>
	89	<entry name="overlay" value="3"/>
	90	</enum>
	91
	92	<!-- Version 3 additions -->
	93
	94	<request name="destroy" type="destructor" since="3">
	95	<description summary="destroy the layer_shell object">
	96	This request indicates that the client will not use the layer_shell
	97	object any more. Objects that have been created through this instance
	98	are not affected.
	99	</description>
	100	</request>
	101	</interface>
	102
	103	<interface name="zwlr_layer_surface_v1" version="4">
	104	<description summary="layer metadata interface">
	105	An interface that may be implemented by a wl_surface, for surfaces that
	106	are designed to be rendered as a layer of a stacked desktop-like
	107	environment.
	108
	109	Layer surface state (layer, size, anchor, exclusive zone,
	110	margin, interactivity) is double-buffered, and will be applied at the
	111	time wl_surface.commit of the corresponding wl_surface is called.
	112
	113	Attaching a null buffer to a layer surface unmaps it.
	114
	115	Unmapping a layer_surface means that the surface cannot be shown by the
	116	compositor until it is explicitly mapped again. The layer_surface
	117	returns to the state it had right after layer_shell.get_layer_surface.
	118	The client can re-map the surface by performing a commit without any
	119	buffer attached, waiting for a configure event and handling it as usual.
	120	</description>
	121
	122	<request name="set_size">
	123	<description summary="sets the size of the surface">
	124	Sets the size of the surface in surface-local coordinates. The
	125	compositor will display the surface centered with respect to its
	126	anchors.
	127
	128	If you pass 0 for either value, the compositor will assign it and
	129	inform you of the assignment in the configure event. You must set your
	130	anchor to opposite edges in the dimensions you omit; not doing so is a
	131	protocol error. Both values are 0 by default.
	132
	133	Size is double-buffered, see wl_surface.commit.
	134	</description>
	135	<arg name="width" type="uint"/>
	136	<arg name="height" type="uint"/>
	137	</request>
	138
	139	<request name="set_anchor">
	140	<description summary="configures the anchor point of the surface">
	141	Requests that the compositor anchor the surface to the specified edges
	142	and corners. If two orthogonal edges are specified (e.g. 'top' and
	143	'left'), then the anchor point will be the intersection of the edges
	144	(e.g. the top left corner of the output); otherwise the anchor point
	145	will be centered on that edge, or in the center if none is specified.
	146
	147	Anchor is double-buffered, see wl_surface.commit.
	148	</description>
	149	<arg name="anchor" type="uint" enum="anchor"/>
	150	</request>
	151
	152	<request name="set_exclusive_zone">
	153	<description summary="configures the exclusive geometry of this surface">
	154	Requests that the compositor avoids occluding an area with other
	155	surfaces. The compositor's use of this information is
	156	implementation-dependent - do not assume that this region will not
	157	actually be occluded.
	158
	159	A positive value is only meaningful if the surface is anchored to one
	160	edge or an edge and both perpendicular edges. If the surface is not
	161	anchored, anchored to only two perpendicular edges (a corner), anchored
	162	to only two parallel edges or anchored to all edges, a positive value
	163	will be treated the same as zero.
	164
	165	A positive zone is the distance from the edge in surface-local
	166	coordinates to consider exclusive.
	167
	168	Surfaces that do not wish to have an exclusive zone may instead specify
	169	how they should interact with surfaces that do. If set to zero, the
	170	surface indicates that it would like to be moved to avoid occluding
	171	surfaces with a positive exclusive zone. If set to -1, the surface
	172	indicates that it would not like to be moved to accommodate for other
	173	surfaces, and the compositor should extend it all the way to the edges
	174	it is anchored to.
	175
	176	For example, a panel might set its exclusive zone to 10, so that
	177	maximized shell surfaces are not shown on top of it. A notification
	178	might set its exclusive zone to 0, so that it is moved to avoid
	179	occluding the panel, but shell surfaces are shown underneath it. A
	180	wallpaper or lock screen might set their exclusive zone to -1, so that
	181	they stretch below or over the panel.
	182
	183	The default value is 0.
	184
	185	Exclusive zone is double-buffered, see wl_surface.commit.
	186	</description>
	187	<arg name="zone" type="int"/>
	188	</request>
	189
	190	<request name="set_margin">
	191	<description summary="sets a margin from the anchor point">
	192	Requests that the surface be placed some distance away from the anchor
	193	point on the output, in surface-local coordinates. Setting this value
	194	for edges you are not anchored to has no effect.
	195
	196	The exclusive zone includes the margin.
	197
	198	Margin is double-buffered, see wl_surface.commit.
	199	</description>
	200	<arg name="top" type="int"/>
	201	<arg name="right" type="int"/>
	202	<arg name="bottom" type="int"/>
	203	<arg name="left" type="int"/>
	204	</request>
	205
	206	<enum name="keyboard_interactivity">
	207	<description summary="types of keyboard interaction possible for a layer shell surface">
	208	Types of keyboard interaction possible for layer shell surfaces. The
	209	rationale for this is twofold: (1) some applications are not interested
	210	in keyboard events and not allowing them to be focused can improve the
	211	desktop experience; (2) some applications will want to take exclusive
	212	keyboard focus.
	213	</description>
	214
	215	<entry name="none" value="0">
	216	<description summary="no keyboard focus is possible">
	217	This value indicates that this surface is not interested in keyboard
	218	events and the compositor should never assign it the keyboard focus.
	219
	220	This is the default value, set for newly created layer shell surfaces.
	221
	222	This is useful for e.g. desktop widgets that display information or
	223	only have interaction with non-keyboard input devices.
	224	</description>
	225	</entry>
	226	<entry name="exclusive" value="1">
	227	<description summary="request exclusive keyboard focus">
	228	Request exclusive keyboard focus if this surface is above the shell surface layer.
	229
	230	For the top and overlay layers, the seat will always give
	231	exclusive keyboard focus to the top-most layer which has keyboard
	232	interactivity set to exclusive. If this layer contains multiple
	233	surfaces with keyboard interactivity set to exclusive, the compositor
	234	determines the one receiving keyboard events in an implementation-
	235	defined manner. In this case, no guarantee is made when this surface
	236	will receive keyboard focus (if ever).
	237
	238	For the bottom and background layers, the compositor is allowed to use
	239	normal focus semantics.
	240
	241	This setting is mainly intended for applications that need to ensure
	242	they receive all keyboard events, such as a lock screen or a password
	243	prompt.
	244	</description>
	245	</entry>
	246	<entry name="on_demand" value="2" since="4">
	247	<description summary="request regular keyboard focus semantics">
	248	This requests the compositor to allow this surface to be focused and
	249	unfocused by the user in an implementation-defined manner. The user
	250	should be able to unfocus this surface even regardless of the layer
	251	it is on.
	252
	253	Typically, the compositor will want to use its normal mechanism to
	254	manage keyboard focus between layer shell surfaces with this setting
	255	and regular toplevels on the desktop layer (e.g. click to focus).
	256	Nevertheless, it is possible for a compositor to require a special
	257	interaction to focus or unfocus layer shell surfaces (e.g. requiring
	258	a click even if focus follows the mouse normally, or providing a
	259	keybinding to switch focus between layers).
	260
	261	This setting is mainly intended for desktop shell components (e.g.
	262	panels) that allow keyboard interaction. Using this option can allow
	263	implementing a desktop shell that can be fully usable without the
	264	mouse.
	265	</description>
	266	</entry>
	267	</enum>
	268
	269	<request name="set_keyboard_interactivity">
	270	<description summary="requests keyboard events">
	271	Set how keyboard events are delivered to this surface. By default,
	272	layer shell surfaces do not receive keyboard events; this request can
	273	be used to change this.
	274
	275	This setting is inherited by child surfaces set by the get_popup
	276	request.
	277
	278	Layer surfaces receive pointer, touch, and tablet events normally. If
	279	you do not want to receive them, set the input region on your surface
	280	to an empty region.
	281
	282	Keyboard interactivity is double-buffered, see wl_surface.commit.
	283	</description>
	284	<arg name="keyboard_interactivity" type="uint" enum="keyboard_interactivity"/>
	285	</request>
	286
	287	<request name="get_popup">
	288	<description summary="assign this layer_surface as an xdg_popup parent">
	289	This assigns an xdg_popup's parent to this layer_surface. This popup
	290	should have been created via xdg_surface::get_popup with the parent set
	291	to NULL, and this request must be invoked before committing the popup's
	292	initial state.
	293
	294	See the documentation of xdg_popup for more details about what an
	295	xdg_popup is and how it is used.
	296	</description>
	297	<arg name="popup" type="object" interface="xdg_popup"/>
	298	</request>
	299
	300	<request name="ack_configure">
	301	<description summary="ack a configure event">
	302	When a configure event is received, if a client commits the
	303	surface in response to the configure event, then the client
	304	must make an ack_configure request sometime before the commit
	305	request, passing along the serial of the configure event.
	306
	307	If the client receives multiple configure events before it
	308	can respond to one, it only has to ack the last configure event.
	309
	310	A client is not required to commit immediately after sending
	311	an ack_configure request - it may even ack_configure several times
	312	before its next surface commit.
	313
	314	A client may send multiple ack_configure requests before committing, but
	315	only the last request sent before a commit indicates which configure
	316	event the client really is responding to.
	317	</description>
	318	<arg name="serial" type="uint" summary="the serial from the configure event"/>
	319	</request>
	320
	321	<request name="destroy" type="destructor">
	322	<description summary="destroy the layer_surface">
	323	This request destroys the layer surface.
	324	</description>
	325	</request>
	326
	327	<event name="configure">
	328	<description summary="suggest a surface change">
	329	The configure event asks the client to resize its surface.
	330
	331	Clients should arrange their surface for the new states, and then send
	332	an ack_configure request with the serial sent in this configure event at
	333	some point before committing the new surface.
	334
	335	The client is free to dismiss all but the last configure event it
	336	received.
	337
	338	The width and height arguments specify the size of the window in
	339	surface-local coordinates.
	340
	341	The size is a hint, in the sense that the client is free to ignore it if
	342	it doesn't resize, pick a smaller size (to satisfy aspect ratio or
	343	resize in steps of NxM pixels). If the client picks a smaller size and
	344	is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the
	345	surface will be centered on this axis.
	346
	347	If the width or height arguments are zero, it means the client should
	348	decide its own window dimension.
	349	</description>
	350	<arg name="serial" type="uint"/>
	351	<arg name="width" type="uint"/>
	352	<arg name="height" type="uint"/>
	353	</event>
	354
	355	<event name="closed">
	356	<description summary="surface should be closed">
	357	The closed event is sent by the compositor when the surface will no
	358	longer be shown. The output may have been destroyed or the user may
	359	have asked for it to be removed. Further changes to the surface will be
	360	ignored. The client should destroy the resource after receiving this
	361	event, and create a new surface if they so choose.
	362	</description>
	363	</event>
	364
	365	<enum name="error">
	366	<entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
	367	<entry name="invalid_size" value="1" summary="size is invalid"/>
	368	<entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
	369	<entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/>
	370	</enum>
	371
	372	<enum name="anchor" bitfield="true">
	373	<entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
	374	<entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
	375	<entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
	376	<entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
	377	</enum>
	378
	379	<!-- Version 2 additions -->
	380
	381	<request name="set_layer" since="2">
	382	<description summary="change the layer of the surface">
	383	Change the layer that the surface is rendered on.
	384
	385	Layer is double-buffered, see wl_surface.commit.
	386	</description>
	387	<arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
	388	</request>
	389	</interface>
	390	</protocol>

protocols/wlr-output-power-management-unstable-v1.xml

0 created 644 +128 0

@@ -0,0 +1,128
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<protocol name="wlr_output_power_management_unstable_v1">
	3	<copyright>
	4	Copyright © 2019 Purism SPC
	5
	6	Permission is hereby granted, free of charge, to any person obtaining a
	7	copy of this software and associated documentation files (the "Software"),
	8	to deal in the Software without restriction, including without limitation
	9	the rights to use, copy, modify, merge, publish, distribute, sublicense,
	10	and/or sell copies of the Software, and to permit persons to whom the
	11	Software is furnished to do so, subject to the following conditions:
	12
	13	The above copyright notice and this permission notice (including the next
	14	paragraph) shall be included in all copies or substantial portions of the
	15	Software.
	16
	17	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	18	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	19	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	20	THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	21	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	22	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	23	DEALINGS IN THE SOFTWARE.
	24	</copyright>
	25
	26	<description summary="Control power management modes of outputs">
	27	This protocol allows clients to control power management modes
	28	of outputs that are currently part of the compositor space. The
	29	intent is to allow special clients like desktop shells to power
	30	down outputs when the system is idle.
	31
	32	To modify outputs not currently part of the compositor space see
	33	wlr-output-management.
	34
	35	Warning! The protocol described in this file is experimental and
	36	backward incompatible changes may be made. Backward compatible changes
	37	may be added together with the corresponding interface version bump.
	38	Backward incompatible changes are done by bumping the version number in
	39	the protocol and interface names and resetting the interface version.
	40	Once the protocol is to be declared stable, the 'z' prefix and the
	41	version number in the protocol and interface names are removed and the
	42	interface version number is reset.
	43	</description>
	44
	45	<interface name="zwlr_output_power_manager_v1" version="1">
	46	<description summary="manager to create per-output power management">
	47	This interface is a manager that allows creating per-output power
	48	management mode controls.
	49	</description>
	50
	51	<request name="get_output_power">
	52	<description summary="get a power management for an output">
	53	Create a output power management mode control that can be used to
	54	adjust the power management mode for a given output.
	55	</description>
	56	<arg name="id" type="new_id" interface="zwlr_output_power_v1"/>
	57	<arg name="output" type="object" interface="wl_output"/>
	58	</request>
	59
	60	<request name="destroy" type="destructor">
	61	<description summary="destroy the manager">
	62	All objects created by the manager will still remain valid, until their
	63	appropriate destroy request has been called.
	64	</description>
	65	</request>
	66	</interface>
	67
	68	<interface name="zwlr_output_power_v1" version="1">
	69	<description summary="adjust power management mode for an output">
	70	This object offers requests to set the power management mode of
	71	an output.
	72	</description>
	73
	74	<enum name="mode">
	75	<entry name="off" value="0"
	76	summary="Output is turned off."/>
	77	<entry name="on" value="1"
	78	summary="Output is turned on, no power saving"/>
	79	</enum>
	80
	81	<enum name="error">
	82	<entry name="invalid_mode" value="1" summary="inexistent power save mode"/>
	83	</enum>
	84
	85	<request name="set_mode">
	86	<description summary="Set an outputs power save mode">
	87	Set an output's power save mode to the given mode. The mode change
	88	is effective immediately. If the output does not support the given
	89	mode a failed event is sent.
	90	</description>
	91	<arg name="mode" type="uint" enum="mode" summary="the power save mode to set"/>
	92	</request>
	93
	94	<event name="mode">
	95	<description summary="Report a power management mode change">
	96	Report the power management mode change of an output.
	97
	98	The mode event is sent after an output changed its power
	99	management mode. The reason can be a client using set_mode or the
	100	compositor deciding to change an output's mode.
	101	This event is also sent immediately when the object is created
	102	so the client is informed about the current power management mode.
	103	</description>
	104	<arg name="mode" type="uint" enum="mode"
	105	summary="the output's new power management mode"/>
	106	</event>
	107
	108	<event name="failed">
	109	<description summary="object no longer valid">
	110	This event indicates that the output power management mode control
	111	is no longer valid. This can happen for a number of reasons,
	112	including:
	113	- The output doesn't support power management
	114	- Another client already has exclusive power management mode control
	115	for this output
	116	- The output disappeared
	117
	118	Upon receiving this event, the client should destroy this object.
	119	</description>
	120	</event>
	121
	122	<request name="destroy" type="destructor">
	123	<description summary="destroy this power management">
	124	Destroys the output power management mode control object.
	125	</description>
	126	</request>
	127	</interface>
	128	</protocol>

smsg/README.md

0 created 644 +55 0

@@ -0,0 +1,55
	1	smsg - send ipc messages to swindle (forked from [this repository](https://codeberg.org/notchoc/dwlmsg))
	2
	3	```
	4	usage: smsg [-OTLPF]
	5	smsg [-o <output>] -s [-t <tags>] [-l <layout>] [-c <tags>]
	6	smsg [-o <output>] (-g \| -w) [-FOotlcvmf]
	7	```
	8
	9	```
	10	options:
	11	-g get
	12	-s set
	13	-w watch
	14	-O get all outputs
	15	-T get number of tags
	16	-L get all available layouts
	17	-P get compositor pid
	18	-F get focused output
	19	-o select output
	20	-t get/set selected tags (set with [+-^.], overwrite with ! prefix)
	21	-l get/set current layout
	22	-c get title and appid of focused client
	23	-v get visibility of statusbar
	24	-m get fullscreen status
	25	-f get floating status
	26	```
	27
	28	```
	29	examples:
	30	# act like dwl stdout
	31	smsg -w
	32	# watch focused client appid and title
	33	smsg -w -c
	34	# get currently focused output
	35	smsg -F
	36	# watch for focused output changes
	37	smsg -w -F
	38	# get all available outputs
	39	smsg -O
	40	# watch available outputs
	41	smsg -w -O
	42	# select tag 1, deselect tag 2, toggle tag 4 on output eDP-1
	43	smsg -o eDP-1 -s -t +-.^
	44	# toggle tag 3, overwriting current tagset (yes, zero-indexed)
	45	smsg -t !2^
	46	# select tag 8 on current output
	47	smsg -s -t 7
	48	# deselect tag 8 on current output
	49	smsg -s -t 7-
	50	# switch to first layout (order given by smsg -L)
	51	smsg -l 0
	52	# switch to floating layout
	53	smsg -l '><>'
	54	```
	55

smsg/arg.h

0 created 644 +58 0

@@ -0,0 +1,58
	1	#ifndef ARG_H__
	2	#define ARG_H__
	3
	4	extern char *argv0;
	5
	6	#define ARGBEGIN for (argv0 = *argv, argv++, argc--;\
	7	argv[0] && argv[0][0] == '-'\
	8	&& argv[0][1];\
	9	argc--, argv++) {\
	10	char argc_;\
	11	char **argv_;\
	12	int brk_;\
	13	if (argv[0][1] == '-' && argv[0][2] == '\0') {\
	14	argv++;\
	15	argc--;\
	16	break;\
	17	}\
	18	for (brk_ = 0, argv[0]++, argv_ = argv;\
	19	argv[0][0] && !brk_;\
	20	argv[0]++) {\
	21	if (argv_ != argv)\
	22	break;\
	23	argc_ = argv[0][0];\
	24	switch (argc_)
	25
	26	#define ARGNUM case '0':\
	27	case '1':\
	28	case '2':\
	29	case '3':\
	30	case '4':\
	31	case '5':\
	32	case '6':\
	33	case '7':\
	34	case '8':\
	35	case '9'
	36
	37	#define ARGEND }\
	38	}
	39
	40	#define ARGC() argc_
	41
	42	#define ARGNUMF() (brk_ = 1, estrtonum(argv[0], 0, INT_MAX))
	43
	44	#define EARGF(x) ((argv[0][1] == '\0' && argv[1] == NULL)?\
	45	((x), abort(), (char *)0) :\
	46	(brk_ = 1, (argv[0][1] != '\0')?\
	47	(&argv[0][1]) :\
	48	(argc--, argv++, argv[0])))
	49
	50	#define ARGF() ((argv[0][1] == '\0' && argv[1] == NULL)?\
	51	(char *)0 :\
	52	(brk_ = 1, (argv[0][1] != '\0')?\
	53	(&argv[0][1]) :\
	54	(argc--, argv++, argv[0])))
	55
	56	#define LNGARG() &argv[0][0]
	57
	58	#endif

smsg/protocols/dwl-ipc-unstable-v2.xml

0 created 644 +181 0

@@ -0,0 +1,181
	1	<?xml version="1.0" encoding="utf-8"?>
	2	<!--
	3	This is largely ripped from somebar's ipc patchset; just with some personal modifications.
	4	I would probably just submit raphi's patchset but I don't think that would be polite.
	5	-->
	6	<protocol name="dwl_ipc_unstable_v2">
	7	<description summary="inter-proccess-communication about dwl's state">
	8	This protocol allows clients to update and get updates from dwl.
	9
	10	Warning! The protocol described in this file is experimental and
	11	backward incompatible changes may be made. Backward compatible
	12	changes may be added together with the corresponding interface
	13	version bump.
	14	Backward incompatible changes are done by bumping the version
	15	number in the protocol and interface names and resetting the
	16	interface version. Once the protocol is to be declared stable,
	17	the 'z' prefix and the version number in the protocol and
	18	interface names are removed and the interface version number is
	19	reset.
	20	</description>
	21
	22	<interface name="zdwl_ipc_manager_v2" version="2">
	23	<description summary="manage dwl state">
	24	This interface is exposed as a global in wl_registry.
	25
	26	Clients can use this interface to get a dwl_ipc_output.
	27	After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
	28	The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
	29	</description>
	30
	31	<request name="release" type="destructor">
	32	<description summary="release dwl_ipc_manager">
	33	Indicates that the client will not the dwl_ipc_manager object anymore.
	34	Objects created through this instance are not affected.
	35	</description>
	36	</request>
	37
	38	<request name="get_output">
	39	<description summary="get a dwl_ipc_outout for a wl_output">
	40	Get a dwl_ipc_outout for the specified wl_output.
	41	</description>
	42	<arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
	43	<arg name="output" type="object" interface="wl_output"/>
	44	</request>
	45
	46	<event name="tags">
	47	<description summary="Announces tag amount">
	48	This event is sent after binding.
	49	A roundtrip after binding guarantees the client recieved all tags.
	50	</description>
	51	<arg name="amount" type="uint"/>
	52	</event>
	53
	54	<event name="layout">
	55	<description summary="Announces a layout">
	56	This event is sent after binding.
	57	A roundtrip after binding guarantees the client recieved all layouts.
	58	</description>
	59	<arg name="name" type="string"/>
	60	</event>
	61	</interface>
	62
	63	<interface name="zdwl_ipc_output_v2" version="2">
	64	<description summary="control dwl output">
	65	Observe and control a dwl output.
	66
	67	Events are double-buffered:
	68	Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
	69
	70	Request are not double-buffered:
	71	The compositor will update immediately upon request.
	72	</description>
	73
	74	<enum name="tag_state">
	75	<entry name="none" value="0" summary="no state"/>
	76	<entry name="active" value="1" summary="tag is active"/>
	77	<entry name="urgent" value="2" summary="tag has at least one urgent client"/>
	78	</enum>
	79
	80	<request name="release" type="destructor">
	81	<description summary="release dwl_ipc_outout">
	82	Indicates to that the client no longer needs this dwl_ipc_output.
	83	</description>
	84	</request>
	85
	86	<event name="toggle_visibility">
	87	<description summary="Toggle client visibilty">
	88	Indicates the client should hide or show themselves.
	89	If the client is visible then hide, if hidden then show.
	90	</description>
	91	</event>
	92
	93	<event name="active">
	94	<description summary="Update the selected output.">
	95	Indicates if the output is active. Zero is invalid, nonzero is valid.
	96	</description>
	97	<arg name="active" type="uint"/>
	98	</event>
	99
	100	<event name="tag">
	101	<description summary="Update the state of a tag.">
	102	Indicates that a tag has been updated.
	103	</description>
	104	<arg name="tag" type="uint" summary="Index of the tag"/>
	105	<arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/>
	106	<arg name="clients" type="uint" summary="The number of clients in the tag."/>
	107	<arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/>
	108	</event>
	109
	110	<event name="layout">
	111	<description summary="Update the layout.">
	112	Indicates a new layout is selected.
	113	</description>
	114	<arg name="layout" type="uint" summary="Index of the layout."/>
	115	</event>
	116
	117	<event name="title">
	118	<description summary="Update the title.">
	119	Indicates the title has changed.
	120	</description>
	121	<arg name="title" type="string" summary="The new title name."/>
	122	</event>
	123
	124	<event name="appid" since="1">
	125	<description summary="Update the appid.">
	126	Indicates the appid has changed.
	127	</description>
	128	<arg name="appid" type="string" summary="The new appid."/>
	129	</event>
	130
	131	<event name="layout_symbol" since="1">
	132	<description summary="Update the current layout symbol">
	133	Indicates the layout has changed. Since layout symbols are dynamic.
	134	As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying.
	135	You can ignore the zdwl_ipc_output.layout event.
	136	</description>
	137	<arg name="layout" type="string" summary="The new layout"/>
	138	</event>
	139
	140	<event name="frame">
	141	<description summary="The update sequence is done.">
	142	Indicates that a sequence of status updates have finished and the client should redraw.
	143	</description>
	144	</event>
	145
	146	<request name="set_tags">
	147	<description summary="Set the active tags of this output"/>
	148	<arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
	149	<arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/>
	150	</request>
	151
	152	<request name="set_client_tags">
	153	<description summary="Set the tags of the focused client.">
	154	The tags are updated as follows:
	155	new_tags = (current_tags AND and_tags) XOR xor_tags
	156	</description>
	157	<arg name="and_tags" type="uint"/>
	158	<arg name="xor_tags" type="uint"/>
	159	</request>
	160
	161	<request name="set_layout">
	162	<description summary="Set the layout of this output"/>
	163	<arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/>
	164	</request>
	165
	166	<!-- Version 2 -->
	167	<event name="fullscreen" since="2">
	168	<description summary="Update fullscreen status">
	169	Indicates if the selected client on this output is fullscreen.
	170	</description>
	171	<arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/>
	172	</event>
	173
	174	<event name="floating" since="2">
	175	<description summary="Update the floating status">
	176	Indicates if the selected client on this output is floating.
	177	</description>
	178	<arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/>
	179	</event>
	180	</interface>
	181	</protocol>

smsg/smsg.c

0 created 644 +516 0

This diff has been collapsed as it changes many lines, (516 lines changed) Show them Hide them
	@@ -0,0 +1,516
		1	#define _GNU_SOURCE
		2	#include "arg.h"
		3	#include <poll.h>
		4	#include <stdio.h>
		5	#include <stdlib.h>
		6	#include <string.h>
		7	#include <sys/socket.h>
		8	#include <wayland-client.h>
		9	#include <wayland-util.h>
		10	#include "dwl-ipc-unstable-v2-protocol.h"
		11
		12	#define die(fmt, ...) do { fprintf(stderr, fmt "\n", ##__VA_ARGS__); exit(EXIT_FAILURE); } while (0)
		13
		14	char *argv0;
		15
		16	static enum {
		17	NONE = 0,
		18	SET = 1<<0,
		19	GET = 1<<1,
		20	WATCH = 1<<2 \| GET,
		21	} mode = NONE;
		22
		23	static int Oflag;
		24	static int Tflag;
		25	static int Lflag;
		26	static int Pflag;
		27	static int Fflag;
		28	static int oflag;
		29	static int tflag;
		30	static int lflag;
		31	static int cflag;
		32	static int vflag;
		33	static int mflag;
		34	static int fflag;
		35
		36	static uint32_t occ, seltags, sel, urg;
		37
		38	static char *output_name;
		39	static char *focused_output;
		40	static uint32_t tagcount;
		41	static char *tagset;
		42	static char *layout_name;
		43	static size_t layoutcount, layout_idx;
		44	static char *client_tags;
		45
		46	struct output {
		47	char *output_name;
		48	uint32_t name;
		49	};
		50	static size_t outputs_buflen = 4;
		51	static struct output *outputs;
		52	static size_t outputcount;
		53
		54	static struct wl_display *display;
		55	static struct wl_registry *registry;
		56	static struct zdwl_ipc_manager_v2 *dwl_ipc_manager;
		57
		58	static void
		59	dwl_ipc_tags(void data, struct zdwl_ipc_manager_v2 dwl_ipc_manager, uint32_t count)
		60	{
		61	tagcount = count;
		62	if (Tflag && mode & GET) printf("%d\n", tagcount);
		63	}
		64
		65	static void
		66	dwl_ipc_layout(void data, struct zdwl_ipc_manager_v2 dwl_ipc_manager, const char *name)
		67	{
		68	if (lflag && mode & SET && strcmp(layout_name, name) == 0)
		69	layout_idx = layoutcount;
		70	if (Lflag && mode & GET) printf("%s\n", name);
		71	layoutcount++;
		72	}
		73
		74	static const struct zdwl_ipc_manager_v2_listener dwl_ipc_listener = {
		75	.tags = dwl_ipc_tags,
		76	.layout = dwl_ipc_layout
		77	};
		78
		79	static void
		80	dwl_ipc_output_toggle_visibility(void data, struct zdwl_ipc_output_v2 dwl_ipc_output)
		81	{
		82	if (!vflag) return;
		83	char *oname = data;
		84	if (oname) printf("%s ", oname);
		85	printf("toggle\n");
		86	}
		87
		88	static void
		89	dwl_ipc_output_active(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		90	uint32_t active)
		91	{
		92	if (active && (!output_name \|\| !*output_name))
		93	output_name = strdup(data);
		94	if (active) {
		95	free(focused_output);
		96	focused_output = data ? strdup(data) : NULL;
		97	}
		98	if (!oflag) return;
		99	char *oname = data;
		100	if (oname) printf("%s ", oname);
		101	printf("selmon %u\n", !!active);
		102	}
		103
		104	static void
		105	dwl_ipc_output_tag(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		106	uint32_t tag, uint32_t state, uint32_t clients, uint32_t focused)
		107	{
		108	if (!tflag) return;
		109	if (state != ZDWL_IPC_OUTPUT_V2_TAG_STATE_NONE) seltags \|= 1<<tag;
		110	if (state == ZDWL_IPC_OUTPUT_V2_TAG_STATE_ACTIVE) urg \|= 1<<tag;
		111	if (clients > 0) occ \|= 1<<tag;
		112	if (!(mode & GET)) return;
		113	if (data) printf("%s ", (char *)data);
		114	printf("tag %u %u %u %u\n", tag, state, clients, focused);
		115	}
		116
		117	static void
		118	dwl_ipc_output_layout(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		119	uint32_t layout)
		120	{
		121	}
		122
		123	static void
		124	dwl_ipc_output_layout_symbol(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		125	const char *layout)
		126	{
		127	if (!(lflag && mode & GET)) return;
		128	if (data) printf("%s ", (char *)data);
		129	printf("layout %s\n", layout);
		130	}
		131
		132	static void
		133	dwl_ipc_output_title(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		134	const char *title)
		135	{
		136	if (!(cflag && mode & GET)) return;
		137	if (data) printf("%s ", (char *)data);
		138	printf("title %s\n", title);
		139	}
		140
		141	static void
		142	dwl_ipc_output_appid(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		143	const char *appid)
		144	{
		145	if (!(cflag && mode & GET)) return;
		146	if (data) printf("%s ", (char *)data);
		147	printf("appid %s\n", appid);
		148	}
		149
		150	static void
		151	dwl_ipc_output_fullscreen(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		152	uint32_t is_fullscreen)
		153	{
		154	if (!mflag) return;
		155	if (data) printf("%s ", (char *)data);
		156	printf("fullscreen %u\n", is_fullscreen);
		157	}
		158
		159	static void
		160	dwl_ipc_output_floating(void data, struct zdwl_ipc_output_v2 dwl_ipc_output,
		161	uint32_t is_floating)
		162	{
		163	if (!fflag) return;
		164	if (data) printf("%s ", (char *)data);
		165	printf("floating %u\n", is_floating);
		166	}
		167
		168	static void
		169	dwl_ipc_output_frame(void data, struct zdwl_ipc_output_v2 dwl_ipc_output)
		170	{
		171	if (mode & SET) {
		172	if (data && !(output_name && strcmp(output_name, (char *)data) == 0)) return;
		173	if (lflag) {
		174	if (layout_idx == 0) {
		175	for (char c = layout_name; c; c++) {
		176	if (c < '0' \|\| c > '9')
		177	die("bad layout %s", layout_name);
		178	layout_idx = c-'0' + layout_idx10;
		179	}
		180	}
		181	if (layout_idx >= layoutcount)
		182	die("bad layout %s", layout_name);
		183	zdwl_ipc_output_v2_set_layout(dwl_ipc_output, layout_idx);
		184	}
		185	if (tflag) {
		186	uint32_t mask = seltags;
		187	char *t = tagset;
		188	uint32_t i = 0;
		189	int toggle = 1;
		190
		191	if (*t == '!') {
		192	toggle = 0;
		193	t++;
		194	}
		195
		196	for (; t && t >= '0' && *t <= '9'; t++)
		197	i = t-'0' + i10;
		198
		199	if (toggle && !*t) mask = 1<<i;
		200
		201	for (; *t; t++, i++) {
		202	switch (*t) {
		203	case '-':
		204	mask &= ~(1<<i);
		205	break;
		206	case '+':
		207	mask \|= 1<<i;
		208	break;
		209	case '^':
		210	mask ^= 1<<i;
		211	break;
		212	}
		213	}
		214
		215	if (i > tagcount) die("bad tagset %s", tagset);
		216
		217	zdwl_ipc_output_v2_set_tags(dwl_ipc_output, mask, toggle);
		218	}
		219	if (cflag) {
		220	uint32_t and = ~0, xor = 0;
		221	char *t = client_tags;
		222	uint32_t i = 0;
		223
		224	for (; t && t >= '0' && *t <= '9'; t++)
		225	i = t-'0' + i10;
		226
		227	if (!*t) {
		228	and = 0;
		229	xor = 1<<i;
		230	}
		231
		232	for (; *t; t++, i++) {
		233	switch (*t) {
		234	case '-':
		235	and &= ~(1<<i);
		236	break;
		237	case '+':
		238	and &= ~(1<<i);
		239	xor \|= 1<<i;
		240	break;
		241	case '^':
		242	xor \|= 1<<i;
		243	break;
		244	}
		245	}
		246	if (i > tagcount) die("bad client tagset %s", client_tags);
		247
		248	zdwl_ipc_output_v2_set_client_tags(dwl_ipc_output, and, xor);
		249	}
		250	wl_display_flush(display);
		251	exit(0);
		252	} else {
		253	if (Fflag && mode == WATCH && focused_output)
		254	printf("focusmon %s\n", focused_output);
		255	if (tflag) {
		256	if (data) printf("%s ", (char *)data);
		257	printf("tags %u %u %u %u\n", occ, seltags, sel, urg);
		258	occ = seltags = sel = urg = 0;
		259	}
		260	}
		261	fflush(stdout);
		262	}
		263
		264	static const struct zdwl_ipc_output_v2_listener dwl_ipc_output_listener = {
		265	.toggle_visibility = dwl_ipc_output_toggle_visibility,
		266	.active = dwl_ipc_output_active,
		267	.tag = dwl_ipc_output_tag,
		268	.layout = dwl_ipc_output_layout,
		269	.title = dwl_ipc_output_title,
		270	.appid = dwl_ipc_output_appid,
		271	.layout_symbol = dwl_ipc_output_layout_symbol,
		272	.fullscreen = dwl_ipc_output_fullscreen,
		273	.floating = dwl_ipc_output_floating,
		274	.frame = dwl_ipc_output_frame,
		275	};
		276
		277	static void
		278	wl_output_name(void data, struct wl_output output, const char *name)
		279	{
		280	if (outputs) {
		281	struct output o = (struct output )data;
		282	o->output_name = strdup(name);
		283	printf("+ ");
		284	}
		285	if (Oflag) printf("%s\n", name);
		286	if (output_name && *output_name && strcmp(output_name, name) != 0) {
		287	wl_output_release(output);
		288	return;
		289	}
		290	if (dwl_ipc_manager) {
		291	struct zdwl_ipc_output_v2 *dwl_ipc_output =
		292	zdwl_ipc_manager_v2_get_output(dwl_ipc_manager, output);
		293	zdwl_ipc_output_v2_add_listener(dwl_ipc_output, &dwl_ipc_output_listener,
		294	output_name && *output_name ? NULL : strdup(name));
		295	}
		296	}
		297
		298	static void
		299	wl_output_geometry(void data, struct wl_output wl_output, int32_t x, int32_t y, int32_t w, int32_t h, int32_t subpixel, const char make, const char model, int32_t transform) {
		300	}
		301
		302	static void
		303	wl_output_mode(void data, struct wl_output wl_output, uint32_t flags, int32_t width, int32_t height, int32_t refresh)
		304	{
		305	}
		306
		307	static void
		308	wl_output_done(void data, struct wl_output wl_output)
		309	{
		310	}
		311
		312	static void
		313	wl_output_scale(void data, struct wl_output wl_output, int32_t factor)
		314	{
		315	}
		316
		317	static void
		318	wl_output_description(void data, struct wl_output output, const char *description)
		319	{
		320	}
		321
		322	static const struct wl_output_listener output_listener = {
		323	.geometry = wl_output_geometry,
		324	.mode = wl_output_mode,
		325	.done = wl_output_done,
		326	.scale = wl_output_scale,
		327	.name = wl_output_name,
		328	.description = wl_output_description,
		329	};
		330
		331	static void
		332	global_add(void data, struct wl_registry wl_registry,
		333	uint32_t name, const char *interface, uint32_t version)
		334	{
		335	if (strcmp(interface, wl_output_interface.name) == 0) {
		336	struct wl_output *o = wl_registry_bind(
		337	wl_registry, name, &wl_output_interface,
		338	WL_OUTPUT_NAME_SINCE_VERSION);
		339	wl_output_add_listener(o, &output_listener, outputs ? &outputs[outputcount] : NULL);
		340	if (!outputs) return;
		341	if (outputcount >= outputs_buflen) {
		342	outputs_buflen *= 2;
		343	outputs = reallocarray(outputs, outputs_buflen, sizeof(struct output));
		344	}
		345	outputs[outputcount].name = name;
		346	outputcount++;
		347	} else if (strcmp(interface, zdwl_ipc_manager_v2_interface.name) == 0) {
		348	dwl_ipc_manager = wl_registry_bind(wl_registry, name,
		349	&zdwl_ipc_manager_v2_interface, version < 2 ? version : 2);
		350	zdwl_ipc_manager_v2_add_listener(dwl_ipc_manager, &dwl_ipc_listener, NULL);
		351	}
		352	}
		353
		354	static void
		355	global_remove(void data, struct wl_registry wl_registry, uint32_t name)
		356	{
		357	if (!outputs) return;
		358	for (size_t i = 0; i < outputcount; i++) {
		359	if (outputs[i].name == name) {
		360	printf("- %s\n", outputs[i].output_name);
		361	free(outputs[i].output_name);
		362	outputs[i] = outputs[--outputcount];
		363	}
		364	}
		365	}
		366
		367	static const struct wl_registry_listener registry_listener = {
		368	.global = global_add,
		369	.global_remove = global_remove,
		370	};
		371
		372	static void
		373	usage(int code)
		374	{
		375	fprintf(code ? stderr : stdout,
		376	"usage:"
		377	"\t%1$s [-OTLPF]\n"
		378	"\t%1$s [-o <output>] -s [-t <tags>] [-l <layout>] [-c <tags>]\n"
		379	"\t%1$s [-o <output>] (-g \| -w) [-FOotlcvmf]\n",
		380	argv0);
		381	exit(code);
		382	}
		383
		384	int
		385	main(int argc, char *argv[])
		386	{
		387	ARGBEGIN {
		388	case '?': case 'h':
		389	usage(0); break;
		390	case 's':
		391	if (mode != NONE) usage(1);
		392	mode = SET;
		393	break;
		394	case 'g':
		395	if (mode != NONE) usage(1);
		396	mode = GET;
		397	break;
		398	case 'w':
		399	if (mode != NONE) usage(1);
		400	mode = WATCH;
		401	break;
		402	case 'o':
		403	if (mode & SET)
		404	output_name = EARGF(usage(1));
		405	else if (mode & GET \|\| !(output_name = ARGF()))
		406	oflag = 1;
		407	break;
		408	case 't':
		409	tflag = 1;
		410	if (mode & GET) break;
		411	mode = SET;
		412	tagset = EARGF(usage(1));
		413	break;
		414	case 'l':
		415	lflag = 1;
		416	if (mode & GET) break;
		417	mode = SET;
		418	layout_name = EARGF(usage(1));
		419	break;
		420	case 'c':
		421	cflag = 1;
		422	if (mode & GET) break;
		423	mode = SET;
		424	client_tags = EARGF(usage(1));
		425	break;
		426	case 'O':
		427	Oflag = 1;
		428	if (mode & SET) usage(1);
		429	if (mode & WATCH)
		430	outputs = malloc(outputs_buflen * sizeof(struct output));
		431	else
		432	mode = GET;
		433	break;
		434	case 'T':
		435	Tflag = 1;
		436	if (mode && mode != GET) usage(1);
		437	mode = GET;
		438	break;
		439	case 'L':
		440	Lflag = 1;
		441	if (mode && mode != GET) usage(1);
		442	mode = GET;
		443	break;
		444	case 'P':
		445	Pflag = 1;
		446	if (mode && mode != GET) usage(1);
		447	mode = GET;
		448	break;
		449	case 'F':
		450	Fflag = 1;
		451	if (mode && mode != GET) usage(1);
		452	mode = GET;
		453	break;
		454	case 'v':
		455	vflag = 1;
		456	if (mode & SET) usage(1);
		457	mode \|= GET;
		458	break;
		459	case 'm':
		460	mflag = 1;
		461	if (mode & SET) usage(1);
		462	mode \|= GET;
		463	break;
		464	case 'f':
		465	fflag = 1;
		466	if (mode & SET) usage(1);
		467	mode \|= GET;
		468	break;
		469	default:
		470	fprintf(stderr, "%s: bad option: -%c\n", argv0, ARGC());
		471	usage(1);
		472	} ARGEND
		473	if (argc > 0) {
		474	fprintf(stderr, "%s: bad args:", argv0);
		475	for (; *argv; argv++)
		476	fprintf(stderr, " %s", argv[0]);
		477	fprintf(stderr, "\n");
		478	usage(1);
		479	}
		480	if (mode == NONE) usage(1);
		481	if (mode & GET && !(oflag \|\| tflag \|\| lflag \|\| Oflag \|\| Tflag \|\| Lflag \|\| Pflag \|\| Fflag \|\| cflag \|\| vflag \|\| mflag \|\| fflag))
		482	oflag = tflag = lflag = cflag = vflag = mflag = fflag = Fflag = 1;
		483
		484	display = wl_display_connect(NULL);
		485	if (!display) die("bad display");
		486
		487	if (Pflag) {
		488	int fd = wl_display_get_fd(display);
		489	struct ucred ucred;
		490	socklen_t len = sizeof(struct ucred);
		491	if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == -1)
		492	die("bad getsockopt");
		493	printf("%d\n", ucred.pid);
		494	}
		495
		496	registry = wl_display_get_registry(display);
		497	if (!registry) die("bad registry");
		498
		499	wl_registry_add_listener(registry, &registry_listener, NULL);
		500
		501	wl_display_dispatch(display);
		502	wl_display_roundtrip(display);
		503
		504	if (!dwl_ipc_manager && (mode & SET \|\| tflag \|\| lflag \|\| Tflag \|\| Lflag \|\| cflag \|\| vflag \|\| mflag \|\| fflag))
		505	die("bad dwl-ipc protocol");
		506
		507	wl_display_roundtrip(display);
		508
		509	if (Fflag && !(mode == WATCH) && focused_output)
		510	printf("focusmon %s\n", focused_output);
		511
		512	if (mode == WATCH)
		513	while (wl_display_dispatch(display) != -1);
		514
		515	return 0;
		516	}

src/swindle.c

0 created 644 +4222 0

This diff has been collapsed as it changes many lines, (4222 lines changed) Show them Hide them
	@@ -0,0 +1,4222
		1	/*
		2	* See LICENSE file and licenses/ directory for copyright and license details.
		3	*/
		4	#include <errno.h>
		5	#include <getopt.h>
		6	#include <libinput.h>
		7	#include <linux/input-event-codes.h>
		8	#include <math.h>
		9	#include <signal.h>
		10	#include <stdio.h>
		11	#include <sys/stat.h>
		12	#include <stdlib.h>
		13	#include <sys/wait.h>
		14	#include <time.h>
		15	#include <unistd.h>
		16	#include <wayland-server-core.h>
		17	#include <wlr/backend.h>
		18	#include <wlr/backend/libinput.h>
		19	#include <wlr/render/allocator.h>
		20	#include <wlr/render/wlr_renderer.h>
		21	#include <wlr/types/wlr_alpha_modifier_v1.h>
		22	#include <wlr/types/wlr_compositor.h>
		23	#include <wlr/types/wlr_cursor.h>
		24	#include <wlr/types/wlr_cursor_shape_v1.h>
		25	#include <wlr/types/wlr_data_control_v1.h>
		26	#include <wlr/types/wlr_data_device.h>
		27	#include <wlr/types/wlr_drm.h>
		28	#include <wlr/types/wlr_export_dmabuf_v1.h>
		29	#include <wlr/types/wlr_ext_data_control_v1.h>
		30	#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
		31	#include <wlr/types/wlr_fractional_scale_v1.h>
		32	#include <wlr/types/wlr_gamma_control_v1.h>
		33	#include <wlr/types/wlr_idle_inhibit_v1.h>
		34	#include <wlr/types/wlr_idle_notify_v1.h>
		35	#include <wlr/types/wlr_input_device.h>
		36	#include <wlr/types/wlr_keyboard.h>
		37	#include <wlr/types/wlr_keyboard_group.h>
		38	#include <wlr/types/wlr_layer_shell_v1.h>
		39	#include <wlr/types/wlr_linux_dmabuf_v1.h>
		40	#include <wlr/types/wlr_linux_drm_syncobj_v1.h>
		41	#include <wlr/types/wlr_output.h>
		42	#include <wlr/types/wlr_output_layout.h>
		43	#include <wlr/types/wlr_output_management_v1.h>
		44	#include <wlr/types/wlr_output_power_management_v1.h>
		45	#include <wlr/types/wlr_pointer.h>
		46	#include <wlr/types/wlr_pointer_constraints_v1.h>
		47	#include <wlr/types/wlr_presentation_time.h>
		48	#include <wlr/types/wlr_primary_selection.h>
		49	#include <wlr/types/wlr_primary_selection_v1.h>
		50	#include <wlr/types/wlr_relative_pointer_v1.h>
		51	#include <wlr/types/wlr_scene.h>
		52	#include <wlr/types/wlr_screencopy_v1.h>
		53	#include <wlr/types/wlr_seat.h>
		54	#include <wlr/types/wlr_server_decoration.h>
		55	#include <wlr/types/wlr_session_lock_v1.h>
		56	#include <wlr/types/wlr_single_pixel_buffer_v1.h>
		57	#include <wlr/types/wlr_subcompositor.h>
		58	#include <wlr/types/wlr_viewporter.h>
		59	#include <wlr/types/wlr_virtual_keyboard_v1.h>
		60	#include <wlr/types/wlr_virtual_pointer_v1.h>
		61	#include <wlr/types/wlr_xcursor_manager.h>
		62	#include <wlr/types/wlr_xdg_activation_v1.h>
		63	#include <wlr/types/wlr_xdg_decoration_v1.h>
		64	#include <wlr/types/wlr_xdg_output_v1.h>
		65	#include <wlr/types/wlr_xdg_shell.h>
		66	#include <wlr/util/log.h>
		67	#include <wlr/util/region.h>
		68	#include <xkbcommon/xkbcommon.h>
		69	#ifdef XWAYLAND
		70	#include <wlr/xwayland.h>
		71	#include <xcb/xcb.h>
		72	#include <xcb/xcb_icccm.h>
		73	#endif
		74
		75	#include "util.h"
		76	#include "parser/parser.h"
		77
		78	/* macros */
		79	#define MAX(A, B) ((A) > (B) ? (A) : (B))
		80	#define MIN(A, B) ((A) < (B) ? (A) : (B))
		81	#define CLEANMASK(mask) (mask & ~WLR_MODIFIER_CAPS)
		82	#define VISIBLEON(C, M) ((M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
		83	#define LENGTH(X) (sizeof X / sizeof X[0])
		84	#define END(A) ((A) + LENGTH(A))
		85	#define TAGMASK ((1u << TAGCOUNT) - 1)
		86	#define LISTEN(E, L, H) wl_signal_add((E), ((L)->notify = (H), (L)))
		87	#define LISTEN_STATIC(E, H) do { struct wl_listener _l = ecalloc(1, sizeof(_l)); _l->notify = (H); wl_signal_add((E), _l); } while (0)
		88
		89	/* enums */
		90	enum { CurNormal, CurPressed, CurMove, CurResize, CurTileDrag }; /* cursor */
		91	enum { XDGShell, LayerShell, X11 }; /* client types */
		92	enum { LyrBg, LyrBottom, LyrTile, LyrFloat, LyrTop, LyrFS, LyrOverlay, LyrBlock, NUM_LAYERS }; /* scene layers */
		93
		94	typedef union {
		95	int i;
		96	uint32_t ui;
		97	float f;
		98	const void *v;
		99	} Arg;
		100
		101	typedef struct {
		102	unsigned int mod;
		103	unsigned int button;
		104	void (func)(const Arg );
		105	const Arg arg;
		106	} Button;
		107
		108	typedef struct Monitor Monitor;
		109	typedef struct {
		110	/* Must keep this field first */
		111	unsigned int type; /* XDGShell or X11* */
		112
		113	Monitor *mon;
		114	struct wlr_scene_tree *scene;
		115	struct wlr_scene_rect inner_border[4]; / inner top, bottom, left, right */
		116	struct wlr_scene_rect outer_border[4]; / outer top, bottom, left, right */
		117	struct wlr_scene_tree *scene_surface;
		118	struct wl_list link;
		119	struct wl_list flink;
		120	struct wlr_box geom; /* layout-relative, includes border */
		121	struct wlr_box prev; /* layout-relative, includes border */
		122	struct wlr_box bounds; /* only width and height are used */
		123	union {
		124	struct wlr_xdg_surface *xdg;
		125	struct wlr_xwayland_surface *xwayland;
		126	} surface;
		127	struct wlr_xdg_toplevel_decoration_v1 *decoration;
		128	struct wl_listener commit;
		129	struct wl_listener map;
		130	struct wl_listener maximize;
		131	struct wl_listener unmap;
		132	struct wl_listener destroy;
		133	struct wl_listener set_title;
		134	struct wl_listener fullscreen;
		135	struct wl_listener set_decoration_mode;
		136	struct wl_listener destroy_decoration;
		137	struct wlr_foreign_toplevel_handle_v1 *foreign_toplevel;
		138	struct wl_listener factivate;
		139	struct wl_listener fclose;
		140	struct wl_listener ffullscreen;
		141	struct wl_listener fdestroy;
		142	#ifdef XWAYLAND
		143	struct wl_listener activate;
		144	struct wl_listener associate;
		145	struct wl_listener dissociate;
		146	struct wl_listener configure;
		147	struct wl_listener set_hints;
		148	#endif
		149	unsigned int bw; /* total border width = ibw + obw */
		150	unsigned int ibw; /* inner border width */
		151	unsigned int obw; /* outer border width */
		152	uint32_t tags;
		153	int isfloating, isurgent, isfullscreen;
		154	float opacity; /* re-asserted every frame in rendermon() */
		155	uint32_t resize; /* configure serial of a pending resize */
		156	} Client;
		157
		158	typedef struct {
		159	uint32_t mod;
		160	xkb_keysym_t keysym;
		161	void (func)(const Arg );
		162	const Arg arg;
		163	} Key;
		164
		165	typedef struct {
		166	struct wlr_keyboard_group *wlr_group;
		167
		168	int nsyms;
		169	const xkb_keysym_t keysyms; / invalid if nsyms == 0 */
		170	uint32_t mods; /* invalid if nsyms == 0 */
		171	struct wl_event_source *key_repeat_source;
		172
		173	struct wl_listener modifiers;
		174	struct wl_listener key;
		175	struct wl_listener destroy;
		176	} KeyboardGroup;
		177
		178	typedef struct {
		179	/* Must keep this field first */
		180	unsigned int type; /* LayerShell */
		181
		182	Monitor *mon;
		183	struct wlr_scene_tree *scene;
		184	struct wlr_scene_tree *popups;
		185	struct wlr_scene_layer_surface_v1 *scene_layer;
		186	struct wl_list link;
		187	int mapped;
		188	struct wlr_layer_surface_v1 *layer_surface;
		189
		190	struct wl_listener destroy;
		191	struct wl_listener unmap;
		192	struct wl_listener surface_commit;
		193	} LayerSurface;
		194
		195	typedef struct {
		196	const char *symbol;
		197	void (arrange)(Monitor );
		198	} Layout;
		199
		200	#ifndef TAGCOUNT
		201	#define TAGCOUNT 9
		202	#endif
		203
		204	/* dwindle tree */
		205	typedef struct DwindleNode DwindleNode;
		206	struct DwindleNode {
		207	DwindleNode *children[2];
		208	DwindleNode *parent;
		209	Client *client;
		210	struct wlr_box box;
		211	float split_ratio;
		212	int split_top;
		213	int is_node;
		214	};
		215
		216	/* which physical edge of its old box a leaf's geometry moved toward/from */
		217	typedef enum { EDGE_NONE, EDGE_LEFT, EDGE_RIGHT, EDGE_TOP, EDGE_BOTTOM } DwindleEdge;
		218
		219	/* Filled in by dwindle_insert()/dwindle_remove() when a non-NULL hint
		220	* pointer is passed in*/
		221
		222	/*Left untouched (caller should zero it first) if
		223	* the operation didn't actually split/collapse anything, i.e. first
		224	* insert into an empty tree. */
		225
		226	typedef struct {
		227	DwindleEdge edge;
		228	struct wlr_box old_box;
		229	} DwindleHint;
		230
		231	struct Monitor {
		232	struct wl_list link;
		233	struct wlr_output *wlr_output;
		234	struct wlr_scene_output *scene_output;
		235	struct wlr_scene_rect fullscreen_bg; / See createmon() for info */
		236	struct wl_listener frame;
		237	struct wl_listener destroy;
		238	struct wl_listener request_state;
		239	struct wl_listener destroy_lock_surface;
		240	struct wlr_session_lock_surface_v1 *lock_surface;
		241	struct wlr_box m; /* monitor area, layout-relative */
		242	struct wlr_box w; /* window area, layout-relative */
		243	struct wl_list layers[4]; /* LayerSurface.link */
		244	const Layout *lt[2];
		245	int gaps;
		246	unsigned int seltags;
		247	struct wlr_ext_workspace_group_handle_v1 *ext_group;
		248	unsigned int sellt;
		249	uint32_t tagset[2];
		250	float mfact;
		251	int gamma_lut_changed;
		252	int nmaster;
		253	char ltsymbol[16];
		254	int asleep;
		255	DwindleNode dwindle_root[TAGCOUNT]; / one tree per tag */
		256	Client dwindle_focus[TAGCOUNT]; / insertion anchor, one per tag */
		257	};
		258
		259	typedef struct {
		260	const char *name;
		261	float mfact;
		262	int nmaster;
		263	float scale;
		264	const Layout *lt;
		265	enum wl_output_transform rr;
		266	int x, y;
		267	} MonitorRule;
		268
		269	typedef struct {
		270	struct wlr_pointer_constraint_v1 *constraint;
		271	struct wl_listener destroy;
		272	} PointerConstraint;
		273
		274	typedef struct {
		275	const char *id;
		276	const char *title;
		277	uint32_t tags;
		278	int isfloating;
		279	int monitor;
		280	} Rule;
		281
		282	typedef struct {
		283	struct wlr_scene_tree *scene;
		284
		285	struct wlr_session_lock_v1 *lock;
		286	struct wl_listener new_surface;
		287	struct wl_listener unlock;
		288	struct wl_listener destroy;
		289	} SessionLock;
		290
		291	/* function declarations */
		292	static void applybounds(Client c, struct wlr_box bbox);
		293	static void applyrules(Client *c);
		294	static void arrange(Monitor *m);
		295	static void arrangelayer(Monitor m, struct wl_list list,
		296	struct wlr_box *usable_area, int exclusive);
		297	static void arrangelayers(Monitor *m);
		298	static void axisnotify(struct wl_listener listener, void data);
		299	static void buttonpress(struct wl_listener listener, void data);
		300	static void chvt(const Arg *arg);
		301	static void checkidleinhibitor(struct wlr_surface *exclude);
		302	static void cleanup(void);
		303	static void cleanupmon(struct wl_listener listener, void data);
		304	static void cleanuplisteners(void);
		305	static void closemon(Monitor *m);
		306	static void dwindle_free_tree(DwindleNode *n);
		307	static void dwindle_remove_client(Client *c);
		308	static void dwindle_insert(DwindleNode *root, Client new_c, Client focused, DwindleHint hint);
		309	static int dwindle_insert_at_edge(DwindleNode *root, Client new_c, Client *target, DwindleEdge edge);
		310	static void dwindle_remove(DwindleNode *root, Client c, DwindleHint *hint);
		311	static DwindleEdge edge_at_point(struct wlr_box box, double x, double y);
		312	static struct wlr_box preselect_indicator_box(struct wlr_box target, DwindleEdge edge);
		313	static Client tiled_client_at(double x, double y, Client exclude);
		314	static inline int current_tag_idx(Monitor *m);
		315	static void commitlayersurfacenotify(struct wl_listener listener, void data);
		316	static void commitnotify(struct wl_listener listener, void data);
		317	static void commitpopup(struct wl_listener listener, void data);
		318	static void createdecoration(struct wl_listener listener, void data);
		319	static void createidleinhibitor(struct wl_listener listener, void data);
		320	static void createkeyboard(struct wlr_keyboard *keyboard);
		321	static KeyboardGroup *createkeyboardgroup(void);
		322	static void createlayersurface(struct wl_listener listener, void data);
		323	static void createforeigntoplevel(Client *c);
		324	static void createlocksurface(struct wl_listener listener, void data);
		325	static void createmon(struct wl_listener listener, void data);
		326	static void createnotify(struct wl_listener listener, void data);
		327	static void createpointer(struct wlr_pointer *pointer);
		328	static void createpointerconstraint(struct wl_listener listener, void data);
		329	static void createpopup(struct wl_listener listener, void data);
		330	static void cursorconstrain(struct wlr_pointer_constraint_v1 *constraint);
		331	static void cursorframe(struct wl_listener listener, void data);
		332	static void cursorwarptohint(void);
		333	static void destroydecoration(struct wl_listener listener, void data);
		334	static void destroydragicon(struct wl_listener listener, void data);
		335	static void destroyidleinhibitor(struct wl_listener listener, void data);
		336	static void destroylayersurfacenotify(struct wl_listener listener, void data);
		337	static void destroylock(SessionLock *lock, int unlocked);
		338	static void destroylocksurface(struct wl_listener listener, void data);
		339	static void destroynotify(struct wl_listener listener, void data);
		340	static void destroypointerconstraint(struct wl_listener listener, void data);
		341	static void destroysessionlock(struct wl_listener listener, void data);
		342	static void destroykeyboardgroup(struct wl_listener listener, void data);
		343	static Monitor *dirtomon(enum wlr_direction dir);
		344	static void factivatenotify(struct wl_listener listener, void data);
		345	static void fclosenotify(struct wl_listener listener, void data);
		346	static void fdestroynotify(struct wl_listener listener, void data);
		347	static void ffullscreennotify(struct wl_listener listener, void data);
		348	static void focusclient(Client *c, int lift);
		349	static void focusmon(const Arg *arg);
		350	static void focusdir(const Arg *arg);
		351	static void swapdir(const Arg *arg);
		352	static void swaptiled(Client a, Client b);
		353	static void dwindle_move_to_edge(Client a, Client b, DwindleEdge edge);
		354	static Client focustop(Monitor m);
		355	static void fullscreennotify(struct wl_listener listener, void data);
		356	static void gpureset(struct wl_listener listener, void data);
		357	static void handlesig(int signo);
		358	static void inputdevice(struct wl_listener listener, void data);
		359	static int keybinding(uint32_t mods, xkb_keysym_t sym);
		360	static void keypress(struct wl_listener listener, void data);
		361	static void keypressmod(struct wl_listener listener, void data);
		362	static int keyrepeat(void *data);
		363	static void killclient(const Arg *arg);
		364	static void locksession(struct wl_listener listener, void data);
		365	static void mapnotify(struct wl_listener listener, void data);
		366	static void maximizenotify(struct wl_listener listener, void data);
		367	static void motionabsolute(struct wl_listener listener, void data);
		368	static void motionnotify(uint32_t time, struct wlr_input_device *device, double sx,
		369	double sy, double sx_unaccel, double sy_unaccel);
		370	static void motionrelative(struct wl_listener listener, void data);
		371	static void moveresize(const Arg *arg);
		372	static void outputmgrapply(struct wl_listener listener, void data);
		373	static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test);
		374	static void outputmgrtest(struct wl_listener listener, void data);
		375	static void pointerfocus(Client c, struct wlr_surface surface,
		376	double sx, double sy, uint32_t time);
		377	static void printstatus(void);
		378	static void powermgrsetmode(struct wl_listener listener, void data);
		379	static void quit(const Arg *arg);
		380	static void rendermon(struct wl_listener listener, void data);
		381	static void requestdecorationmode(struct wl_listener listener, void data);
		382	static void requeststartdrag(struct wl_listener listener, void data);
		383	static void requestmonstate(struct wl_listener listener, void data);
		384	static void resize(Client *c, struct wlr_box geo, int interact);
		385	static void run(char *startup_cmd);
		386	static void setcursor(struct wl_listener listener, void data);
		387	static void setcursorshape(struct wl_listener listener, void data);
		388	static void setfloating(Client *c, int floating);
		389	static void setfullscreen(Client *c, int fullscreen);
		390	static void setlayout(const Arg *arg);
		391	static void setmon(Client c, Monitor m, uint32_t newtags);
		392	static void setpsel(struct wl_listener listener, void data);
		393	static void setsel(struct wl_listener listener, void data);
		394	static void setup(void);
		395	static void spawn(const Arg *arg);
		396	static void startdrag(struct wl_listener listener, void data);
		397	static void tag(const Arg *arg);
		398	static void tagmon(const Arg *arg);
		399	static void dwindle(Monitor *m);
		400	static void togglefloating(const Arg *arg);
		401	static void togglefullscreen(const Arg *arg);
		402	static void togglegaps(const Arg *arg);
		403	static void toggletag(const Arg *arg);
		404	static void toggleview(const Arg *arg);
		405	static void unlocksession(struct wl_listener listener, void data);
		406	static void unmaplayersurfacenotify(struct wl_listener listener, void data);
		407	static void unmapnotify(struct wl_listener listener, void data);
		408	static void updatemons(struct wl_listener listener, void data);
		409	static void updatetitle(struct wl_listener listener, void data);
		410	static void urgent(struct wl_listener listener, void data);
		411	static void view(const Arg *arg);
		412	static void virtualkeyboard(struct wl_listener listener, void data);
		413	static void virtualpointer(struct wl_listener listener, void data);
		414	static Monitor *xytomon(double x, double y);
		415	static void xytonode(double x, double y, struct wlr_surface **psurface,
		416	Client pc, LayerSurface pl, double nx, double ny);
		417
		418	/* variables */
		419	static pid_t child_pid = -1;
		420	static int locked;
		421	static void *exclusive_focus;
		422	static struct wl_display *dpy;
		423	static struct wl_event_loop *event_loop;
		424	static struct wlr_backend *backend;
		425	static struct wlr_scene *scene;
		426	static struct wlr_scene_tree *layers[NUM_LAYERS];
		427	static struct wlr_scene_tree *drag_icon;
		428	/* Map from ZWLR_LAYER_SHELL_* constants to Lyr* enum */
		429	static const int layermap[] = { LyrBg, LyrBottom, LyrTop, LyrOverlay };
		430	static struct wlr_renderer *drw;
		431	static struct wlr_allocator *alloc;
		432	static struct wlr_compositor *compositor;
		433	static struct wlr_session *session;
		434
		435	static struct wlr_xdg_shell *xdg_shell;
		436	static struct wlr_xdg_activation_v1 *activation;
		437	static struct wlr_xdg_decoration_manager_v1 *xdg_decoration_mgr;
		438	static struct wl_list clients; /* tiling order */
		439	static struct wl_list fstack; /* focus order */
		440	static struct wlr_idle_notifier_v1 *idle_notifier;
		441	static struct wlr_idle_inhibit_manager_v1 *idle_inhibit_mgr;
		442	static struct wlr_layer_shell_v1 *layer_shell;
		443	static struct wlr_output_manager_v1 *output_mgr;
		444	static struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard_mgr;
		445	static struct wlr_virtual_pointer_manager_v1 *virtual_pointer_mgr;
		446	static struct wlr_cursor_shape_manager_v1 *cursor_shape_mgr;
		447	static struct wlr_output_power_manager_v1 *power_mgr;
		448	static struct wlr_foreign_toplevel_manager_v1 *foreign_toplevel_mgr;
		449
		450	static struct wlr_pointer_constraints_v1 *pointer_constraints;
		451	static struct wlr_relative_pointer_manager_v1 *relative_pointer_mgr;
		452	static struct wlr_pointer_constraint_v1 *active_constraint;
		453
		454	static struct wlr_cursor *cursor;
		455	static struct wlr_xcursor_manager *cursor_mgr;
		456
		457	static struct wlr_scene_rect *root_bg;
		458	static struct wlr_session_lock_manager_v1 *session_lock_mgr;
		459	static struct wlr_scene_rect *locked_bg;
		460	static struct wlr_session_lock_v1 *cur_lock;
		461
		462	static struct wlr_seat *seat;
		463	static KeyboardGroup *kb_group;
		464	static unsigned int cursor_mode;
		465	static Client *grabc;
		466	static int grabcx, grabcy; /* client-relative */
		467
		468	/* Tile-drag preselect recomputes every motion event while cursor_mode ==
		469	CurTileDrag edge == EDGE_NONE means "dead centre of target, do a plain
		470	swap on release"." */
		471	static Client *preselect_target;
		472	static DwindleEdge preselect_edge;
		473	static struct wlr_scene_rect *preselect_indicator;
		474
		475	/* Fixed size grabc is resized to the moment a tile-drag starts, so it
		476	visually detaches and follows the cursor like a floating window rather
		477	than staying pinned at full tile size the whole gesture. Deliberately
		478	not "preserve original size" */
		479	#define TILEDRAG_DETACH_W 960
		480	#define TILEDRAG_DETACH_H 540
		481	static struct wlr_box tiledrag_orig_geom;
		482
		483	static struct wlr_output_layout *output_layout;
		484	static struct wlr_box sgeom;
		485	static struct wl_list mons;
		486	static Monitor *selmon;
		487
		488	/* global event handlers */
		489	static struct wl_listener cursor_axis = {.notify = axisnotify};
		490	static struct wl_listener cursor_button = {.notify = buttonpress};
		491	static struct wl_listener cursor_frame = {.notify = cursorframe};
		492	static struct wl_listener cursor_motion = {.notify = motionrelative};
		493	static struct wl_listener cursor_motion_absolute = {.notify = motionabsolute};
		494	static struct wl_listener gpu_reset = {.notify = gpureset};
		495	static struct wl_listener layout_change = {.notify = updatemons};
		496	static struct wl_listener new_idle_inhibitor = {.notify = createidleinhibitor};
		497	static struct wl_listener new_input_device = {.notify = inputdevice};
		498	static struct wl_listener new_virtual_keyboard = {.notify = virtualkeyboard};
		499	static struct wl_listener new_virtual_pointer = {.notify = virtualpointer};
		500	static struct wl_listener new_pointer_constraint = {.notify = createpointerconstraint};
		501	static struct wl_listener new_output = {.notify = createmon};
		502	static struct wl_listener new_xdg_toplevel = {.notify = createnotify};
		503	static struct wl_listener new_xdg_popup = {.notify = createpopup};
		504	static struct wl_listener new_xdg_decoration = {.notify = createdecoration};
		505	static struct wl_listener new_layer_surface = {.notify = createlayersurface};
		506	static struct wl_listener output_mgr_apply = {.notify = outputmgrapply};
		507	static struct wl_listener output_mgr_test = {.notify = outputmgrtest};
		508	static struct wl_listener output_power_mgr_set_mode = {.notify = powermgrsetmode};
		509	static struct wl_listener request_activate = {.notify = urgent};
		510	static struct wl_listener request_cursor = {.notify = setcursor};
		511	static struct wl_listener request_set_psel = {.notify = setpsel};
		512	static struct wl_listener request_set_sel = {.notify = setsel};
		513	static struct wl_listener request_set_cursor_shape = {.notify = setcursorshape};
		514	static struct wl_listener request_start_drag = {.notify = requeststartdrag};
		515	static struct wl_listener start_drag = {.notify = startdrag};
		516	static struct wl_listener new_session_lock = {.notify = locksession};
		517
		518	#ifdef XWAYLAND
		519	static void activatex11(struct wl_listener listener, void data);
		520	static void associatex11(struct wl_listener listener, void data);
		521	static void configurex11(struct wl_listener listener, void data);
		522	static void createnotifyx11(struct wl_listener listener, void data);
		523	static void dissociatex11(struct wl_listener listener, void data);
		524	static void sethints(struct wl_listener listener, void data);
		525	static void xwaylandready(struct wl_listener listener, void data);
		526	static struct wl_listener new_xwayland_surface = {.notify = createnotifyx11};
		527	static struct wl_listener xwayland_ready = {.notify = xwaylandready};
		528	static struct wlr_xwayland *xwayland;
		529	#endif
		530
		531	/* Runtime config */
		532
		533	static Config cfg;
		534	static struct wl_event_source *cfg_watch_src;
		535	static const char *custom_cfg_path;
		536
		537	#include "config.h"
		538
		539	/* attempt to encapsulate suck into one file */
		540	#include "client.h"
		541	#include "dwl-ipc.h"
		542	#include "ext-workspace.h"
		543
		544	/* function implementations */
		545	void
		546	applybounds(Client c, struct wlr_box bbox)
		547	{
		548	/* set minimum possible */
		549	c->geom.width = MAX(1 + 2 * (int)c->bw, c->geom.width);
		550	c->geom.height = MAX(1 + 2 * (int)c->bw, c->geom.height);
		551
		552	if (c->geom.x >= bbox->x + bbox->width)
		553	c->geom.x = bbox->x + bbox->width - c->geom.width;
		554	if (c->geom.y >= bbox->y + bbox->height)
		555	c->geom.y = bbox->y + bbox->height - c->geom.height;
		556	if (c->geom.x + c->geom.width <= bbox->x)
		557	c->geom.x = bbox->x;
		558	if (c->geom.y + c->geom.height <= bbox->y)
		559	c->geom.y = bbox->y;
		560	}
		561
		562	void
		563	applyrules(Client *c)
		564	{
		565	/* rule matching */
		566	const char appid, title;
		567	uint32_t newtags = 0;
		568	int i, ri;
		569	Monitor mon = selmon, m;
		570
		571	appid = client_get_appid(c);
		572	title = client_get_title(c);
		573
		574	if (c->foreign_toplevel) {
		575	wlr_foreign_toplevel_handle_v1_set_app_id(c->foreign_toplevel, appid);
		576	wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel, title);
		577	}
		578
		579	for (ri = 0; ri < cfg.nrules; ri++) {
		580	const CfgRule *r = &cfg.rules[ri];
		581	if ((!r->title[0] \|\| strstr(title, r->title))
		582	&& (!r->app_id[0] \|\| strstr(appid, r->app_id))) {
		583	c->isfloating = r->floating;
		584	newtags \|= r->tags;
		585	i = 0;
		586	wl_list_for_each(m, &mons, link) {
		587	if (r->monitor == i++)
		588	mon = m;
		589	}
		590	}
		591	}
		592
		593	c->isfloating \|= client_is_float_type(c);
		594	setmon(c, mon, newtags);
		595	}
		596
		597	void
		598	arrange(Monitor *m)
		599	{
		600	Client *c;
		601
		602	if (!m->wlr_output->enabled)
		603	return;
		604
		605	wl_list_for_each(c, &clients, link) {
		606	if (c->mon == m) {
		607	wlr_scene_node_set_enabled(&c->scene->node, VISIBLEON(c, m));
		608	client_set_suspended(c, !VISIBLEON(c, m));
		609	}
		610	}
		611
		612	wlr_scene_node_set_enabled(&m->fullscreen_bg->node,
		613	(c = focustop(m)) && c->isfullscreen);
		614
		615	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol));
		616
		617	/* We move all clients (except fullscreen and unmanaged) to LyrTile while
		618	* in floating layout to avoid "real" floating clients be always on top */
		619	wl_list_for_each(c, &clients, link) {
		620	if (c->mon != m \|\| c->scene->node.parent == layers[LyrFS])
		621	continue;
		622
		623	wlr_scene_node_reparent(&c->scene->node,
		624	(!m->lt[m->sellt]->arrange && c->isfloating)
		625	? layers[LyrTile]
		626	: (m->lt[m->sellt]->arrange && c->isfloating)
		627	? layers[LyrFloat]
		628	: c->scene->node.parent);
		629	}
		630
		631	if (m->lt[m->sellt]->arrange)
		632	m->lt[m->sellt]->arrange(m);
		633	motionnotify(0, NULL, 0, 0, 0, 0);
		634	checkidleinhibitor(NULL);
		635	}
		636
		637	void
		638	arrangelayer(Monitor m, struct wl_list list, struct wlr_box *usable_area, int exclusive)
		639	{
		640	LayerSurface *l;
		641	struct wlr_box full_area = m->m;
		642
		643	wl_list_for_each(l, list, link) {
		644	struct wlr_layer_surface_v1 *layer_surface = l->layer_surface;
		645
		646	if (!layer_surface->initialized)
		647	continue;
		648
		649	if (exclusive != (layer_surface->current.exclusive_zone > 0))
		650	continue;
		651
		652	wlr_scene_layer_surface_v1_configure(l->scene_layer, &full_area, usable_area);
		653	wlr_scene_node_set_position(&l->popups->node, l->scene->node.x, l->scene->node.y);
		654	}
		655	}
		656
		657	void
		658	arrangelayers(Monitor *m)
		659	{
		660	int i;
		661	struct wlr_box usable_area = m->m;
		662	LayerSurface *l;
		663	uint32_t layers_above_shell[] = {
		664	ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
		665	ZWLR_LAYER_SHELL_V1_LAYER_TOP,
		666	};
		667	if (!m->wlr_output->enabled)
		668	return;
		669
		670	/* Arrange exclusive surfaces from top->bottom */
		671	for (i = 3; i >= 0; i--)
		672	arrangelayer(m, &m->layers[i], &usable_area, 1);
		673
		674	if (!wlr_box_equal(&usable_area, &m->w)) {
		675	m->w = usable_area;
		676	arrange(m);
		677	}
		678
		679	/* Arrange non-exclusive surfaces from top->bottom */
		680	for (i = 3; i >= 0; i--)
		681	arrangelayer(m, &m->layers[i], &usable_area, 0);
		682
		683	/* Find topmost keyboard interactive layer, if such a layer exists */
		684	for (i = 0; i < (int)LENGTH(layers_above_shell); i++) {
		685	wl_list_for_each_reverse(l, &m->layers[layers_above_shell[i]], link) {
		686	if (locked \|\| !l->layer_surface->current.keyboard_interactive \|\| !l->mapped)
		687	continue;
		688	/* Deactivate the focused client. */
		689	focusclient(NULL, 0);
		690	exclusive_focus = l;
		691	client_notify_enter(l->layer_surface->surface, wlr_seat_get_keyboard(seat));
		692	return;
		693	}
		694	}
		695	}
		696
		697	void
		698	axisnotify(struct wl_listener listener, void data)
		699	{
		700	/* This event is forwarded by the cursor when a pointer emits an axis event,
		701	* for example when you move the scroll wheel. */
		702	struct wlr_pointer_axis_event *event = data;
		703	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
		704	wlr_seat_pointer_notify_axis(seat,
		705	event->time_msec, event->orientation, event->delta,
		706	event->delta_discrete, event->source, event->relative_direction);
		707	}
		708
		709	static void dispatch_action(const char action, const char (args)[CFG_MAX_STRLEN], int nargs);
		710
		711	void
		712	buttonpress(struct wl_listener listener, void data)
		713	{
		714	struct wlr_pointer_button_event *event = data;
		715	struct wlr_keyboard *keyboard;
		716	uint32_t mods;
		717	Client *c;
		718
		719	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
		720
		721	switch (event->state) {
		722	case WL_POINTER_BUTTON_STATE_PRESSED:
		723	cursor_mode = CurPressed;
		724	selmon = xytomon(cursor->x, cursor->y);
		725	if (locked)
		726	break;
		727
		728	/* Change focus if the button was _pressed_ over a client */
		729	xytonode(cursor->x, cursor->y, NULL, &c, NULL, NULL, NULL);
		730	if (c && (!client_is_unmanaged(c) \|\| client_wants_focus(c)))
		731	focusclient(c, 1);
		732
		733	keyboard = wlr_seat_get_keyboard(seat);
		734	mods = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;
		735	for (int i = 0; i < cfg.nbuttons; i++) {
		736	const CfgButton *b = &cfg.buttons[i];
		737	if (CLEANMASK(mods) == CLEANMASK(b->mods) &&
		738	event->button == b->button) {
		739	dispatch_action(b->action, b->args, b->nargs);
		740	return;
		741	}
		742	}
		743	break;
		744	case WL_POINTER_BUTTON_STATE_RELEASED:
		745	/* If you released any buttons, we exit interactive move/resize mode. */
		746	if (!locked && cursor_mode != CurNormal && cursor_mode != CurPressed) {
		747	wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
		748	if (cursor_mode == CurTileDrag) {
		749	Monitor *dropmon = xytomon(cursor->x, cursor->y);
		750	if (dropmon && dropmon != grabc->mon) {
		751	selmon = dropmon;
		752	cursor_mode = CurNormal; /* so arrange() treats grabc as tiled */
		753	setmon(grabc, dropmon, 0);
		754	wlr_scene_node_reparent(&grabc->scene->node, layers[LyrTile]);
		755	preselect_target = NULL;
		756	preselect_edge = EDGE_NONE;
		757	wlr_scene_node_set_enabled(&preselect_indicator->node, false);
		758	grabc = NULL;
		759	return;
		760	}
		761	if (preselect_target && preselect_edge != EDGE_NONE) {
		762	dwindle_move_to_edge(grabc, preselect_target, preselect_edge);
		763	} else {
		764	Client *target = tiled_client_at(cursor->x, cursor->y, grabc);
		765	if (target)
		766	swaptiled(grabc, target);
		767	else
		768	resize(grabc, tiledrag_orig_geom, 0);
		769	}
		770	wlr_scene_node_reparent(&grabc->scene->node, layers[LyrTile]);
		771	preselect_target = NULL;
		772	preselect_edge = EDGE_NONE;
		773	wlr_scene_node_set_enabled(&preselect_indicator->node, false);
		774	cursor_mode = CurNormal;
		775	grabc = NULL;
		776	return;
		777	}
		778	cursor_mode = CurNormal;
		779	/* Drop the window off on its new monitor */
		780	selmon = xytomon(cursor->x, cursor->y);
		781	setmon(grabc, selmon, 0);
		782	grabc = NULL;
		783	return;
		784	}
		785	cursor_mode = CurNormal;
		786	break;
		787	}
		788	/* If the event wasn't handled by the compositor, notify the client with
		789	* pointer focus that a button press has occurred */
		790	wlr_seat_pointer_notify_button(seat,
		791	event->time_msec, event->button, event->state);
		792	}
		793
		794	void
		795	chvt(const Arg *arg)
		796	{
		797	if (!session) {
		798	fprintf(stderr, "swindle: chvt: no session (not running on DRM)\n");
		799	return;
		800	}
		801	wlr_session_change_vt(session, arg->ui);
		802	}
		803
		804	void
		805	checkidleinhibitor(struct wlr_surface *exclude)
		806	{
		807	int inhibited = 0, unused_lx, unused_ly;
		808	struct wlr_idle_inhibitor_v1 *inhibitor;
		809	wl_list_for_each(inhibitor, &idle_inhibit_mgr->inhibitors, link) {
		810	struct wlr_surface *surface = wlr_surface_get_root_surface(inhibitor->surface);
		811	struct wlr_scene_tree *tree = surface->data;
		812	if (exclude != surface && (cfg.bypass_surface_visibility \|\| (!tree
		813	\|\| wlr_scene_node_coords(&tree->node, &unused_lx, &unused_ly)))) {
		814	inhibited = 1;
		815	break;
		816	}
		817	}
		818
		819	wlr_idle_notifier_v1_set_inhibited(idle_notifier, inhibited);
		820	}
		821
		822	void
		823	cleanup(void)
		824	{
		825	config_watch_stop(cfg_watch_src);
		826	cfg_watch_src = NULL;
		827	cleanuplisteners();
		828	#ifdef XWAYLAND
		829	wlr_xwayland_destroy(xwayland);
		830	xwayland = NULL;
		831	#endif
		832	wl_display_destroy_clients(dpy);
		833	if (child_pid > 0) {
		834	kill(-child_pid, SIGTERM);
		835	waitpid(child_pid, NULL, 0);
		836	}
		837	wlr_xcursor_manager_destroy(cursor_mgr);
		838
		839	destroykeyboardgroup(&kb_group->destroy, NULL);
		840
		841	/* If it's not destroyed manually, it will cause a use-after-free of wlr_seat.
		842	* Destroy it until it's fixed on the wlroots side */
		843	wlr_backend_destroy(backend);
		844
		845	wl_display_destroy(dpy);
		846	/* Destroy after the wayland display (when the monitors are already destroyed)
		847	to avoid destroying them with an invalid scene output. */
		848	wlr_scene_node_destroy(&scene->tree.node);
		849	}
		850
		851	void
		852	cleanupmon(struct wl_listener listener, void data)
		853	{
		854	Monitor *m = wl_container_of(listener, m, destroy);
		855	LayerSurface l, tmp;
		856	size_t i;
		857
		858	/* m->layers[i] are intentionally not unlinked */
		859	for (i = 0; i < LENGTH(m->layers); i++) {
		860	wl_list_for_each_safe(l, tmp, &m->layers[i], link)
		861	wlr_layer_surface_v1_destroy(l->layer_surface);
		862	}
		863
		864	wl_list_remove(&m->destroy.link);
		865	wl_list_remove(&m->frame.link);
		866	wl_list_remove(&m->link);
		867	wl_list_remove(&m->request_state.link);
		868	if (m->lock_surface)
		869	destroylocksurface(&m->destroy_lock_surface, NULL);
		870	m->wlr_output->data = NULL;
		871	wlr_output_layout_remove(output_layout, m->wlr_output);
		872	wlr_scene_output_destroy(m->scene_output);
		873
		874	closemon(m);
		875	ext_workspace_cleanupmon(m);
		876	for (int i = 0; i < TAGCOUNT; i++) {
		877	dwindle_free_tree(m->dwindle_root[i]);
		878	m->dwindle_root[i] = NULL;
		879	}
		880	wlr_scene_node_destroy(&m->fullscreen_bg->node);
		881	free(m);
		882	}
		883
		884	void
		885	cleanuplisteners(void)
		886	{
		887	wl_list_remove(&cursor_axis.link);
		888	wl_list_remove(&cursor_button.link);
		889	wl_list_remove(&cursor_frame.link);
		890	wl_list_remove(&cursor_motion.link);
		891	wl_list_remove(&cursor_motion_absolute.link);
		892	wl_list_remove(&gpu_reset.link);
		893	wl_list_remove(&new_idle_inhibitor.link);
		894	wl_list_remove(&layout_change.link);
		895	wl_list_remove(&new_input_device.link);
		896	wl_list_remove(&new_virtual_keyboard.link);
		897	wl_list_remove(&new_virtual_pointer.link);
		898	wl_list_remove(&new_pointer_constraint.link);
		899	wl_list_remove(&new_output.link);
		900	wl_list_remove(&new_xdg_toplevel.link);
		901	wl_list_remove(&new_xdg_decoration.link);
		902	wl_list_remove(&new_xdg_popup.link);
		903	wl_list_remove(&new_layer_surface.link);
		904	wl_list_remove(&output_mgr_apply.link);
		905	wl_list_remove(&output_mgr_test.link);
		906	wl_list_remove(&output_power_mgr_set_mode.link);
		907	wl_list_remove(&request_activate.link);
		908	wl_list_remove(&request_cursor.link);
		909	wl_list_remove(&request_set_psel.link);
		910	wl_list_remove(&request_set_sel.link);
		911	wl_list_remove(&request_set_cursor_shape.link);
		912	wl_list_remove(&request_start_drag.link);
		913	wl_list_remove(&start_drag.link);
		914	wl_list_remove(&new_session_lock.link);
		915	#ifdef XWAYLAND
		916	wl_list_remove(&new_xwayland_surface.link);
		917	wl_list_remove(&xwayland_ready.link);
		918	#endif
		919	}
		920
		921	void
		922	closemon(Monitor *m)
		923	{
		924	/* update selmon if needed and
		925	* move closed monitor's clients to the focused one */
		926	Client *c;
		927	int i = 0, nmons = wl_list_length(&mons);
		928	if (!nmons) {
		929	selmon = NULL;
		930	} else if (m == selmon) {
		931	do /* don't switch to disabled mons */
		932	selmon = wl_container_of(mons.next, selmon, link);
		933	while (!selmon->wlr_output->enabled && i++ < nmons);
		934
		935	if (!selmon->wlr_output->enabled)
		936	selmon = NULL;
		937	}
		938
		939	wl_list_for_each(c, &clients, link) {
		940	if (c->isfloating && c->geom.x > m->m.width)
		941	resize(c, (struct wlr_box){.x = c->geom.x - m->w.width, .y = c->geom.y,
		942	.width = c->geom.width, .height = c->geom.height}, 0);
		943	if (c->mon == m)
		944	setmon(c, selmon, c->tags);
		945	}
		946	focusclient(focustop(selmon), 1);
		947	printstatus();
		948	}
		949
		950	void
		951	commitlayersurfacenotify(struct wl_listener listener, void data)
		952	{
		953	LayerSurface *l = wl_container_of(listener, l, surface_commit);
		954	struct wlr_layer_surface_v1 *layer_surface = l->layer_surface;
		955	struct wlr_scene_tree *scene_layer = layers[layermap[layer_surface->current.layer]];
		956	struct wlr_layer_surface_v1_state old_state;
		957
		958	if (l->layer_surface->initial_commit) {
		959	client_set_scale(layer_surface->surface, l->mon->wlr_output->scale);
		960
		961	/* Temporarily set the layer's current state to pending
		962	* so that we can easily arrange it */
		963	old_state = l->layer_surface->current;
		964	l->layer_surface->current = l->layer_surface->pending;
		965	arrangelayers(l->mon);
		966	l->layer_surface->current = old_state;
		967	return;
		968	}
		969
		970	if (layer_surface->current.committed == 0 && l->mapped == layer_surface->surface->mapped)
		971	return;
		972	l->mapped = layer_surface->surface->mapped;
		973
		974	if (scene_layer != l->scene->node.parent) {
		975	wlr_scene_node_reparent(&l->scene->node, scene_layer);
		976	wl_list_remove(&l->link);
		977	wl_list_insert(&l->mon->layers[layer_surface->current.layer], &l->link);
		978	wlr_scene_node_reparent(&l->popups->node, (layer_surface->current.layer
		979	< ZWLR_LAYER_SHELL_V1_LAYER_TOP ? layers[LyrTop] : scene_layer));
		980	}
		981
		982	arrangelayers(l->mon);
		983	}
		984
		985	void
		986	commitnotify(struct wl_listener listener, void data)
		987	{
		988	Client *c = wl_container_of(listener, c, commit);
		989
		990	if (c->surface.xdg->initial_commit) {
		991	/*
		992	* Get the monitor this client will be rendered on
		993	* Note that if the user set a rule in which the client is placed on
		994	* a different monitor based on its title, this will likely select
		995	* a wrong monitor.
		996	*/
		997	applyrules(c);
		998	if (c->mon) {
		999	client_set_scale(client_surface(c), c->mon->wlr_output->scale);
		1000	}
		1001	setmon(c, NULL, 0); /* Make sure to reapply rules in mapnotify() */
		1002
		1003	wlr_xdg_toplevel_set_wm_capabilities(c->surface.xdg->toplevel,
		1004	WLR_XDG_TOPLEVEL_WM_CAPABILITIES_FULLSCREEN);
		1005	if (c->decoration)
		1006	requestdecorationmode(&c->set_decoration_mode, c->decoration);
		1007	wlr_xdg_toplevel_set_size(c->surface.xdg->toplevel, 0, 0);
		1008	return;
		1009	}
		1010
		1011	resize(c, c->geom, (c->isfloating && !c->isfullscreen));
		1012
		1013	/* mark a pending resize as completed */
		1014	if (c->resize && c->resize <= c->surface.xdg->current.configure_serial)
		1015	c->resize = 0;
		1016	}
		1017
		1018	void
		1019	commitpopup(struct wl_listener listener, void data)
		1020	{
		1021	struct wlr_surface *surface = data;
		1022	struct wlr_xdg_popup *popup = wlr_xdg_popup_try_from_wlr_surface(surface);
		1023	LayerSurface *l = NULL;
		1024	Client *c = NULL;
		1025	struct wlr_box box;
		1026	int type = -1;
		1027
		1028	if (!popup->base->initial_commit)
		1029	return;
		1030
		1031	type = toplevel_from_wlr_surface(popup->base->surface, &c, &l);
		1032	if (!popup->parent \|\| type < 0)
		1033	return;
		1034	popup->base->surface->data = wlr_scene_xdg_surface_create(
		1035	popup->parent->data, popup->base);
		1036	if ((l && !l->mon) \|\| (c && !c->mon)) {
		1037	wlr_xdg_popup_destroy(popup);
		1038	return;
		1039	}
		1040	box = type == LayerShell ? l->mon->m : c->mon->w;
		1041	box.x -= (type == LayerShell ? l->scene->node.x : c->geom.x);
		1042	box.y -= (type == LayerShell ? l->scene->node.y : c->geom.y);
		1043	wlr_xdg_popup_unconstrain_from_box(popup, &box);
		1044	wl_list_remove(&listener->link);
		1045	free(listener);
		1046	}
		1047
		1048	void
		1049	createdecoration(struct wl_listener listener, void data)
		1050	{
		1051	struct wlr_xdg_toplevel_decoration_v1 *deco = data;
		1052	Client *c = deco->toplevel->base->data;
		1053	c->decoration = deco;
		1054
		1055	LISTEN(&deco->events.request_mode, &c->set_decoration_mode, requestdecorationmode);
		1056	LISTEN(&deco->events.destroy, &c->destroy_decoration, destroydecoration);
		1057
		1058	requestdecorationmode(&c->set_decoration_mode, deco);
		1059	}
		1060
		1061	void
		1062	createidleinhibitor(struct wl_listener listener, void data)
		1063	{
		1064	struct wlr_idle_inhibitor_v1 *idle_inhibitor = data;
		1065	LISTEN_STATIC(&idle_inhibitor->events.destroy, destroyidleinhibitor);
		1066
		1067	checkidleinhibitor(NULL);
		1068	}
		1069
		1070	void
		1071	createkeyboard(struct wlr_keyboard *keyboard)
		1072	{
		1073	/* Set the keymap to match the group keymap */
		1074	wlr_keyboard_set_keymap(keyboard, kb_group->wlr_group->keyboard.keymap);
		1075
		1076	/* Add the new keyboard to the group */
		1077	wlr_keyboard_group_add_keyboard(kb_group->wlr_group, keyboard);
		1078	}
		1079
		1080	KeyboardGroup *
		1081	createkeyboardgroup(void)
		1082	{
		1083	KeyboardGroup group = ecalloc(1, sizeof(group));
		1084	struct xkb_context *context;
		1085	struct xkb_keymap *keymap;
		1086
		1087	group->wlr_group = wlr_keyboard_group_create();
		1088	group->wlr_group->data = group;
		1089
		1090	/* Prepare an XKB keymap and assign it to the keyboard group. */
		1091	struct xkb_rule_names rn = {
		1092	.model = cfg.input.model[0] ? cfg.input.model : NULL,
		1093	.layout = cfg.input.layout[0] ? cfg.input.layout : "us",
		1094	.variant = cfg.input.variant[0] ? cfg.input.variant : NULL,
		1095	.options = cfg.input.options[0] ? cfg.input.options : NULL,
		1096	};
		1097	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
		1098	if (!(keymap = xkb_keymap_new_from_names(context, &rn,
		1099	XKB_KEYMAP_COMPILE_NO_FLAGS)))
		1100	die("failed to compile keymap");
		1101
		1102	wlr_keyboard_set_keymap(&group->wlr_group->keyboard, keymap);
		1103	xkb_keymap_unref(keymap);
		1104	xkb_context_unref(context);
		1105
		1106	wlr_keyboard_set_repeat_info(&group->wlr_group->keyboard, cfg.input.repeat_rate, cfg.input.repeat_delay);
		1107
		1108	/* Set up listeners for keyboard events */
		1109	LISTEN(&group->wlr_group->keyboard.events.key, &group->key, keypress);
		1110	LISTEN(&group->wlr_group->keyboard.events.modifiers, &group->modifiers, keypressmod);
		1111
		1112	group->key_repeat_source = wl_event_loop_add_timer(event_loop, keyrepeat, group);
		1113
		1114	/* A seat can only have one keyboard, but this is a limitation of the
		1115	* Wayland protocol - not wlroots. We assign all connected keyboards to the
		1116	* same wlr_keyboard_group, which provides a single wlr_keyboard interface for
		1117	* all of them. Set this combined wlr_keyboard as the seat keyboard.
		1118	*/
		1119	wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);
		1120	return group;
		1121	}
		1122
		1123	void
		1124	createlayersurface(struct wl_listener listener, void data)
		1125	{
		1126	struct wlr_layer_surface_v1 *layer_surface = data;
		1127	LayerSurface *l;
		1128	struct wlr_surface *surface = layer_surface->surface;
		1129	struct wlr_scene_tree *scene_layer = layers[layermap[layer_surface->pending.layer]];
		1130
		1131	if (!layer_surface->output
		1132	&& !(layer_surface->output = selmon ? selmon->wlr_output : NULL)) {
		1133	wlr_layer_surface_v1_destroy(layer_surface);
		1134	return;
		1135	}
		1136
		1137	l = layer_surface->data = ecalloc(1, sizeof(*l));
		1138	l->type = LayerShell;
		1139	LISTEN(&surface->events.commit, &l->surface_commit, commitlayersurfacenotify);
		1140	LISTEN(&surface->events.unmap, &l->unmap, unmaplayersurfacenotify);
		1141	LISTEN(&layer_surface->events.destroy, &l->destroy, destroylayersurfacenotify);
		1142
		1143	l->layer_surface = layer_surface;
		1144	l->mon = layer_surface->output->data;
		1145	l->scene_layer = wlr_scene_layer_surface_v1_create(scene_layer, layer_surface);
		1146	l->scene = l->scene_layer->tree;
		1147	l->popups = surface->data = wlr_scene_tree_create(layer_surface->current.layer
		1148	< ZWLR_LAYER_SHELL_V1_LAYER_TOP ? layers[LyrTop] : scene_layer);
		1149	l->scene->node.data = l->popups->node.data = l;
		1150
		1151	wl_list_insert(&l->mon->layers[layer_surface->pending.layer],&l->link);
		1152	wlr_surface_send_enter(surface, layer_surface->output);
		1153	}
		1154
		1155	void
		1156	createlocksurface(struct wl_listener listener, void data)
		1157	{
		1158	SessionLock *lock = wl_container_of(listener, lock, new_surface);
		1159	struct wlr_session_lock_surface_v1 *lock_surface = data;
		1160	Monitor *m = lock_surface->output->data;
		1161	struct wlr_scene_tree *scene_tree = lock_surface->surface->data
		1162	= wlr_scene_subsurface_tree_create(lock->scene, lock_surface->surface);
		1163	m->lock_surface = lock_surface;
		1164
		1165	wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y);
		1166	wlr_session_lock_surface_v1_configure(lock_surface, m->m.width, m->m.height);
		1167
		1168	LISTEN(&lock_surface->events.destroy, &m->destroy_lock_surface, destroylocksurface);
		1169
		1170	if (m == selmon)
		1171	client_notify_enter(lock_surface->surface, wlr_seat_get_keyboard(seat));
		1172	}
		1173
		1174	void
		1175	createmon(struct wl_listener listener, void data)
		1176	{
		1177	/* This event is raised by the backend when a new output (aka a display or
		1178	* monitor) becomes available. */
		1179	struct wlr_output *wlr_output = data;
		1180	size_t i;
		1181	struct wlr_output_state state;
		1182	Monitor *m;
		1183
		1184	if (!wlr_output_init_render(wlr_output, alloc, drw))
		1185	return;
		1186
		1187	m = wlr_output->data = ecalloc(1, sizeof(*m));
		1188	m->wlr_output = wlr_output;
		1189
		1190	for (i = 0; i < LENGTH(m->layers); i++)
		1191	wl_list_init(&m->layers[i]);
		1192
		1193	wlr_output_state_init(&state);
		1194	/* Initialize monitor state using configured rules */
		1195	m->tagset[0] = m->tagset[1] = 1;
		1196	m->gaps = (cfg.appearance.gaps > 0) ? 1 : 0;
		1197	{
		1198	int ri;
		1199	for (ri = 0; ri < cfg.nmonitors; ri++) {
		1200	const CfgMonitorRule *r = &cfg.monitors[ri];
		1201	if (!r->name[0] \|\| strstr(wlr_output->name, r->name)) {
		1202	m->m.x = r->x;
		1203	m->m.y = r->y;
		1204	m->mfact = r->mfact;
		1205	m->nmaster = r->nmaster;
		1206	/* Map layout name to layouts[] entry (it's not
		1207	* very useful I know) */
		1208	m->lt[0] = &layouts[0]; /* default: floating */
		1209	for (int li = 0; li < (int)LENGTH(layouts); li++) {
		1210	if (layouts[li].symbol && !strcmp(r->layout, layouts[li].symbol)) {
		1211	m->lt[0] = &layouts[li];
		1212	break;
		1213	}
		1214	/* also match by arrange function name string */
		1215	if (!strcmp(r->layout, "dwindle") && layouts[li].arrange == dwindle) {
		1216	m->lt[0] = &layouts[li];
		1217	break;
		1218	}
		1219	}
		1220	m->lt[1] = &layouts[LENGTH(layouts) > 1 && m->lt[0] != &layouts[1]];
		1221	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol));
		1222	wlr_output_state_set_scale(&state, r->scale);
		1223	wlr_output_state_set_transform(&state, r->transform);
		1224	break;
		1225	}
		1226	}
		1227	}
		1228
		1229	/* The mode is a tuple of (width, height, refresh rate), and each
		1230	* monitor supports only a specific set of modes. We just pick the
		1231	* monitor's preferred mode; a more sophisticated compositor would let
		1232	* the user configure it. */
		1233	wlr_output_state_set_mode(&state, wlr_output_preferred_mode(wlr_output));
		1234
		1235	/* Set up event listeners */
		1236	LISTEN(&wlr_output->events.frame, &m->frame, rendermon);
		1237	LISTEN(&wlr_output->events.destroy, &m->destroy, cleanupmon);
		1238	LISTEN(&wlr_output->events.request_state, &m->request_state, requestmonstate);
		1239
		1240	wlr_output_state_set_enabled(&state, 1);
		1241	wlr_output_commit_state(wlr_output, &state);
		1242	wlr_output_state_finish(&state);
		1243
		1244	wl_list_insert(&mons, &m->link);
		1245	ext_workspace_createmon(m);
		1246	printstatus();
		1247
		1248	/* The xdg-protocol specifies:
		1249	*
		1250	* If the fullscreened surface is not opaque, the compositor must make
		1251	* sure that other screen content not part of the same surface tree (made
		1252	* up of subsurfaces, popups or similarly coupled surfaces) are not
		1253	* visible below the fullscreened surface.
		1254	*
		1255	*/
		1256
		1257	/* updatemons() will resize and set correct position */
		1258	m->fullscreen_bg = wlr_scene_rect_create(layers[LyrFS], 0, 0, cfg.appearance.fullscreen_bg);
		1259	wlr_scene_node_set_enabled(&m->fullscreen_bg->node, 0);
		1260
		1261	/* Adds this to the output layout in the order it was configured.
		1262	*
		1263	* The output layout utility automatically adds a wl_output global to the
		1264	* display, which Wayland clients can see to find out information about the
		1265	* output (such as DPI, scale factor, manufacturer, etc).
		1266	*/
		1267	m->scene_output = wlr_scene_output_create(scene, wlr_output);
		1268	if (m->m.x == -1 && m->m.y == -1)
		1269	wlr_output_layout_add_auto(output_layout, wlr_output);
		1270	else
		1271	wlr_output_layout_add(output_layout, wlr_output, m->m.x, m->m.y);
		1272	}
		1273
		1274	void
		1275	createnotify(struct wl_listener listener, void data)
		1276	{
		1277	/* This event is raised when a client creates a new toplevel (application window). */
		1278	struct wlr_xdg_toplevel *toplevel = data;
		1279	Client *c = NULL;
		1280
		1281	/* Allocate a Client for this surface */
		1282	c = toplevel->base->data = ecalloc(1, sizeof(*c));
		1283	c->surface.xdg = toplevel->base;
		1284	c->ibw = cfg.appearance.inner_border_px;
		1285	c->obw = cfg.appearance.outer_border_px;
		1286	c->bw = c->ibw + c->obw;
		1287
		1288	LISTEN(&toplevel->base->surface->events.commit, &c->commit, commitnotify);
		1289	LISTEN(&toplevel->base->surface->events.map, &c->map, mapnotify);
		1290	LISTEN(&toplevel->base->surface->events.unmap, &c->unmap, unmapnotify);
		1291	LISTEN(&toplevel->events.destroy, &c->destroy, destroynotify);
		1292	LISTEN(&toplevel->events.request_fullscreen, &c->fullscreen, fullscreennotify);
		1293	LISTEN(&toplevel->events.request_maximize, &c->maximize, maximizenotify);
		1294	LISTEN(&toplevel->events.set_title, &c->set_title, updatetitle);
		1295	}
		1296
		1297	void
		1298	createpointer(struct wlr_pointer *pointer)
		1299	{
		1300	struct libinput_device *device;
		1301	if (wlr_input_device_is_libinput(&pointer->base)
		1302	&& (device = wlr_libinput_get_device_handle(&pointer->base))) {
		1303
		1304	if (libinput_device_config_tap_get_finger_count(device)) {
		1305	libinput_device_config_tap_set_enabled(device, cfg.input.tap_to_click);
		1306	libinput_device_config_tap_set_drag_enabled(device, cfg.input.tap_and_drag);
		1307	libinput_device_config_tap_set_drag_lock_enabled(device, cfg.input.drag_lock);
		1308	libinput_device_config_tap_set_button_map(device, cfg.input.tap_button_map);
		1309	}
		1310
		1311	if (libinput_device_config_scroll_has_natural_scroll(device))
		1312	libinput_device_config_scroll_set_natural_scroll_enabled(device, cfg.input.natural_scrolling);
		1313
		1314	if (libinput_device_config_dwt_is_available(device))
		1315	libinput_device_config_dwt_set_enabled(device, cfg.input.disable_while_typing);
		1316
		1317	if (libinput_device_config_left_handed_is_available(device))
		1318	libinput_device_config_left_handed_set(device, cfg.input.left_handed);
		1319
		1320	if (libinput_device_config_middle_emulation_is_available(device))
		1321	libinput_device_config_middle_emulation_set_enabled(device, cfg.input.middle_button_emulation);
		1322
		1323	if (libinput_device_config_scroll_get_methods(device) != LIBINPUT_CONFIG_SCROLL_NO_SCROLL)
		1324	libinput_device_config_scroll_set_method(device, cfg.input.scroll_method);
		1325
		1326	if (libinput_device_config_click_get_methods(device) != LIBINPUT_CONFIG_CLICK_METHOD_NONE)
		1327	libinput_device_config_click_set_method(device, cfg.input.click_method);
		1328
		1329	if (libinput_device_config_send_events_get_modes(device))
		1330	libinput_device_config_send_events_set_mode(device, cfg.input.send_events_mode);
		1331
		1332	if (libinput_device_config_accel_is_available(device)) {
		1333	libinput_device_config_accel_set_profile(device, cfg.input.accel_profile);
		1334	libinput_device_config_accel_set_speed(device, cfg.input.accel_speed);
		1335	}
		1336	}
		1337
		1338	wlr_cursor_attach_input_device(cursor, &pointer->base);
		1339	}
		1340
		1341	void
		1342	createpointerconstraint(struct wl_listener listener, void data)
		1343	{
		1344	PointerConstraint pointer_constraint = ecalloc(1, sizeof(pointer_constraint));
		1345	pointer_constraint->constraint = data;
		1346	LISTEN(&pointer_constraint->constraint->events.destroy,
		1347	&pointer_constraint->destroy, destroypointerconstraint);
		1348	}
		1349
		1350	void
		1351	createpopup(struct wl_listener listener, void data)
		1352	{
		1353	/* This event is raised when a client (either xdg-shell or layer-shell)
		1354	* creates a new popup. */
		1355	struct wlr_xdg_popup *popup = data;
		1356	LISTEN_STATIC(&popup->base->surface->events.commit, commitpopup);
		1357	}
		1358
		1359	void
		1360	cursorconstrain(struct wlr_pointer_constraint_v1 *constraint)
		1361	{
		1362	if (active_constraint == constraint)
		1363	return;
		1364
		1365	if (active_constraint)
		1366	wlr_pointer_constraint_v1_send_deactivated(active_constraint);
		1367
		1368	active_constraint = constraint;
		1369	wlr_pointer_constraint_v1_send_activated(constraint);
		1370	}
		1371
		1372	void
		1373	cursorframe(struct wl_listener listener, void data)
		1374	{
		1375	/* This event is forwarded by the cursor when a pointer emits a frame
		1376	* event. Frame events are sent after regular pointer events to group
		1377	* multiple events together. For instance, two axis events may happen at the
		1378	* same time, in which case a frame event won't be sent in between. */
		1379	/* Notify the client with pointer focus of the frame event. */
		1380	wlr_seat_pointer_notify_frame(seat);
		1381	}
		1382
		1383	void
		1384	cursorwarptohint(void)
		1385	{
		1386	Client *c = NULL;
		1387	double sx = active_constraint->current.cursor_hint.x;
		1388	double sy = active_constraint->current.cursor_hint.y;
		1389
		1390	toplevel_from_wlr_surface(active_constraint->surface, &c, NULL);
		1391	if (c && active_constraint->current.cursor_hint.enabled) {
		1392	wlr_cursor_warp(cursor, NULL, sx + c->geom.x + c->bw, sy + c->geom.y + c->bw);
		1393	wlr_seat_pointer_warp(active_constraint->seat, sx, sy);
		1394	}
		1395	}
		1396
		1397	void
		1398	destroydecoration(struct wl_listener listener, void data)
		1399	{
		1400	Client *c = wl_container_of(listener, c, destroy_decoration);
		1401
		1402	wl_list_remove(&c->destroy_decoration.link);
		1403	wl_list_remove(&c->set_decoration_mode.link);
		1404	}
		1405
		1406	void
		1407	destroydragicon(struct wl_listener listener, void data)
		1408	{
		1409	/* Focus enter isn't sent during drag, so refocus the focused node. */
		1410	focusclient(focustop(selmon), 1);
		1411	motionnotify(0, NULL, 0, 0, 0, 0);
		1412	wl_list_remove(&listener->link);
		1413	free(listener);
		1414	}
		1415
		1416	void
		1417	destroyidleinhibitor(struct wl_listener listener, void data)
		1418	{
		1419	/* `data` is the wlr_surface of the idle inhibitor being destroyed,
		1420	* at this point the idle inhibitor is still in the list of the manager */
		1421	checkidleinhibitor(wlr_surface_get_root_surface(data));
		1422	wl_list_remove(&listener->link);
		1423	free(listener);
		1424	}
		1425
		1426	void
		1427	destroylayersurfacenotify(struct wl_listener listener, void data)
		1428	{
		1429	LayerSurface *l = wl_container_of(listener, l, destroy);
		1430
		1431	wl_list_remove(&l->link);
		1432	wl_list_remove(&l->destroy.link);
		1433	wl_list_remove(&l->unmap.link);
		1434	wl_list_remove(&l->surface_commit.link);
		1435	wlr_scene_node_destroy(&l->scene->node);
		1436	wlr_scene_node_destroy(&l->popups->node);
		1437	free(l);
		1438	}
		1439
		1440	void
		1441	destroylock(SessionLock *lock, int unlock)
		1442	{
		1443	wlr_seat_keyboard_notify_clear_focus(seat);
		1444	if ((locked = !unlock))
		1445	goto destroy;
		1446
		1447	wlr_scene_node_set_enabled(&locked_bg->node, 0);
		1448
		1449	focusclient(focustop(selmon), 0);
		1450	motionnotify(0, NULL, 0, 0, 0, 0);
		1451
		1452	destroy:
		1453	wl_list_remove(&lock->new_surface.link);
		1454	wl_list_remove(&lock->unlock.link);
		1455	wl_list_remove(&lock->destroy.link);
		1456
		1457	wlr_scene_node_destroy(&lock->scene->node);
		1458	cur_lock = NULL;
		1459	free(lock);
		1460	}
		1461
		1462	void
		1463	destroylocksurface(struct wl_listener listener, void data)
		1464	{
		1465	Monitor *m = wl_container_of(listener, m, destroy_lock_surface);
		1466	struct wlr_session_lock_surface_v1 surface, lock_surface = m->lock_surface;
		1467
		1468	m->lock_surface = NULL;
		1469	wl_list_remove(&m->destroy_lock_surface.link);
		1470
		1471	if (lock_surface->surface != seat->keyboard_state.focused_surface)
		1472	return;
		1473
		1474	if (locked && cur_lock && !wl_list_empty(&cur_lock->surfaces)) {
		1475	surface = wl_container_of(cur_lock->surfaces.next, surface, link);
		1476	client_notify_enter(surface->surface, wlr_seat_get_keyboard(seat));
		1477	} else if (!locked) {
		1478	focusclient(focustop(selmon), 1);
		1479	} else {
		1480	wlr_seat_keyboard_clear_focus(seat);
		1481	}
		1482	}
		1483
		1484	void
		1485	destroynotify(struct wl_listener listener, void data)
		1486	{
		1487	/* Called when the xdg_toplevel is destroyed. */
		1488	Client *c = wl_container_of(listener, c, destroy);
		1489	wl_list_remove(&c->destroy.link);
		1490	wl_list_remove(&c->set_title.link);
		1491	wl_list_remove(&c->fullscreen.link);
		1492	#ifdef XWAYLAND
		1493	if (c->type != XDGShell) {
		1494	wl_list_remove(&c->activate.link);
		1495	wl_list_remove(&c->associate.link);
		1496	wl_list_remove(&c->configure.link);
		1497	wl_list_remove(&c->dissociate.link);
		1498	wl_list_remove(&c->set_hints.link);
		1499	} else
		1500	#endif
		1501	{
		1502	wl_list_remove(&c->commit.link);
		1503	wl_list_remove(&c->map.link);
		1504	wl_list_remove(&c->unmap.link);
		1505	wl_list_remove(&c->maximize.link);
		1506	}
		1507	free(c);
		1508	}
		1509
		1510	void
		1511	destroypointerconstraint(struct wl_listener listener, void data)
		1512	{
		1513	PointerConstraint *pointer_constraint = wl_container_of(listener, pointer_constraint, destroy);
		1514
		1515	if (active_constraint == pointer_constraint->constraint) {
		1516	cursorwarptohint();
		1517	active_constraint = NULL;
		1518	}
		1519
		1520	wl_list_remove(&pointer_constraint->destroy.link);
		1521	free(pointer_constraint);
		1522	}
		1523
		1524	void
		1525	destroysessionlock(struct wl_listener listener, void data)
		1526	{
		1527	SessionLock *lock = wl_container_of(listener, lock, destroy);
		1528	destroylock(lock, 0);
		1529	}
		1530
		1531	void
		1532	destroykeyboardgroup(struct wl_listener listener, void data)
		1533	{
		1534	KeyboardGroup *group = wl_container_of(listener, group, destroy);
		1535	wl_event_source_remove(group->key_repeat_source);
		1536	wl_list_remove(&group->key.link);
		1537	wl_list_remove(&group->modifiers.link);
		1538	wl_list_remove(&group->destroy.link);
		1539	wlr_keyboard_group_destroy(group->wlr_group);
		1540	free(group);
		1541	}
		1542
		1543	Monitor *
		1544	dirtomon(enum wlr_direction dir)
		1545	{
		1546	struct wlr_output *next;
		1547	if (!wlr_output_layout_get(output_layout, selmon->wlr_output))
		1548	return selmon;
		1549	if ((next = wlr_output_layout_adjacent_output(output_layout,
		1550	dir, selmon->wlr_output, selmon->m.x, selmon->m.y)))
		1551	return next->data;
		1552	if ((next = wlr_output_layout_farthest_output(output_layout,
		1553	dir ^ (WLR_DIRECTION_LEFT\|WLR_DIRECTION_RIGHT),
		1554	selmon->wlr_output, selmon->m.x, selmon->m.y)))
		1555	return next->data;
		1556	return selmon;
		1557	}
		1558
		1559	void
		1560	focusclient(Client *c, int lift)
		1561	{
		1562	struct wlr_surface *old = seat->keyboard_state.focused_surface;
		1563	int unused_lx, unused_ly, old_client_type;
		1564	Client *old_c = NULL;
		1565	LayerSurface *old_l = NULL;
		1566
		1567	if (locked)
		1568	return;
		1569
		1570	/* Raise client in stacking order if requested */
		1571	if (c && lift)
		1572	wlr_scene_node_raise_to_top(&c->scene->node);
		1573
		1574	if (c && client_surface(c) == old)
		1575	return;
		1576
		1577	if ((old_client_type = toplevel_from_wlr_surface(old, &old_c, &old_l)) == XDGShell) {
		1578	struct wlr_xdg_popup popup, tmp;
		1579	wl_list_for_each_safe(popup, tmp, &old_c->surface.xdg->popups, link)
		1580	wlr_xdg_popup_destroy(popup);
		1581	}
		1582
		1583	/* Put the new client atop the focus stack and select its monitor */
		1584	if (c && !client_is_unmanaged(c)) {
		1585	wl_list_remove(&c->flink);
		1586	wl_list_insert(&fstack, &c->flink);
		1587	selmon = c->mon;
		1588	c->isurgent = 0;
		1589
		1590	/* Track focused client for dwindle insertion anchor */
		1591	if (c->mon && !c->isfloating && !c->isfullscreen)
		1592	c->mon->dwindle_focus[current_tag_idx(c->mon)] = c;
		1593
		1594	/* Don't change border color if there is an exclusive focus or we are
		1595	* handling a drag operation */
		1596	if (!exclusive_focus && !seat->drag) {
		1597	client_set_border_color(c, cfg.appearance.inner_focus_color, cfg.appearance.outer_focus_color);
		1598	client_set_opacity(c, cfg.appearance.active_opacity);
		1599	}
		1600	}
		1601
		1602	/* Deactivate old client if focus is changing */
		1603	if (old && (!c \|\| client_surface(c) != old)) {
		1604	/* If an overlay is focused, don't focus or activate the client,
		1605	* but only update its position in fstack to render its border with the focus colors
		1606	* and focus it after the overlay is closed. */
		1607	if (old_client_type == LayerShell && wlr_scene_node_coords(
		1608	&old_l->scene->node, &unused_lx, &unused_ly)
		1609	&& old_l->layer_surface->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {
		1610	return;
		1611	} else if (old_c && old_c == exclusive_focus && client_wants_focus(old_c)) {
		1612	return;
		1613	/* Don't deactivate old client if the new one wants focus, as this causes issues with winecfg
		1614	* and probably other clients */
		1615	} else if (old_c && !client_is_unmanaged(old_c) && (!c \|\| !client_wants_focus(c))) {
		1616	client_set_border_color(old_c, cfg.appearance.inner_border_color, cfg.appearance.outer_border_color);
		1617	client_set_opacity(old_c, cfg.appearance.inactive_opacity);
		1618
		1619	client_activate_surface(old, 0);
		1620	if (old_c->foreign_toplevel)
		1621	wlr_foreign_toplevel_handle_v1_set_activated(old_c->foreign_toplevel, 0);
		1622	}
		1623	}
		1624	printstatus();
		1625
		1626	if (!c) {
		1627	/* With no client, all we have left is to clear focus */
		1628	wlr_seat_keyboard_notify_clear_focus(seat);
		1629	return;
		1630	}
		1631
		1632	/* Change cursor surface */
		1633	motionnotify(0, NULL, 0, 0, 0, 0);
		1634
		1635	/* Have a client, so focus its top-level wlr_surface */
		1636	client_notify_enter(client_surface(c), wlr_seat_get_keyboard(seat));
		1637
		1638	/* Activate the new client */
		1639	client_activate_surface(client_surface(c), 1);
		1640	if (c->foreign_toplevel)
		1641	wlr_foreign_toplevel_handle_v1_set_activated(c->foreign_toplevel, 1);
		1642	}
		1643
		1644	void
		1645	focusmon(const Arg *arg)
		1646	{
		1647	int i = 0, nmons = wl_list_length(&mons);
		1648	if (nmons) {
		1649	do /* don't switch to disabled mons */
		1650	selmon = dirtomon(arg->i);
		1651	while (!selmon->wlr_output->enabled && i++ < nmons);
		1652	}
		1653	focusclient(focustop(selmon), 1);
		1654	}
		1655
		1656	/* Return the centre point of a client's geometry. */
		1657	static void
		1658	client_center(Client c, int cx, int *cy)
		1659	{
		1660	*cx = c->geom.x + c->geom.width / 2;
		1661	*cy = c->geom.y + c->geom.height / 2;
		1662	}
		1663
		1664	/* focusdir is basically spatial focus in a cardinal direction.
		1665	* arg->i: WLR_DIRECTION_LEFT, RIGHT, UP, DOWN.
		1666	* It finds the nearest tiled visible client whose centre lies in the
		1667	* requested half-plane relative to the focused client's centre */
		1668	void
		1669	focusdir(const Arg *arg)
		1670	{
		1671	Client c, best = NULL;
		1672	Client *sel = focustop(selmon);
		1673	int sx, sy, cx, cy;
		1674	double bestdist = 1e18, dist;
		1675
		1676	if (!sel \|\| (sel->isfullscreen && !client_has_children(sel)))
		1677	return;
		1678
		1679	client_center(sel, &sx, &sy);
		1680
		1681	wl_list_for_each(c, &clients, link) {
		1682	if (c == sel \|\| !VISIBLEON(c, selmon) \|\| c->isfloating)
		1683	continue;
		1684
		1685	client_center(c, &cx, &cy);
		1686
		1687	/* the candidate must be in the requested direction. */
		1688	switch (arg->i) {
		1689	case WLR_DIRECTION_LEFT: if (cx >= sx) continue; break;
		1690	case WLR_DIRECTION_RIGHT: if (cx <= sx) continue; break;
		1691	case WLR_DIRECTION_UP: if (cy >= sy) continue; break;
		1692	case WLR_DIRECTION_DOWN: if (cy <= sy) continue; break;
		1693	default: return;
		1694	}
		1695
		1696	dist = (double)(cx - sx) * (cx - sx) + (double)(cy - sy) * (cy - sy);
		1697	if (dist < bestdist) {
		1698	bestdist = dist;
		1699	best = c;
		1700	}
		1701	}
		1702
		1703	if (best)
		1704	focusclient(best, 1);
		1705	}
		1706
		1707	/* We probably should change the name of this: it sounds like it
		1708	* will focus the topmost client of this mon, when actually will
		1709	* only return that client */
		1710	Client *
		1711	focustop(Monitor *m)
		1712	{
		1713	Client *c;
		1714	wl_list_for_each(c, &fstack, flink) {
		1715	if (VISIBLEON(c, m))
		1716	return c;
		1717	}
		1718	return NULL;
		1719	}
		1720
		1721	void
		1722	fullscreennotify(struct wl_listener listener, void data)
		1723	{
		1724	Client *c = wl_container_of(listener, c, fullscreen);
		1725	setfullscreen(c, client_wants_fullscreen(c));
		1726	}
		1727
		1728	void
		1729	gpureset(struct wl_listener listener, void data)
		1730	{
		1731	struct wlr_renderer *old_drw = drw;
		1732	struct wlr_allocator *old_alloc = alloc;
		1733	struct Monitor *m;
		1734	if (!(drw = wlr_renderer_autocreate(backend)))
		1735	die("couldn't recreate renderer");
		1736
		1737	if (!(alloc = wlr_allocator_autocreate(backend, drw)))
		1738	die("couldn't recreate allocator");
		1739
		1740	wl_list_remove(&gpu_reset.link);
		1741	wl_signal_add(&drw->events.lost, &gpu_reset);
		1742
		1743	wlr_compositor_set_renderer(compositor, drw);
		1744
		1745	wl_list_for_each(m, &mons, link) {
		1746	wlr_output_init_render(m->wlr_output, alloc, drw);
		1747	}
		1748
		1749	wlr_allocator_destroy(old_alloc);
		1750	wlr_renderer_destroy(old_drw);
		1751	}
		1752
		1753	void
		1754	handlesig(int signo)
		1755	{
		1756	if (signo == SIGCHLD)
		1757	while (waitpid(-1, NULL, WNOHANG) > 0);
		1758	else if (signo == SIGINT \|\| signo == SIGTERM)
		1759	quit(NULL);
		1760	}
		1761
		1762
		1763	void
		1764	inputdevice(struct wl_listener listener, void data)
		1765	{
		1766	/* This event is raised by the backend when a new input device becomes
		1767	* available. */
		1768	struct wlr_input_device *device = data;
		1769	uint32_t caps;
		1770
		1771	switch (device->type) {
		1772	case WLR_INPUT_DEVICE_KEYBOARD:
		1773	createkeyboard(wlr_keyboard_from_input_device(device));
		1774	break;
		1775	case WLR_INPUT_DEVICE_POINTER:
		1776	createpointer(wlr_pointer_from_input_device(device));
		1777	break;
		1778	default:
		1779	/* TODO handle other input device types */
		1780	break;
		1781	}
		1782
		1783	/* We need to let the wlr_seat know what our capabilities are, which is
		1784	* communiciated to the client. In dwl we always have a cursor, even if
		1785	* there are no pointer devices, so we always include that capability. */
		1786	/* TODO do we actually require a cursor? */
		1787	caps = WL_SEAT_CAPABILITY_POINTER;
		1788	if (!wl_list_empty(&kb_group->wlr_group->devices))
		1789	caps \|= WL_SEAT_CAPABILITY_KEYBOARD;
		1790	wlr_seat_set_capabilities(seat, caps);
		1791	}
		1792
		1793	/* dispatch_action maps a CfgKeybind/CfgButton action string to the
		1794	* corresponding compositor function and calls it. args[0] is used where
		1795	* needed (spawn argv, tag mask, direction, etc). */
		1796	static void
		1797	dispatch_action(const char action, const char (args)[CFG_MAX_STRLEN], int nargs)
		1798	{
		1799	Arg arg = {0};
		1800	const char *a0 = nargs > 0 ? args[0] : NULL;
		1801
		1802	if (!strcmp(action, "spawn")) {
		1803	/* Build a NULL-terminated argv on the stack.
		1804	* CFG_MAX_ARGS is 16, which is plenty. */
		1805	const char *argv[CFG_MAX_ARGS + 1];
		1806	int i;
		1807	for (i = 0; i < nargs && i < CFG_MAX_ARGS; i++)
		1808	argv[i] = args[i];
		1809	argv[i] = NULL;
		1810	arg.v = argv;
		1811	spawn(&arg);
		1812	return;
		1813	}
		1814	if (!strcmp(action, "killclient")) { killclient(NULL); return; }
		1815	if (!strcmp(action, "togglefloating")) { togglefloating(NULL); return; }
		1816	if (!strcmp(action, "togglefullscreen")){ togglefullscreen(NULL); return; }
		1817	if (!strcmp(action, "togglegaps")) { togglegaps(NULL); return; }
		1818	if (!strcmp(action, "quit")) { quit(NULL); return; }
		1819
		1820	if (!strcmp(action, "view")) {
		1821	if (a0 && strcmp(a0, "all") == 0) arg.ui = ~0u;
		1822	else if (a0) arg.ui = (uint32_t)atoi(a0);
		1823	view(&arg);
		1824	return;
		1825	}
		1826	if (!strcmp(action, "toggleview")) {
		1827	if (a0) arg.ui = (uint32_t)atoi(a0);
		1828	toggleview(&arg);
		1829	return;
		1830	}
		1831	if (!strcmp(action, "tag")) {
		1832	if (a0) arg.ui = (uint32_t)atoi(a0);
		1833	tag(&arg);
		1834	return;
		1835	}
		1836	if (!strcmp(action, "toggletag")) {
		1837	if (a0) arg.ui = (uint32_t)atoi(a0);
		1838	toggletag(&arg);
		1839	return;
		1840	}
		1841
		1842	if (!strcmp(action, "focusdir")) {
		1843	if (a0 && !strcmp(a0, "left")) arg.i = WLR_DIRECTION_LEFT;
		1844	else if (a0 && !strcmp(a0, "right")) arg.i = WLR_DIRECTION_RIGHT;
		1845	else if (a0 && !strcmp(a0, "up")) arg.i = WLR_DIRECTION_UP;
		1846	else if (a0 && !strcmp(a0, "down")) arg.i = WLR_DIRECTION_DOWN;
		1847	focusdir(&arg);
		1848	return;
		1849	}
		1850	if (!strcmp(action, "swapdir")) {
		1851	if (a0 && !strcmp(a0, "left")) arg.i = WLR_DIRECTION_LEFT;
		1852	else if (a0 && !strcmp(a0, "right")) arg.i = WLR_DIRECTION_RIGHT;
		1853	else if (a0 && !strcmp(a0, "up")) arg.i = WLR_DIRECTION_UP;
		1854	else if (a0 && !strcmp(a0, "down")) arg.i = WLR_DIRECTION_DOWN;
		1855	swapdir(&arg);
		1856	return;
		1857	}
		1858	if (!strcmp(action, "focusmon")) {
		1859	if (a0 && !strcmp(a0, "left")) arg.i = WLR_DIRECTION_LEFT;
		1860	else if (a0 && !strcmp(a0, "right")) arg.i = WLR_DIRECTION_RIGHT;
		1861	focusmon(&arg);
		1862	return;
		1863	}
		1864	if (!strcmp(action, "setlayout")) {
		1865	/* arg is index into layouts[]; "0" = floating, "1" = dwindle and so
		1866	* on and so forth */
		1867
		1868	if (a0) arg.ui = (uint32_t)atoi(a0);
		1869	setlayout(&arg);
		1870	return;
		1871	}
		1872	if (!strcmp(action, "tagmon")) {
		1873	if (a0 && !strcmp(a0, "left")) arg.i = WLR_DIRECTION_LEFT;
		1874	else if (a0 && !strcmp(a0, "right")) arg.i = WLR_DIRECTION_RIGHT;
		1875	tagmon(&arg);
		1876	return;
		1877	}
		1878	if (!strcmp(action, "moveresize")) {
		1879	if (a0 && !strcmp(a0, "move")) arg.ui = CurMove;
		1880	else if (a0 && !strcmp(a0, "resize")) arg.ui = CurResize;
		1881	moveresize(&arg);
		1882	return;
		1883	}
		1884	if (!strcmp(action, "chvt")) {
		1885	if (a0) arg.ui = (uint32_t)atoi(a0);
		1886	chvt(&arg);
		1887	return;
		1888	}
		1889
		1890	fprintf(stderr, "swindle: unknown action '%s'\n", action);
		1891	}
		1892
		1893	int
		1894	keybinding(uint32_t mods, xkb_keysym_t sym)
		1895	{
		1896	for (int i = 0; i < cfg.nkeybinds; i++) {
		1897	const CfgKeybind *k = &cfg.keybinds[i];
		1898	if (CLEANMASK(mods) == CLEANMASK(k->mods)
		1899	&& xkb_keysym_to_lower(sym) == xkb_keysym_to_lower(k->key)) {
		1900	dispatch_action(k->action, k->args, k->nargs);
		1901	return 1;
		1902	}
		1903	}
		1904	return 0;
		1905	}
		1906
		1907	void
		1908	keypress(struct wl_listener listener, void data)
		1909	{
		1910	int i;
		1911	/* This event is raised when a key is pressed or released. */
		1912	KeyboardGroup *group = wl_container_of(listener, group, key);
		1913	struct wlr_keyboard_key_event *event = data;
		1914
		1915	/* Translate libinput keycode -> xkbcommon */
		1916	uint32_t keycode = event->keycode + 8;
		1917	/* Get a list of keysyms based on the keymap for this keyboard */
		1918	const xkb_keysym_t *syms;
		1919	int nsyms = xkb_state_key_get_syms(
		1920	group->wlr_group->keyboard.xkb_state, keycode, &syms);
		1921
		1922	/*
		1923	* Also get the base-level (unshifted) keysyms for this key
		1924	* This is necessary for binds like { mods={"logo","shift"}, key="1" }:
		1925	* when Shift is held, xkb_state_key_get_syms returns "exclam" (0x21),
		1926	* not "1" (0x31), so the config match would silently fail
		1927	* Querying level 0 of the active layout gives it the unshifted sym
		1928	* regardless of modifier state, which matches what the user wrote in
		1929	* the config
		1930	*/
		1931	const xkb_keysym_t *base_syms;
		1932	int base_nsyms = xkb_keymap_key_get_syms_by_level(
		1933	xkb_state_get_keymap(group->wlr_group->keyboard.xkb_state),
		1934	keycode,
		1935	xkb_state_key_get_layout(
		1936	group->wlr_group->keyboard.xkb_state, keycode),
		1937	0, /* level 0 = unshifted */
		1938	&base_syms);
		1939
		1940	int handled = 0;
		1941	uint32_t mods = wlr_keyboard_get_modifiers(&group->wlr_group->keyboard);
		1942
		1943	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
		1944
		1945	if (session && event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
		1946	for (i = 0; i < nsyms; i++) {
		1947	if (syms[i] >= XKB_KEY_XF86Switch_VT_1 &&
		1948	syms[i] <= XKB_KEY_XF86Switch_VT_12) {
		1949	wlr_session_change_vt(session,
		1950	syms[i] - XKB_KEY_XF86Switch_VT_1 + 1);
		1951	return;
		1952	}
		1953	}
		1954	for (i = 0; i < base_nsyms; i++) {
		1955	if (base_syms[i] >= XKB_KEY_XF86Switch_VT_1 &&
		1956	base_syms[i] <= XKB_KEY_XF86Switch_VT_12) {
		1957	wlr_session_change_vt(session,
		1958	base_syms[i] - XKB_KEY_XF86Switch_VT_1 + 1);
		1959	return;
		1960	}
		1961	}
		1962	}
		1963
		1964	/* Try state-aware syms first, then base syms (catches shifted digit binds). */
		1965	if (!locked && event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
		1966	for (i = 0; i < nsyms; i++)
		1967	handled = keybinding(mods, syms[i]) \|\| handled;
		1968	if (!handled) {
		1969	for (i = 0; i < base_nsyms; i++)
		1970	handled = keybinding(mods, base_syms[i]) \|\| handled;
		1971	}
		1972	}
		1973
		1974	if (handled && group->wlr_group->keyboard.repeat_info.delay > 0) {
		1975	group->mods = mods;
		1976	group->keysyms = base_syms;
		1977	group->nsyms = base_nsyms;
		1978	wl_event_source_timer_update(group->key_repeat_source,
		1979	group->wlr_group->keyboard.repeat_info.delay);
		1980	} else {
		1981	group->nsyms = 0;
		1982	wl_event_source_timer_update(group->key_repeat_source, 0);
		1983	}
		1984
		1985	if (handled)
		1986	return;
		1987
		1988	wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);
		1989	/* Pass unhandled keycodes along to the client. */
		1990	wlr_seat_keyboard_notify_key(seat, event->time_msec,
		1991	event->keycode, event->state);
		1992	}
		1993
		1994	void
		1995	keypressmod(struct wl_listener listener, void data)
		1996	{
		1997	/* This event is raised when a modifier key, such as shift or alt, is
		1998	* pressed. We simply communicate this to the client. */
		1999	KeyboardGroup *group = wl_container_of(listener, group, modifiers);
		2000
		2001	wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);
		2002	/* Send modifiers to the client. */
		2003	wlr_seat_keyboard_notify_modifiers(seat,
		2004	&group->wlr_group->keyboard.modifiers);
		2005	}
		2006
		2007	int
		2008	keyrepeat(void *data)
		2009	{
		2010	KeyboardGroup *group = data;
		2011	int i;
		2012	if (!group->nsyms \|\| group->wlr_group->keyboard.repeat_info.rate <= 0)
		2013	return 0;
		2014
		2015	wl_event_source_timer_update(group->key_repeat_source,
		2016	1000 / group->wlr_group->keyboard.repeat_info.rate);
		2017
		2018	for (i = 0; i < group->nsyms; i++)
		2019	keybinding(group->mods, group->keysyms[i]);
		2020
		2021	return 0;
		2022	}
		2023
		2024	void
		2025	killclient(const Arg *arg)
		2026	{
		2027	Client *sel = focustop(selmon);
		2028	if (sel)
		2029	client_send_close(sel);
		2030	}
		2031
		2032	void
		2033	locksession(struct wl_listener listener, void data)
		2034	{
		2035	struct wlr_session_lock_v1 *session_lock = data;
		2036	SessionLock *lock;
		2037	wlr_scene_node_set_enabled(&locked_bg->node, 1);
		2038	if (cur_lock) {
		2039	wlr_session_lock_v1_destroy(session_lock);
		2040	return;
		2041	}
		2042	lock = session_lock->data = ecalloc(1, sizeof(*lock));
		2043	focusclient(NULL, 0);
		2044
		2045	lock->scene = wlr_scene_tree_create(layers[LyrBlock]);
		2046	cur_lock = lock->lock = session_lock;
		2047	locked = 1;
		2048
		2049	LISTEN(&session_lock->events.new_surface, &lock->new_surface, createlocksurface);
		2050	LISTEN(&session_lock->events.destroy, &lock->destroy, destroysessionlock);
		2051	LISTEN(&session_lock->events.unlock, &lock->unlock, unlocksession);
		2052
		2053	wlr_session_lock_v1_send_locked(session_lock);
		2054	}
		2055
		2056	void
		2057	mapnotify(struct wl_listener listener, void data)
		2058	{
		2059	/* Called when the surface is mapped, or ready to display on-screen. */
		2060	Client *p = NULL;
		2061	Client w, c = wl_container_of(listener, c, map);
		2062	Monitor *m;
		2063	int i;
		2064
		2065	/* Create scene tree for this client and its border */
		2066	c->scene = client_surface(c)->data = wlr_scene_tree_create(layers[LyrTile]);
		2067	/* Enabled later by a call to arrange() */
		2068	wlr_scene_node_set_enabled(&c->scene->node, client_is_unmanaged(c));
		2069	c->scene_surface = c->type == XDGShell
		2070	? wlr_scene_xdg_surface_create(c->scene, c->surface.xdg)
		2071	: wlr_scene_subsurface_tree_create(c->scene, client_surface(c));
		2072	c->scene->node.data = c->scene_surface->node.data = c;
		2073
		2074	client_get_geometry(c, &c->geom);
		2075
		2076	/* Handle unmanaged clients first so we can return prior create borders */
		2077	if (client_is_unmanaged(c)) {
		2078	/* Unmanaged clients always are floating */
		2079	wlr_scene_node_reparent(&c->scene->node, layers[LyrFloat]);
		2080	wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
		2081	client_set_size(c, c->geom.width, c->geom.height);
		2082	if (client_wants_focus(c)) {
		2083	focusclient(c, 1);
		2084	exclusive_focus = c;
		2085	}
		2086	goto unset_fullscreen;
		2087	}
		2088
		2089	for (i = 0; i < 4; i++) {
		2090	c->inner_border[i] = wlr_scene_rect_create(c->scene, 0, 0,
		2091	c->isurgent ? cfg.appearance.inner_urgent_color : cfg.appearance.inner_border_color);
		2092	c->inner_border[i]->node.data = c;
		2093
		2094	c->outer_border[i] = wlr_scene_rect_create(c->scene, 0, 0,
		2095	c->isurgent ? cfg.appearance.outer_urgent_color : cfg.appearance.outer_border_color);
		2096	c->outer_border[i]->node.data = c;
		2097	}
		2098
		2099	createforeigntoplevel(c);
		2100
		2101	/* Initialize client geometry with room for border */
		2102	client_set_tiled(c, WLR_EDGE_TOP \| WLR_EDGE_BOTTOM \| WLR_EDGE_LEFT \| WLR_EDGE_RIGHT);
		2103	c->geom.width += 2 * c->bw;
		2104	c->geom.height += 2 * c->bw;
		2105
		2106	/* Insert this client into client lists. */
		2107	wl_list_insert(&clients, &c->link);
		2108	wl_list_insert(&fstack, &c->flink);
		2109
		2110	/* Set initial monitor, tags, floating status, and focus:
		2111	* we always consider floating, clients that have parent and thus
		2112	* we set the same tags and monitor as its parent.
		2113	* If there is no parent, apply rules */
		2114	if ((p = client_get_parent(c))) {
		2115	c->isfloating = 1;
		2116	setmon(c, p->mon, p->tags);
		2117	} else {
		2118	applyrules(c);
		2119	}
		2120	printstatus();
		2121
		2122	unset_fullscreen:
		2123	m = c->mon ? c->mon : xytomon(c->geom.x, c->geom.y);
		2124	wl_list_for_each(w, &clients, link) {
		2125	if (w != c && w != p && w->isfullscreen && m == w->mon && (w->tags & c->tags))
		2126	setfullscreen(w, 0);
		2127	}
		2128	}
		2129
		2130	void
		2131	maximizenotify(struct wl_listener listener, void data)
		2132	{
		2133	/* This event is raised when a client would like to maximize itself,
		2134	* typically because the user clicked on the maximize button on
		2135	* client-side decorations. swindle doesn't support maximization, but
		2136	* to conform to xdg-shell protocol we still must send a configure.
		2137	* Since xdg-shell protocol v5 we should ignore request of unsupported
		2138	* capabilities, just schedule a empty configure when the client uses <5
		2139	* protocol version
		2140	* wlr_xdg_surface_schedule_configure() is used to send an empty reply. */
		2141	Client *c = wl_container_of(listener, c, maximize);
		2142	if (c->surface.xdg->initialized
		2143	&& wl_resource_get_version(c->surface.xdg->toplevel->resource)
		2144	< XDG_TOPLEVEL_STATE_TILED_BOTTOM_SINCE_VERSION)
		2145	wlr_xdg_surface_schedule_configure(c->surface.xdg);
		2146	}
		2147
		2148
		2149	void
		2150	motionabsolute(struct wl_listener listener, void data)
		2151	{
		2152	/* This event is forwarded by the cursor when a pointer emits an _absolute_
		2153	* motion event, from 0..1 on each axis. This happens, for example, when
		2154	* wlroots is running under a Wayland window rather than KMS+DRM, and you
		2155	* move the mouse over the window. You could enter the window from any edge,
		2156	* so we have to warp the mouse there. Also, some hardware emits these events. */
		2157	struct wlr_pointer_motion_absolute_event *event = data;
		2158	double lx, ly, dx, dy;
		2159
		2160	if (!event->time_msec) /* this is 0 with virtual pointers */
		2161	wlr_cursor_warp_absolute(cursor, &event->pointer->base, event->x, event->y);
		2162
		2163	wlr_cursor_absolute_to_layout_coords(cursor, &event->pointer->base, event->x, event->y, &lx, &ly);
		2164	dx = lx - cursor->x;
		2165	dy = ly - cursor->y;
		2166	motionnotify(event->time_msec, &event->pointer->base, dx, dy, dx, dy);
		2167	}
		2168
		2169	void
		2170	motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double dy,
		2171	double dx_unaccel, double dy_unaccel)
		2172	{
		2173	double sx = 0, sy = 0, sx_confined, sy_confined;
		2174	Client c = NULL, w = NULL;
		2175	LayerSurface *l = NULL;
		2176	struct wlr_surface *surface = NULL;
		2177	struct wlr_pointer_constraint_v1 *constraint;
		2178
		2179	/* Find the client under the pointer and send the event along. */
		2180	xytonode(cursor->x, cursor->y, &surface, &c, NULL, &sx, &sy);
		2181
		2182	if (cursor_mode == CurPressed && !seat->drag
		2183	&& surface != seat->pointer_state.focused_surface
		2184	&& toplevel_from_wlr_surface(seat->pointer_state.focused_surface, &w, &l) >= 0) {
		2185	c = w;
		2186	surface = seat->pointer_state.focused_surface;
		2187	sx = cursor->x - (l ? l->scene->node.x : w->geom.x);
		2188	sy = cursor->y - (l ? l->scene->node.y : w->geom.y);
		2189	}
		2190
		2191	/* time is 0 in internal calls meant to restore pointer focus. */
		2192	if (time) {
		2193	wlr_relative_pointer_manager_v1_send_relative_motion(
		2194	relative_pointer_mgr, seat, (uint64_t)time * 1000,
		2195	dx, dy, dx_unaccel, dy_unaccel);
		2196
		2197	wl_list_for_each(constraint, &pointer_constraints->constraints, link)
		2198	cursorconstrain(constraint);
		2199
		2200	if (active_constraint && cursor_mode != CurResize && cursor_mode != CurMove) {
		2201	toplevel_from_wlr_surface(active_constraint->surface, &c, NULL);
		2202	if (c && active_constraint->surface == seat->pointer_state.focused_surface) {
		2203	sx = cursor->x - c->geom.x - c->bw;
		2204	sy = cursor->y - c->geom.y - c->bw;
		2205	if (wlr_region_confine(&active_constraint->region, sx, sy,
		2206	sx + dx, sy + dy, &sx_confined, &sy_confined)) {
		2207	dx = sx_confined - sx;
		2208	dy = sy_confined - sy;
		2209	}
		2210
		2211	if (active_constraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED)
		2212	return;
		2213	}
		2214	}
		2215
		2216	wlr_cursor_move(cursor, device, dx, dy);
		2217	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
		2218
		2219	if (cfg.sloppyfocus)
		2220	selmon = xytomon(cursor->x, cursor->y);
		2221	}
		2222
		2223	/* Update drag icon's position */
		2224	wlr_scene_node_set_position(&drag_icon->node, (int)round(cursor->x), (int)round(cursor->y));
		2225
		2226	/* If we are currently grabbing the mouse, handle and return */
		2227	if (cursor_mode == CurMove) {
		2228	/* Move the grabbed client to the new position. */
		2229	resize(grabc, (struct wlr_box){.x = (int)round(cursor->x) - grabcx, .y = (int)round(cursor->y) - grabcy,
		2230	.width = grabc->geom.width, .height = grabc->geom.height}, 1);
		2231	return;
		2232	} else if (cursor_mode == CurResize) {
		2233	resize(grabc, (struct wlr_box){.x = grabc->geom.x, .y = grabc->geom.y,
		2234	.width = (int)round(cursor->x) - grabc->geom.x, .height = (int)round(cursor->y) - grabc->geom.y}, 1);
		2235	return;
		2236	} else if (cursor_mode == CurTileDrag) {
		2237	resize(grabc, (struct wlr_box){
		2238	.x = (int)round(cursor->x) - grabcx,
		2239	.y = (int)round(cursor->y) - grabcy,
		2240	.width = TILEDRAG_DETACH_W,
		2241	.height = TILEDRAG_DETACH_H,
		2242	}, 1);
		2243
		2244	/* tiled_client_at, not xytonode: grabc is on LyrFloat now and
		2245	* covers whatever's under the cursor, so a scene hit-test would
		2246	* just find grabc itself and stop. */
		2247	Client *target = tiled_client_at(cursor->x, cursor->y, grabc);
		2248
		2249	if (target) {
		2250	preselect_target = target;
		2251	preselect_edge = edge_at_point(target->geom, cursor->x, cursor->y);
		2252	} else {
		2253	preselect_target = NULL;
		2254	preselect_edge = EDGE_NONE;
		2255	}
		2256
		2257	if (preselect_target && preselect_edge != EDGE_NONE) {
		2258	struct wlr_box ind = preselect_indicator_box(preselect_target->geom, preselect_edge);
		2259	wlr_scene_node_set_position(&preselect_indicator->node, ind.x, ind.y);
		2260	wlr_scene_rect_set_size(preselect_indicator, ind.width, ind.height);
		2261	wlr_scene_node_set_enabled(&preselect_indicator->node, true);
		2262	} else {
		2263	wlr_scene_node_set_enabled(&preselect_indicator->node, false);
		2264	}
		2265	return;
		2266	}
		2267
		2268	/* If there's no client surface under the cursor, set the cursor image to a
		2269	* default. This is what makes the cursor image appear when you move it
		2270	* off of a client or over its border. */
		2271	if (!surface && !seat->drag)
		2272	wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
		2273
		2274	pointerfocus(c, surface, sx, sy, time);
		2275	}
		2276
		2277	void
		2278	motionrelative(struct wl_listener listener, void data)
		2279	{
		2280	/* This event is forwarded by the cursor when a pointer emits a _relative_
		2281	* pointer motion event (i.e. a delta) */
		2282	struct wlr_pointer_motion_event *event = data;
		2283	/* The cursor doesn't move unless we tell it to. The cursor automatically
		2284	* handles constraining the motion to the output layout, as well as any
		2285	* special configuration applied for the specific input device which
		2286	* generated the event. You can pass NULL for the device if you want to move
		2287	* the cursor around without any input. */
		2288	motionnotify(event->time_msec, &event->pointer->base, event->delta_x, event->delta_y,
		2289	event->unaccel_dx, event->unaccel_dy);
		2290	}
		2291
		2292	void
		2293	moveresize(const Arg *arg)
		2294	{
		2295	if (cursor_mode != CurNormal && cursor_mode != CurPressed)
		2296	return;
		2297	xytonode(cursor->x, cursor->y, NULL, &grabc, NULL, NULL, NULL);
		2298	if (!grabc \|\| client_is_unmanaged(grabc) \|\| grabc->isfullscreen)
		2299	return;
		2300
		2301	if (arg->ui == CurMove && !grabc->isfloating
		2302	&& grabc->mon->lt[grabc->mon->sellt]->arrange) {
		2303	cursor_mode = CurTileDrag;
		2304	tiledrag_orig_geom = grabc->geom;
		2305	grabcx = TILEDRAG_DETACH_W / 2;
		2306	grabcy = TILEDRAG_DETACH_H / 2;
		2307	wlr_scene_node_reparent(&grabc->scene->node, layers[LyrFloat]);
		2308	resize(grabc, (struct wlr_box){
		2309	.x = (int)round(cursor->x) - grabcx,
		2310	.y = (int)round(cursor->y) - grabcy,
		2311	.width = TILEDRAG_DETACH_W,
		2312	.height = TILEDRAG_DETACH_H,
		2313	}, 1);
		2314	wlr_cursor_set_xcursor(cursor, cursor_mgr, "grabbing");
		2315	return;
		2316	}
		2317
		2318	/* Float the window and tell motionnotify to grab it */
		2319	setfloating(grabc, 1);
		2320	switch (cursor_mode = arg->ui) {
		2321	case CurMove:
		2322	grabcx = (int)round(cursor->x) - grabc->geom.x;
		2323	grabcy = (int)round(cursor->y) - grabc->geom.y;
		2324	wlr_cursor_set_xcursor(cursor, cursor_mgr, "all-scroll");
		2325	break;
		2326	case CurResize:
		2327	/* Doesn't work for X11 output - the next absolute motion event
		2328	* returns the cursor to where it started */
		2329	wlr_cursor_warp_closest(cursor, NULL,
		2330	grabc->geom.x + grabc->geom.width,
		2331	grabc->geom.y + grabc->geom.height);
		2332	wlr_cursor_set_xcursor(cursor, cursor_mgr, "se-resize");
		2333	break;
		2334	}
		2335	}
		2336
		2337	void
		2338	outputmgrapply(struct wl_listener listener, void data)
		2339	{
		2340	struct wlr_output_configuration_v1 *config = data;
		2341	outputmgrapplyortest(config, 0);
		2342	}
		2343
		2344	void
		2345	outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test)
		2346	{
		2347	/*
		2348	* Called when a client such as wlr-randr requests a change in output
		2349	* configuration. This is only one way that the layout can be changed,
		2350	* so any Monitor information should be updated by updatemons() after an
		2351	* output_layout.change event, not here.
		2352	*/
		2353	struct wlr_output_configuration_head_v1 *config_head;
		2354	int ok = 1;
		2355
		2356	wl_list_for_each(config_head, &config->heads, link) {
		2357	struct wlr_output *wlr_output = config_head->state.output;
		2358	Monitor *m = wlr_output->data;
		2359	struct wlr_output_state state;
		2360
		2361	/* Ensure displays previously disabled by wlr-output-power-management-v1
		2362	* are properly handled*/
		2363	m->asleep = 0;
		2364
		2365	wlr_output_state_init(&state);
		2366	wlr_output_state_set_enabled(&state, config_head->state.enabled);
		2367	if (!config_head->state.enabled)
		2368	goto apply_or_test;
		2369
		2370	if (config_head->state.mode)
		2371	wlr_output_state_set_mode(&state, config_head->state.mode);
		2372	else
		2373	wlr_output_state_set_custom_mode(&state,
		2374	config_head->state.custom_mode.width,
		2375	config_head->state.custom_mode.height,
		2376	config_head->state.custom_mode.refresh);
		2377
		2378	wlr_output_state_set_transform(&state, config_head->state.transform);
		2379	wlr_output_state_set_scale(&state, config_head->state.scale);
		2380	wlr_output_state_set_adaptive_sync_enabled(&state,
		2381	config_head->state.adaptive_sync_enabled);
		2382
		2383	apply_or_test:
		2384	ok &= test ? wlr_output_test_state(wlr_output, &state)
		2385	: wlr_output_commit_state(wlr_output, &state);
		2386
		2387	/* Don't move monitors if position wouldn't change. This avoids
		2388	* wlroots marking the output as manually configured.
		2389	* wlr_output_layout_add does not like disabled outputs */
		2390	if (!test && wlr_output->enabled && (m->m.x != config_head->state.x \|\| m->m.y != config_head->state.y))
		2391	wlr_output_layout_add(output_layout, wlr_output,
		2392	config_head->state.x, config_head->state.y);
		2393
		2394	wlr_output_state_finish(&state);
		2395	}
		2396
		2397	if (ok)
		2398	wlr_output_configuration_v1_send_succeeded(config);
		2399	else
		2400	wlr_output_configuration_v1_send_failed(config);
		2401	wlr_output_configuration_v1_destroy(config);
		2402
		2403	updatemons(NULL, NULL);
		2404	}
		2405
		2406	void
		2407	outputmgrtest(struct wl_listener listener, void data)
		2408	{
		2409	struct wlr_output_configuration_v1 *config = data;
		2410	outputmgrapplyortest(config, 1);
		2411	}
		2412
		2413	void
		2414	pointerfocus(Client c, struct wlr_surface surface, double sx, double sy,
		2415	uint32_t time)
		2416	{
		2417	struct timespec now;
		2418
		2419	if (surface != seat->pointer_state.focused_surface &&
		2420	cfg.sloppyfocus && time && c && !client_is_unmanaged(c))
		2421	focusclient(c, 0);
		2422
		2423	/* If surface is NULL, clear pointer focus */
		2424	if (!surface) {
		2425	wlr_seat_pointer_notify_clear_focus(seat);
		2426	return;
		2427	}
		2428
		2429	if (!time) {
		2430	clock_gettime(CLOCK_MONOTONIC, &now);
		2431	time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
		2432	}
		2433
		2434	/* Let the client know that the mouse cursor has entered one
		2435	* of its surfaces, and make keyboard focus follow if desired.
		2436	* wlroots makes this a no-op if surface is already focused */
		2437	wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
		2438	wlr_seat_pointer_notify_motion(seat, time, sx, sy);
		2439	}
		2440
		2441	void
		2442	printstatus(void)
		2443	{
		2444	Monitor *m = NULL;
		2445	Client *c;
		2446	uint32_t occ, urg, sel;
		2447
		2448	wl_list_for_each(m, &mons, link) {
		2449	occ = urg = 0;
		2450	wl_list_for_each(c, &clients, link) {
		2451	if (c->mon != m)
		2452	continue;
		2453	occ \|= c->tags;
		2454	if (c->isurgent)
		2455	urg \|= c->tags;
		2456	}
		2457	if ((c = focustop(m))) {
		2458	printf("%s title %s\n", m->wlr_output->name, client_get_title(c));
		2459	printf("%s appid %s\n", m->wlr_output->name, client_get_appid(c));
		2460	printf("%s fullscreen %d\n", m->wlr_output->name, c->isfullscreen);
		2461	printf("%s floating %d\n", m->wlr_output->name, c->isfloating);
		2462	sel = c->tags;
		2463	} else {
		2464	printf("%s title \n", m->wlr_output->name);
		2465	printf("%s appid \n", m->wlr_output->name);
		2466	printf("%s fullscreen \n", m->wlr_output->name);
		2467	printf("%s floating \n", m->wlr_output->name);
		2468	sel = 0;
		2469	}
		2470
		2471	printf("%s selmon %u\n", m->wlr_output->name, m == selmon);
		2472	printf("%s tags %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32"\n",
		2473	m->wlr_output->name, occ, m->tagset[m->seltags], sel, urg);
		2474	printf("%s layout %s\n", m->wlr_output->name, m->ltsymbol);
		2475	ext_workspace_printstatus(m);
		2476	}
		2477	fflush(stdout);
		2478	ipc_printstatus();
		2479	}
		2480
		2481	void
		2482	powermgrsetmode(struct wl_listener listener, void data)
		2483	{
		2484	struct wlr_output_power_v1_set_mode_event *event = data;
		2485	struct wlr_output_state state = {0};
		2486	Monitor *m = event->output->data;
		2487
		2488	if (!m)
		2489	return;
		2490
		2491	m->gamma_lut_changed = 1; /* Reapply gamma LUT when re-enabling the output */
		2492	wlr_output_state_set_enabled(&state, event->mode);
		2493	wlr_output_commit_state(m->wlr_output, &state);
		2494
		2495	m->asleep = !event->mode;
		2496	updatemons(NULL, NULL);
		2497	}
		2498
		2499	void
		2500	quit(const Arg *arg)
		2501	{
		2502	wl_display_terminate(dpy);
		2503	}
		2504
		2505	void
		2506	rendermon(struct wl_listener listener, void data)
		2507	{
		2508	/* This function is called every time an output is ready to display a frame,
		2509	* generally at the output's refresh rate (e.g. 60Hz). */
		2510	Monitor *m = wl_container_of(listener, m, frame);
		2511	Client *c;
		2512	struct wlr_output_state pending = {0};
		2513	struct timespec now;
		2514
		2515	/* Render if no XDG clients have an outstanding resize and are visible on
		2516	* this monitor. */
		2517	wl_list_for_each(c, &clients, link) {
		2518	/* re-apply opacity every frame instead of trusting a single
		2519	* set-on-focus-change call to stick */
		2520	client_apply_opacity(c);
		2521	if (c->resize && !c->isfloating && client_is_rendered_on_mon(c, m) && !client_is_stopped(c))
		2522	goto skip;
		2523	}
		2524
		2525	wlr_scene_output_commit(m->scene_output, NULL);
		2526
		2527	skip:
		2528	/* Let clients know a frame has been rendered */
		2529	clock_gettime(CLOCK_MONOTONIC, &now);
		2530	wlr_scene_output_send_frame_done(m->scene_output, &now);
		2531	wlr_output_state_finish(&pending);
		2532	}
		2533
		2534	void
		2535	requestdecorationmode(struct wl_listener listener, void data)
		2536	{
		2537	Client *c = wl_container_of(listener, c, set_decoration_mode);
		2538	if (c->surface.xdg->initialized)
		2539	wlr_xdg_toplevel_decoration_v1_set_mode(c->decoration,
		2540	WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
		2541	}
		2542
		2543	void
		2544	requeststartdrag(struct wl_listener listener, void data)
		2545	{
		2546	struct wlr_seat_request_start_drag_event *event = data;
		2547
		2548	if (wlr_seat_validate_pointer_grab_serial(seat, event->origin,
		2549	event->serial))
		2550	wlr_seat_start_pointer_drag(seat, event->drag, event->serial);
		2551	else
		2552	wlr_data_source_destroy(event->drag->source);
		2553	}
		2554
		2555	void
		2556	requestmonstate(struct wl_listener listener, void data)
		2557	{
		2558	struct wlr_output_event_request_state *event = data;
		2559	wlr_output_commit_state(event->output, event->state);
		2560	updatemons(NULL, NULL);
		2561	}
		2562
		2563	void
		2564	resize(Client *c, struct wlr_box geo, int interact)
		2565	{
		2566	struct wlr_box *bbox;
		2567	struct wlr_box clip;
		2568
		2569	if (!c->mon \|\| !client_surface(c)->mapped)
		2570	return;
		2571
		2572	bbox = interact ? &sgeom : &c->mon->w;
		2573
		2574	client_set_bounds(c, geo.width, geo.height);
		2575	c->geom = geo;
		2576	applybounds(c, bbox);
		2577
		2578	/* Update scene-graph, including borders.
		2579	* Outer ring sits flush with the client's outer edge (0,0 .. w,h).
		2580	* Inner ring is inset by obw from the outer ring.
		2581	* The surface itself is inset by the full bw = ibw + obw. */
		2582	{
		2583	unsigned int ib = c->ibw, ob = c->obw;
		2584	int w = c->geom.width, h = c->geom.height;
		2585
		2586	wlr_scene_node_set_position(&c->scene->node, c->geom.x, c->geom.y);
		2587	wlr_scene_node_set_position(&c->scene_surface->node, c->bw, c->bw);
		2588
		2589	wlr_scene_rect_set_size(c->inner_border[0], MAX(1, w - 2 * (int)ob), (int)ib);
		2590	wlr_scene_node_set_position(&c->inner_border[0]->node, ob, ob);
		2591	wlr_scene_rect_set_size(c->inner_border[1], MAX(1, w - 2 * (int)ob), (int)ib);
		2592	wlr_scene_node_set_position(&c->inner_border[1]->node, ob, MAX(0, h - (int)ob - (int)ib));
		2593	wlr_scene_rect_set_size(c->inner_border[2], (int)ib, MAX(1, h - 2 * (int)ob));
		2594	wlr_scene_node_set_position(&c->inner_border[2]->node, ob, ob);
		2595	wlr_scene_rect_set_size(c->inner_border[3], (int)ib, MAX(1, h - 2 * (int)ob));
		2596	wlr_scene_node_set_position(&c->inner_border[3]->node, MAX(0, w - (int)ob - (int)ib), ob);
		2597
		2598	wlr_scene_rect_set_size(c->outer_border[0], MAX(1, w), (int)ob);
		2599	wlr_scene_node_set_position(&c->outer_border[0]->node, 0, 0);
		2600	wlr_scene_rect_set_size(c->outer_border[1], MAX(1, w), (int)ob);
		2601	wlr_scene_node_set_position(&c->outer_border[1]->node, 0, MAX(0, h - (int)ob));
		2602	wlr_scene_rect_set_size(c->outer_border[2], (int)ob, MAX(1, h - 2 * (int)ob));
		2603	wlr_scene_node_set_position(&c->outer_border[2]->node, 0, ob);
		2604	wlr_scene_rect_set_size(c->outer_border[3], (int)ob, MAX(1, h - 2 * (int)ob));
		2605	wlr_scene_node_set_position(&c->outer_border[3]->node, MAX(0, w - (int)ob), ob);
		2606	}
		2607
		2608	/* this is a no-op if size hasn't changed */
		2609	c->resize = client_set_size(c, c->geom.width - 2 * c->bw,
		2610	c->geom.height - 2 * c->bw);
		2611	client_get_clip(c, &clip);
		2612	wlr_scene_subsurface_tree_set_clip(&c->scene_surface->node, &clip);
		2613	}
		2614
		2615	void
		2616	run(char *startup_cmd)
		2617	{
		2618	/* Add a Unix socket to the Wayland display. */
		2619	const char *socket = wl_display_add_socket_auto(dpy);
		2620	if (!socket)
		2621	die("startup: display_add_socket_auto");
		2622	setenv("WAYLAND_DISPLAY", socket, 1);
		2623
		2624	/* Start the backend. This will enumerate outputs and inputs, become the DRM
		2625	* master, etc */
		2626	if (!wlr_backend_start(backend))
		2627	die("startup: backend_start");
		2628
		2629	/* Now that the socket exists and the backend is started, run the startup command */
		2630	if (startup_cmd) {
		2631	int piperw[2];
		2632	if (pipe(piperw) < 0)
		2633	die("startup: pipe:");
		2634	if ((child_pid = fork()) < 0)
		2635	die("startup: fork:");
		2636	if (child_pid == 0) {
		2637	setsid();
		2638	dup2(piperw[0], STDIN_FILENO);
		2639	close(piperw[0]);
		2640	close(piperw[1]);
		2641	execl("/bin/sh", "/bin/sh", "-c", startup_cmd, NULL);
		2642	die("startup: execl:");
		2643	}
		2644	dup2(piperw[1], STDOUT_FILENO);
		2645	close(piperw[1]);
		2646	close(piperw[0]);
		2647	}
		2648
		2649	/* Mark stdout as non-blocking as to avoid the startup script
		2650	* causing swindle to freeze when a user neither closes stdin
		2651	* nor consumes standard input in their startup script */
		2652
		2653	if (fd_set_nonblock(STDOUT_FILENO) < 0)
		2654	close(STDOUT_FILENO);
		2655
		2656	printstatus();
		2657
		2658	/* Launch autostart commands now that the socket is live and the backend
		2659	* is running. Commands run sequentially in a detached child process so
		2660	* the compositor never blocks. */
		2661	config_autostart_run(&cfg);
		2662
		2663	/* At this point the outputs are initialized, choose initial selmon based on
		2664	* cursor position, and set default cursor image */
		2665	selmon = xytomon(cursor->x, cursor->y);
		2666
		2667	wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y);
		2668	wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
		2669
		2670	/* Run the Wayland event loop. This does not return until you exit the
		2671	* compositor. Starting the backend rigged up all of the necessary event
		2672	* loop configuration to listen to libinput events, DRM events, generate
		2673	* frame events at the refresh rate, and so on. */
		2674	wl_display_run(dpy);
		2675	}
		2676
		2677	void
		2678	setcursor(struct wl_listener listener, void data)
		2679	{
		2680	/* This event is raised by the seat when a client provides a cursor image */
		2681	struct wlr_seat_pointer_request_set_cursor_event *event = data;
		2682	/* If we're "grabbing" the cursor, don't use the client's image, we will
		2683	* restore it after "grabbing" sending a leave event, followed by a enter
		2684	* event, which will result in the client requesting set the cursor surface */
		2685	if (cursor_mode != CurNormal && cursor_mode != CurPressed)
		2686	return;
		2687	/* This can be sent by any client, so we check to make sure this one
		2688	* actually has pointer focus first. If so, we can tell the cursor to
		2689	* use the provided surface as the cursor image. It will set the
		2690	* hardware cursor on the output that it's currently on and continue to
		2691	* do so as the cursor moves between outputs. */
		2692	if (event->seat_client == seat->pointer_state.focused_client)
		2693	wlr_cursor_set_surface(cursor, event->surface,
		2694	event->hotspot_x, event->hotspot_y);
		2695	}
		2696
		2697	void
		2698	setcursorshape(struct wl_listener listener, void data)
		2699	{
		2700	struct wlr_cursor_shape_manager_v1_request_set_shape_event *event = data;
		2701	if (cursor_mode != CurNormal && cursor_mode != CurPressed)
		2702	return;
		2703	/* This can be sent by any client, so we check to make sure this one
		2704	* actually has pointer focus first. If so, we can tell the cursor to
		2705	* use the provided cursor shape. */
		2706	if (event->seat_client == seat->pointer_state.focused_client)
		2707	wlr_cursor_set_xcursor(cursor, cursor_mgr,
		2708	wlr_cursor_shape_v1_name(event->shape));
		2709	}
		2710
		2711	void
		2712	setfloating(Client *c, int floating)
		2713	{
		2714	Client *p = client_get_parent(c);
		2715	c->isfloating = floating;
		2716	/* If in floating layout do not change the client's layer */
		2717	if (!c->mon \|\| !client_surface(c)->mapped \|\| !c->mon->lt[c->mon->sellt]->arrange)
		2718	return;
		2719	wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen \|\|
		2720	(p && p->isfullscreen) ? LyrFS
		2721	: c->isfloating ? LyrFloat : LyrTile]);
		2722	arrange(c->mon);
		2723	printstatus();
		2724	}
		2725
		2726	void
		2727	setfullscreen(Client *c, int fullscreen)
		2728	{
		2729	c->isfullscreen = fullscreen;
		2730	if (!c->mon \|\| !client_surface(c)->mapped)
		2731	return;
		2732	c->ibw = fullscreen ? 0 : cfg.appearance.inner_border_px;
		2733	c->obw = fullscreen ? 0 : cfg.appearance.outer_border_px;
		2734	c->bw = c->ibw + c->obw;
		2735	client_set_fullscreen(c, fullscreen);
		2736	if (c->foreign_toplevel)
		2737	wlr_foreign_toplevel_handle_v1_set_fullscreen(c->foreign_toplevel, fullscreen);
		2738	wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen
		2739	? LyrFS : c->isfloating ? LyrFloat : LyrTile]);
		2740
		2741	if (fullscreen) {
		2742	client_set_opacity(c, 1.0f);
		2743	c->prev = c->geom;
		2744	resize(c, c->mon->m, 0);
		2745	} else {
		2746	client_set_opacity(c, client_surface(c) == seat->keyboard_state.focused_surface
		2747	? cfg.appearance.active_opacity : cfg.appearance.inactive_opacity);
		2748	resize(c, c->prev, 0);
		2749	}
		2750	arrange(c->mon);
		2751	printstatus();
		2752	}
		2753
		2754	void
		2755	setlayout(const Arg *arg)
		2756	{
		2757	if (!selmon)
		2758	return;
		2759	/* arg->ui is an index into layouts[]. If out of range, just toggle. */
		2760	if (arg && arg->ui < LENGTH(layouts)) {
		2761	if (selmon->lt[selmon->sellt] != &layouts[arg->ui])
		2762	selmon->sellt ^= 1;
		2763	selmon->lt[selmon->sellt] = &layouts[arg->ui];
		2764	} else {
		2765	selmon->sellt ^= 1;
		2766	}
		2767	strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, LENGTH(selmon->ltsymbol));
		2768	arrange(selmon);
		2769	printstatus();
		2770	}
		2771
		2772	/* arg > 1.0 will set mfact absolutely */
		2773
		2774	void
		2775	setmon(Client c, Monitor m, uint32_t newtags)
		2776	{
		2777	Monitor *oldmon = c->mon;
		2778
		2779	if (oldmon == m)
		2780	return;
		2781	c->mon = m;
		2782	c->prev = c->geom;
		2783
		2784	/* Scene graph sends surface leave/enter events on move and resize */
		2785	if (oldmon) {
		2786	if (c->foreign_toplevel)
		2787	wlr_foreign_toplevel_handle_v1_output_leave(c->foreign_toplevel, oldmon->wlr_output);
		2788	arrange(oldmon);
		2789	}
		2790	if (m) {
		2791	/* Make sure window actually overlaps with the monitor */
		2792	resize(c, c->geom, 0);
		2793	c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
		2794	if (c->foreign_toplevel)
		2795	wlr_foreign_toplevel_handle_v1_output_enter(c->foreign_toplevel, m->wlr_output);
		2796	setfullscreen(c, c->isfullscreen); /* This will call arrange(c->mon) */
		2797	setfloating(c, c->isfloating);
		2798	}
		2799	focusclient(focustop(selmon), 1);
		2800	}
		2801
		2802	void
		2803	setpsel(struct wl_listener listener, void data)
		2804	{
		2805	/* This event is raised by the seat when a client wants to set the selection,
		2806	* usually when the user copies something. wlroots allows compositors to
		2807	* ignore such requests if they so choose, but in dwl we always honor them
		2808	*/
		2809	struct wlr_seat_request_set_primary_selection_event *event = data;
		2810	wlr_seat_set_primary_selection(seat, event->source, event->serial);
		2811	}
		2812
		2813	void
		2814	setsel(struct wl_listener listener, void data)
		2815	{
		2816	/* This event is raised by the seat when a client wants to set the selection,
		2817	* usually when the user copies something. wlroots allows compositors to
		2818	* ignore such requests if they so choose, but in dwl we always honor them
		2819	*/
		2820	struct wlr_seat_request_set_selection_event *event = data;
		2821	wlr_seat_set_selection(seat, event->source, event->serial);
		2822	}
		2823
		2824	/* Config hot reload callback is fired by the inotify watcher */
		2825
		2826	static void
		2827	reapply_client_appearance(void)
		2828	{
		2829	Client *c;
		2830	wl_list_for_each(c, &clients, link) {
		2831	if (!c->mon \|\| client_is_unmanaged(c))
		2832	continue;
		2833	if (c == focustop(c->mon)) {
		2834	client_set_border_color(c, cfg.appearance.inner_focus_color, cfg.appearance.outer_focus_color);
		2835	client_set_opacity(c, cfg.appearance.active_opacity);
		2836	} else {
		2837	client_set_border_color(c, cfg.appearance.inner_border_color, cfg.appearance.outer_border_color);
		2838	client_set_opacity(c, cfg.appearance.inactive_opacity);
		2839	}
		2840	}
		2841	}
		2842
		2843	static void
		2844	reapply_client_borders(void)
		2845	{
		2846	Client *c;
		2847	wl_list_for_each(c, &clients, link) {
		2848	if (client_is_unmanaged(c) \|\| c->isfullscreen)
		2849	continue;
		2850	unsigned int ibw = cfg.appearance.inner_border_px;
		2851	unsigned int obw = cfg.appearance.outer_border_px;
		2852	if (c->ibw == ibw && c->obw == obw)
		2853	continue;
		2854	c->ibw = ibw;
		2855	c->obw = obw;
		2856	c->bw = ibw + obw;
		2857	if (c->isfloating)
		2858	resize(c, c->geom, 0);
		2859	}
		2860	}
		2861
		2862	static void
		2863	on_config_reload(const Config newcfg, void ud)
		2864	{
		2865	Monitor *m;
		2866	(void)ud;
		2867	cfg = *newcfg;
		2868	reapply_client_borders();
		2869	wl_list_for_each(m, &mons, link)
		2870	arrange(m);
		2871	reapply_client_appearance();
		2872	printstatus();
		2873	}
		2874
		2875	void
		2876	setup(void)
		2877	{
		2878	int drm_fd, i, sig[] = {SIGCHLD, SIGINT, SIGTERM, SIGPIPE};
		2879	struct sigaction sa = {.sa_flags = SA_RESTART, .sa_handler = handlesig};
		2880	sigemptyset(&sa.sa_mask);
		2881
		2882	for (i = 0; i < (int)LENGTH(sig); i++)
		2883	sigaction(sig[i], &sa, NULL);
		2884
		2885	/* Load config before anything else so all settings are ready */
		2886	{
		2887	char cfgpath[1024];
		2888	const char *path;
		2889	int debug_override = (cfg.log_level == WLR_DEBUG); /* set by -d flag in main() */
		2890	if (custom_cfg_path)
		2891	path = custom_cfg_path;
		2892	else {
		2893	config_get_path(cfgpath, sizeof(cfgpath));
		2894	path = cfgpath;
		2895	}
		2896	if (config_load(path, &cfg) < 0)
		2897	die("failed to load config from '%s'", path);
		2898	if (debug_override)
		2899	cfg.log_level = WLR_DEBUG;
		2900	}
		2901
		2902	wlr_log_init(cfg.log_level, NULL);
		2903
		2904	/* The Wayland display is managed by libwayland. It handles accepting
		2905	* clients from the Unix socket, managing Wayland globals, and so on and so forth */
		2906	dpy = wl_display_create();
		2907	event_loop = wl_display_get_event_loop(dpy);
		2908	ipc_init();
		2909	workspaces_init();
		2910
		2911	/* Start the inotify config watcher */
		2912
		2913	{
		2914	char cfgpath[1024];
		2915	const char *path = custom_cfg_path;
		2916	if (!path) {
		2917	config_get_path(cfgpath, sizeof(cfgpath));
		2918	path = cfgpath;
		2919	}
		2920	cfg_watch_src = config_watch_start(event_loop, path,
		2921	on_config_reload, NULL);
		2922	}
		2923
		2924	/* The backend is a wlroots feature which abstracts the underlying input and
		2925	* output hardware. The autocreate option will choose the most suitable
		2926	* backend based on the current environment, such as opening an X11 window
		2927	* if an X11 server is running. */
		2928	if (!(backend = wlr_backend_autocreate(event_loop, &session)))
		2929	die("couldn't create backend");
		2930
		2931	/* Initialize the scene graph used to lay out windows */
		2932	scene = wlr_scene_create();
		2933	root_bg = wlr_scene_rect_create(&scene->tree, 0, 0, cfg.appearance.root_color);
		2934	for (i = 0; i < NUM_LAYERS; i++)
		2935	layers[i] = wlr_scene_tree_create(&scene->tree);
		2936	drag_icon = wlr_scene_tree_create(&scene->tree);
		2937	wlr_scene_node_place_below(&drag_icon->node, &layers[LyrBlock]->node);
		2938
		2939	{
		2940	static const float preselect_color[4] = {1.0f, 1.0f, 1.0f, 0.25f};
		2941	preselect_indicator = wlr_scene_rect_create(layers[LyrOverlay], 0, 0, preselect_color);
		2942	wlr_scene_node_set_enabled(&preselect_indicator->node, false);
		2943	}
		2944
		2945	/* Autocreates a renderer, either Pixman, GLES2 or Vulkan for us. The user
		2946	* can also specify a renderer using the WLR_RENDERER env var.
		2947	* The renderer is responsible for defining the various pixel formats it
		2948	* supports for shared memory, this configures that for clients. */
		2949	if (!(drw = wlr_renderer_autocreate(backend)))
		2950	die("couldn't create renderer");
		2951	wl_signal_add(&drw->events.lost, &gpu_reset);
		2952
		2953	/* Create shm, drm and linux_dmabuf interfaces by ourselves.
		2954	* The simplest way is to call:
		2955	* wlr_renderer_init_wl_display(drw);
		2956	* but we need to create the linux_dmabuf interface manually to integrate it
		2957	* with wlr_scene. */
		2958	wlr_renderer_init_wl_shm(drw, dpy);
		2959
		2960	if (wlr_renderer_get_texture_formats(drw, WLR_BUFFER_CAP_DMABUF)) {
		2961	wlr_drm_create(dpy, drw);
		2962	wlr_scene_set_linux_dmabuf_v1(scene,
		2963	wlr_linux_dmabuf_v1_create_with_renderer(dpy, 5, drw));
		2964	}
		2965
		2966	if ((drm_fd = wlr_renderer_get_drm_fd(drw)) >= 0 && drw->features.timeline
		2967	&& backend->features.timeline)
		2968	wlr_linux_drm_syncobj_manager_v1_create(dpy, 1, drm_fd);
		2969
		2970	/* Autocreates an allocator for us.
		2971	* The allocator is the bridge between the renderer and the backend. It
		2972	* handles the buffer creation, allowing wlroots to render onto the
		2973	* screen */
		2974	if (!(alloc = wlr_allocator_autocreate(backend, drw)))
		2975	die("couldn't create allocator");
		2976
		2977	/* This creates some hands-off wlroots interfaces. The compositor is
		2978	* necessary for clients to allocate surfaces and the data device manager
		2979	* handles the clipboard. Each of these wlroots interfaces has room for you
		2980	* to dig your fingers in and play with their behavior if you want. Note that
		2981	* the clients cannot set the selection directly without compositor approval,
		2982	* see the setsel() function. */
		2983	compositor = wlr_compositor_create(dpy, 6, drw);
		2984	wlr_subcompositor_create(dpy);
		2985	wlr_data_device_manager_create(dpy);
		2986	wlr_export_dmabuf_manager_v1_create(dpy);
		2987	wlr_screencopy_manager_v1_create(dpy);
		2988	wlr_data_control_manager_v1_create(dpy);
		2989	wlr_ext_data_control_manager_v1_create(dpy, 1);
		2990	wlr_primary_selection_v1_device_manager_create(dpy);
		2991	wlr_viewporter_create(dpy);
		2992	wlr_single_pixel_buffer_manager_v1_create(dpy);
		2993	wlr_fractional_scale_manager_v1_create(dpy, 1);
		2994	wlr_presentation_create(dpy, backend, 2);
		2995	wlr_alpha_modifier_v1_create(dpy);
		2996
		2997	foreign_toplevel_mgr = wlr_foreign_toplevel_manager_v1_create(dpy);
		2998
		2999	/* Initializes the interface used to implement urgency hints */
		3000	activation = wlr_xdg_activation_v1_create(dpy);
		3001	wl_signal_add(&activation->events.request_activate, &request_activate);
		3002
		3003	wlr_scene_set_gamma_control_manager_v1(scene, wlr_gamma_control_manager_v1_create(dpy));
		3004
		3005	power_mgr = wlr_output_power_manager_v1_create(dpy);
		3006	wl_signal_add(&power_mgr->events.set_mode, &output_power_mgr_set_mode);
		3007
		3008	/* Creates an output layout, which is a wlroots utility for working with an
		3009	* arrangement of screens in a physical layout. */
		3010	output_layout = wlr_output_layout_create(dpy);
		3011	wl_signal_add(&output_layout->events.change, &layout_change);
		3012
		3013	wlr_xdg_output_manager_v1_create(dpy, output_layout);
		3014
		3015	/* Configure a listener to be notified when new outputs are available on the
		3016	* backend. */
		3017	wl_list_init(&mons);
		3018	wl_signal_add(&backend->events.new_output, &new_output);
		3019
		3020	/* Set up our client lists, the xdg-shell and the layer-shell. The xdg-shell is a
		3021	* Wayland protocol which is used for application windows. For more
		3022	* detail on shells, refer to the article:
		3023	*
		3024	* https://drewdevault.com/2018/07/29/Wayland-shells.html
		3025	*/
		3026	wl_list_init(&clients);
		3027	wl_list_init(&fstack);
		3028
		3029	xdg_shell = wlr_xdg_shell_create(dpy, 6);
		3030	wl_signal_add(&xdg_shell->events.new_toplevel, &new_xdg_toplevel);
		3031	wl_signal_add(&xdg_shell->events.new_popup, &new_xdg_popup);
		3032
		3033	layer_shell = wlr_layer_shell_v1_create(dpy, 3);
		3034	wl_signal_add(&layer_shell->events.new_surface, &new_layer_surface);
		3035
		3036	idle_notifier = wlr_idle_notifier_v1_create(dpy);
		3037
		3038	idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy);
		3039	wl_signal_add(&idle_inhibit_mgr->events.new_inhibitor, &new_idle_inhibitor);
		3040
		3041	session_lock_mgr = wlr_session_lock_manager_v1_create(dpy);
		3042	wl_signal_add(&session_lock_mgr->events.new_lock, &new_session_lock);
		3043	locked_bg = wlr_scene_rect_create(layers[LyrBlock], sgeom.width, sgeom.height,
		3044	(float [4]){0.1f, 0.1f, 0.1f, 1.0f});
		3045	wlr_scene_node_set_enabled(&locked_bg->node, 0);
		3046
		3047	/* Use decoration protocols to negotiate server-side decorations */
		3048	wlr_server_decoration_manager_set_default_mode(
		3049	wlr_server_decoration_manager_create(dpy),
		3050	WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
		3051	xdg_decoration_mgr = wlr_xdg_decoration_manager_v1_create(dpy);
		3052	wl_signal_add(&xdg_decoration_mgr->events.new_toplevel_decoration, &new_xdg_decoration);
		3053
		3054	pointer_constraints = wlr_pointer_constraints_v1_create(dpy);
		3055	wl_signal_add(&pointer_constraints->events.new_constraint, &new_pointer_constraint);
		3056
		3057	relative_pointer_mgr = wlr_relative_pointer_manager_v1_create(dpy);
		3058
		3059	/*
		3060	* Creates a cursor, which is a wlroots utility for tracking the cursor
		3061	* image shown on screen.
		3062	*/
		3063	cursor = wlr_cursor_create();
		3064	wlr_cursor_attach_output_layout(cursor, output_layout);
		3065
		3066	/* Creates an xcursor manager, another wlroots utility which loads up
		3067	* Xcursor themes to source cursor images from and makes sure that cursor
		3068	* images are available at all scale factors on the screen (necessary for
		3069	* HiDPI support). Scaled cursors will be loaded with each output. */
		3070	cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
		3071	setenv("XCURSOR_SIZE", "24", 1);
		3072
		3073	/*
		3074	* wlr_cursor only displays an image on screen. It does not move around
		3075	* when the pointer moves. However, we can attach input devices to it, and
		3076	* it will generate aggregate events for all of them. In these events, we
		3077	* can choose how we want to process them, forwarding them to clients and
		3078	* moving the cursor around. More detail on this process is described in
		3079	* https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
		3080	*
		3081	* And more comments are sprinkled throughout the notify functions above.
		3082	*/
		3083	wl_signal_add(&cursor->events.motion, &cursor_motion);
		3084	wl_signal_add(&cursor->events.motion_absolute, &cursor_motion_absolute);
		3085	wl_signal_add(&cursor->events.button, &cursor_button);
		3086	wl_signal_add(&cursor->events.axis, &cursor_axis);
		3087	wl_signal_add(&cursor->events.frame, &cursor_frame);
		3088
		3089	cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);
		3090	wl_signal_add(&cursor_shape_mgr->events.request_set_shape, &request_set_cursor_shape);
		3091
		3092	/*
		3093	* Configures a seat, which is a single "seat" at which a user sits and
		3094	* operates the computer. This conceptually includes up to one keyboard,
		3095	* pointer, touch, and drawing tablet device. We also rig up a listener to
		3096	* let us know when new input devices are available on the backend.
		3097	*/
		3098	wl_signal_add(&backend->events.new_input, &new_input_device);
		3099	virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);
		3100	wl_signal_add(&virtual_keyboard_mgr->events.new_virtual_keyboard,
		3101	&new_virtual_keyboard);
		3102	virtual_pointer_mgr = wlr_virtual_pointer_manager_v1_create(dpy);
		3103	wl_signal_add(&virtual_pointer_mgr->events.new_virtual_pointer,
		3104	&new_virtual_pointer);
		3105
		3106	seat = wlr_seat_create(dpy, "seat0");
		3107	wl_signal_add(&seat->events.request_set_cursor, &request_cursor);
		3108	wl_signal_add(&seat->events.request_set_selection, &request_set_sel);
		3109	wl_signal_add(&seat->events.request_set_primary_selection, &request_set_psel);
		3110	wl_signal_add(&seat->events.request_start_drag, &request_start_drag);
		3111	wl_signal_add(&seat->events.start_drag, &start_drag);
		3112
		3113	kb_group = createkeyboardgroup();
		3114	wl_list_init(&kb_group->destroy.link);
		3115
		3116	output_mgr = wlr_output_manager_v1_create(dpy);
		3117	wl_signal_add(&output_mgr->events.apply, &output_mgr_apply);
		3118	wl_signal_add(&output_mgr->events.test, &output_mgr_test);
		3119
		3120	/* Make sure XWayland clients don't connect to the parent X server,
		3121	* e.g when running in the x11 backend or the wayland backend and the
		3122	* compositor has Xwayland support */
		3123	unsetenv("DISPLAY");
		3124	#ifdef XWAYLAND
		3125	/*
		3126	* Initialise the XWayland X server.
		3127	* It will be started when the first X client is started.
		3128	*/
		3129	if ((xwayland = wlr_xwayland_create(dpy, compositor, 1))) {
		3130	wl_signal_add(&xwayland->events.ready, &xwayland_ready);
		3131	wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
		3132
		3133	setenv("DISPLAY", xwayland->display_name, 1);
		3134	} else {
		3135	fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
		3136	}
		3137	#endif
		3138	}
		3139
		3140	void
		3141	spawn(const Arg *arg)
		3142	{
		3143	if (fork() == 0) {
		3144	dup2(STDERR_FILENO, STDOUT_FILENO);
		3145	setsid();
		3146	execvp(((char )arg->v)[0], (char )arg->v);
		3147	die("dwl: execvp %s failed:", ((char **)arg->v)[0]);
		3148	}
		3149	}
		3150
		3151	void
		3152	startdrag(struct wl_listener listener, void data)
		3153	{
		3154	struct wlr_drag *drag = data;
		3155	if (!drag->icon)
		3156	return;
		3157
		3158	drag->icon->data = &wlr_scene_drag_icon_create(drag_icon, drag->icon)->node;
		3159	LISTEN_STATIC(&drag->icon->events.destroy, destroydragicon);
		3160	}
		3161
		3162	void
		3163	tag(const Arg *arg)
		3164	{
		3165	Client *sel = focustop(selmon);
		3166	if (!sel \|\| (arg->ui & TAGMASK) == 0)
		3167	return;
		3168
		3169	/* Remove from the source tag's dwindle tree */
		3170	dwindle_remove_client(sel);
		3171	sel->tags = arg->ui & TAGMASK;
		3172	focusclient(focustop(selmon), 1);
		3173	arrange(selmon);
		3174	printstatus();
		3175	}
		3176
		3177	void
		3178	tagmon(const Arg *arg)
		3179	{
		3180	Client *sel = focustop(selmon);
		3181	if (sel)
		3182	setmon(sel, dirtomon(arg->i), 0);
		3183	}
		3184
		3185
		3186	/* dwindle helpers */
		3187
		3188	/*
		3189	* Returns the 0-based index of the lowest set tag bit for monitor m.
		3190	* For single-tag views this is the exact tag. For multi-tag views it
		3191	* picks the lowest bit */
		3192
		3193	static inline int
		3194	current_tag_idx(Monitor *m)
		3195	{
		3196	uint32_t tags = m->tagset[m->seltags] & TAGMASK;
		3197	if (!tags)
		3198	return 0;
		3199	int idx = 0;
		3200	while (!(tags & 1u)) { tags >>= 1; idx++; }
		3201	return idx < TAGCOUNT ? idx : 0;
		3202	}
		3203
		3204	static DwindleNode *
		3205	dwindle_new_node(void)
		3206	{
		3207	DwindleNode n = ecalloc(1, sizeof(n));
		3208	n->split_ratio = 1.0f;
		3209	return n;
		3210	}
		3211
		3212	void
		3213	dwindle_free_tree(DwindleNode *n)
		3214	{
		3215	if (!n)
		3216	return;
		3217	dwindle_free_tree(n->children[0]);
		3218	dwindle_free_tree(n->children[1]);
		3219	free(n);
		3220	}
		3221
		3222	static DwindleNode *
		3223	dwindle_find_leaf(DwindleNode n, Client c)
		3224	{
		3225	if (!n)
		3226	return NULL;
		3227	if (!n->is_node)
		3228	return n->client == c ? n : NULL;
		3229	DwindleNode *r = dwindle_find_leaf(n->children[0], c);
		3230	return r ? r : dwindle_find_leaf(n->children[1], c);
		3231	}
		3232
		3233	static DwindleNode *
		3234	dwindle_first_leaf(DwindleNode *n)
		3235	{
		3236	if (!n)
		3237	return NULL;
		3238	while (n->is_node)
		3239	n = n->children[0];
		3240	return n;
		3241	}
		3242
		3243	/*
		3244	* Recursively distribute geometry downward from node n
		3245	* gap is inner gap pixels between the two halves
		3246	*/
		3247
		3248	static void
		3249	dwindle_recalc(DwindleNode *n, int gap)
		3250	{
		3251	if (!n)
		3252	return;
		3253
		3254	if (!n->is_node) {
		3255	if (n->client && !n->client->isfullscreen)
		3256	resize(n->client, n->box, 0);
		3257	return;
		3258	}
		3259
		3260	/* Wider than tall -> split left/right; taller -> split top/bottom. */
		3261	n->split_top = (n->box.height > n->box.width);
		3262
		3263	if (!n->split_top) {
		3264	int w1 = MAX(1, (int)(n->box.width / 2.0f * n->split_ratio) - gap / 2);
		3265	n->children[0]->box = (struct wlr_box){
		3266	n->box.x, n->box.y, w1, n->box.height
		3267	};
		3268	n->children[1]->box = (struct wlr_box){
		3269	n->box.x + w1 + gap, n->box.y,
		3270	MAX(1, n->box.width - w1 - gap), n->box.height
		3271	};
		3272	} else {
		3273	int h1 = MAX(1, (int)(n->box.height / 2.0f * n->split_ratio) - gap / 2);
		3274	n->children[0]->box = (struct wlr_box){
		3275	n->box.x, n->box.y, n->box.width, h1
		3276	};
		3277	n->children[1]->box = (struct wlr_box){
		3278	n->box.x, n->box.y + h1 + gap,
		3279	n->box.width, MAX(1, n->box.height - h1 - gap)
		3280	};
		3281	}
		3282
		3283	dwindle_recalc(n->children[0], gap);
		3284	dwindle_recalc(n->children[1], gap);
		3285	}
		3286
		3287	static int
		3288	dwindle_insert_at_edge(DwindleNode *root, Client new_c, Client *target, DwindleEdge edge)
		3289	{
		3290	DwindleNode opening_on = dwindle_find_leaf(root, target);
		3291	if (!opening_on)
		3292	return 0;
		3293
		3294	DwindleNode *new_leaf = dwindle_new_node();
		3295	new_leaf->client = new_c;
		3296	new_leaf->is_node = 0;
		3297
		3298	DwindleNode *new_parent = dwindle_new_node();
		3299	new_parent->is_node = 1;
		3300	new_parent->box = opening_on->box;
		3301	new_parent->parent = opening_on->parent;
		3302
		3303	int new_c_first = (edge == EDGE_LEFT \|\| edge == EDGE_TOP);
		3304	new_parent->split_top = (edge == EDGE_TOP \|\| edge == EDGE_BOTTOM);
		3305	new_parent->children[new_c_first ? 0 : 1] = new_leaf;
		3306	new_parent->children[new_c_first ? 1 : 0] = opening_on;
		3307
		3308	opening_on->parent = new_parent;
		3309	new_leaf->parent = new_parent;
		3310
		3311	if (new_parent->parent) {
		3312	if (new_parent->parent->children[0] == opening_on)
		3313	new_parent->parent->children[0] = new_parent;
		3314	else
		3315	new_parent->parent->children[1] = new_parent;
		3316	} else {
		3317	*root = new_parent;
		3318	}
		3319	return 1;
		3320	}
		3321
		3322	/*
		3323	* Insert new_c into the tree, bisecting the focused client's node
		3324	* It falls back to the first leaf if focused is NULL or not in the tree
		3325	*/
		3326
		3327	static void
		3328	dwindle_insert(DwindleNode *root, Client new_c, Client focused, DwindleHint hint)
		3329	{
		3330	DwindleNode *new_leaf = dwindle_new_node();
		3331	new_leaf->client = new_c;
		3332	new_leaf->is_node = 0;
		3333
		3334	if (!*root) {
		3335	*root = new_leaf;
		3336	return;
		3337	}
		3338
		3339	DwindleNode *opening_on = focused
		3340	? dwindle_find_leaf(*root, focused) : NULL;
		3341	if (!opening_on)
		3342	opening_on = dwindle_first_leaf(*root);
		3343
		3344	if (hint) {
		3345	int split_top = (opening_on->box.height > opening_on->box.width);
		3346	hint->old_box = opening_on->box;
		3347	hint->edge = split_top ? EDGE_BOTTOM : EDGE_RIGHT;
		3348	}
		3349
		3350	DwindleNode *new_parent = dwindle_new_node();
		3351	new_parent->is_node = 1;
		3352	new_parent->box = opening_on->box;
		3353	new_parent->parent = opening_on->parent;
		3354	new_parent->split_top = (opening_on->box.height > opening_on->box.width);
		3355	new_parent->children[0] = opening_on;
		3356	new_parent->children[1] = new_leaf;
		3357
		3358	opening_on->parent = new_parent;
		3359	new_leaf->parent = new_parent;
		3360
		3361	if (new_parent->parent) {
		3362	if (new_parent->parent->children[0] == opening_on)
		3363	new_parent->parent->children[0] = new_parent;
		3364	else
		3365	new_parent->parent->children[1] = new_parent;
		3366	} else {
		3367	*root = new_parent;
		3368	}
		3369	}
		3370
		3371	/*
		3372	* Remove client c from the tree, promoting its sibling upward.
		3373	*/
		3374
		3375	static void
		3376	dwindle_remove(DwindleNode *root, Client c, DwindleHint *hint)
		3377	{
		3378	DwindleNode leaf = dwindle_find_leaf(root, c);
		3379	if (!leaf)
		3380	return;
		3381
		3382	DwindleNode *parent = leaf->parent;
		3383	if (!parent) {
		3384	free(leaf);
		3385	*root = NULL;
		3386	return;
		3387	}
		3388
		3389	int leaf_is_first = (parent->children[0] == leaf);
		3390	DwindleNode *sibling = leaf_is_first
		3391	? parent->children[1] : parent->children[0];
		3392	DwindleNode *grandparent = parent->parent;
		3393
		3394	if (hint) {
		3395	hint->old_box = sibling->box;
		3396	hint->edge = parent->split_top
		3397	? (leaf_is_first ? EDGE_TOP : EDGE_BOTTOM)
		3398	: (leaf_is_first ? EDGE_LEFT : EDGE_RIGHT);
		3399	}
		3400
		3401	sibling->parent = grandparent;
		3402	if (grandparent) {
		3403	if (grandparent->children[0] == parent)
		3404	grandparent->children[0] = sibling;
		3405	else
		3406	grandparent->children[1] = sibling;
		3407	} else {
		3408	*root = sibling;
		3409	}
		3410
		3411	free(leaf);
		3412	free(parent);
		3413	}
		3414
		3415	/* Remove c from every monitor's per-tag tree and call from unmapnotify(). */
		3416
		3417	static void
		3418	dwindle_remove_client(Client *c)
		3419	{
		3420	Monitor *m;
		3421	wl_list_for_each(m, &mons, link)
		3422	for (int i = 0; i < TAGCOUNT; i++)
		3423	dwindle_remove(&m->dwindle_root[i], c, NULL);
		3424	}
		3425
		3426	#define PRESELECT_MARGIN 0.2
		3427
		3428	static DwindleEdge
		3429	edge_at_point(struct wlr_box box, double x, double y)
		3430	{
		3431	double rel_x = (x - box.x) / MAX(1, box.width);
		3432	double rel_y = (y - box.y) / MAX(1, box.height);
		3433
		3434	/* Distance from each edge, in the same normalized 0..1 space. */
		3435	double d_left = rel_x;
		3436	double d_right = 1.0 - rel_x;
		3437	double d_top = rel_y;
		3438	double d_bottom = 1.0 - rel_y;
		3439
		3440	double closest = MIN(MIN(d_left, d_right), MIN(d_top, d_bottom));
		3441	if (closest > PRESELECT_MARGIN)
		3442	return EDGE_NONE;
		3443
		3444	if (closest == d_left) return EDGE_LEFT;
		3445	if (closest == d_right) return EDGE_RIGHT;
		3446	if (closest == d_top) return EDGE_TOP;
		3447	return EDGE_BOTTOM;
		3448	}
		3449
		3450	static struct wlr_box
		3451	preselect_indicator_box(struct wlr_box target, DwindleEdge edge)
		3452	{
		3453	struct wlr_box r = target;
		3454	switch (edge) {
		3455	case EDGE_LEFT: r.width /= 2; break;
		3456	case EDGE_RIGHT: r.width /= 2; r.x += target.width - r.width; break;
		3457	case EDGE_TOP: r.height /= 2; break;
		3458	case EDGE_BOTTOM: r.height /= 2; r.y += target.height - r.height; break;
		3459	default: break;
		3460	}
		3461	return r;
		3462	}
		3463
		3464	/* layout entry point */
		3465
		3466	void
		3467	dwindle(Monitor *m)
		3468	{
		3469	Client *c;
		3470	int n = 0, e;
		3471	Client *dragging = (cursor_mode == CurTileDrag) ? grabc : NULL;
		3472
		3473	wl_list_for_each(c, &clients, link)
		3474	if (c != dragging && VISIBLEON(c, m) && !c->isfloating && !c->isfullscreen)
		3475	n++;
		3476
		3477	if (n == 0)
		3478	return;
		3479
		3480	e = (m->gaps && !(cfg.appearance.smart_gaps && n == 1)) ? (int)cfg.appearance.gaps : 0;
		3481
		3482	int ti = current_tag_idx(m);
		3483	DwindleNode **root = &m->dwindle_root[ti];
		3484
		3485	/* prune leaves whose clients are no longer tiled here */
		3486	{
		3487	DwindleNode *stack[512];
		3488	Client *stale[512];
		3489	int sp = 0, sc = 0;
		3490
		3491	if (*root)
		3492	stack[sp++] = *root;
		3493
		3494	while (sp > 0) {
		3495	DwindleNode *nd = stack[--sp];
		3496	if (!nd->is_node) {
		3497	int found = 0;
		3498	if (nd->client == dragging) {
		3499	/* Treat the dragged client as "still present" so it
		3500	* isn't pruned out from under itself mid-gesture. */
		3501	found = 1;
		3502	} else {
		3503	wl_list_for_each(c, &clients, link) {
		3504	if (c == nd->client
		3505	&& VISIBLEON(c, m)
		3506	&& !c->isfloating) {
		3507	found = 1;
		3508	break;
		3509	}
		3510	}
		3511	}
		3512	if (!found && sc < 512)
		3513	stale[sc++] = nd->client;
		3514	} else {
		3515	if (nd->children[1]) stack[sp++] = nd->children[1];
		3516	if (nd->children[0]) stack[sp++] = nd->children[0];
		3517	}
		3518	}
		3519
		3520	for (int i = 0; i < sc; i++)
		3521	dwindle_remove(root, stale[i], NULL); /* TODO: wire to animation (soon tm) */
		3522	}
		3523
		3524	/* insert any newly visible client, splitting the focused node.
		3525	* Use m->dwindle_focus[ti] so it actually splits what the user
		3526	* was looking at when they spawned the window, rather than whatever
		3527	* focustop() happens to return */
		3528
		3529	Client *focused = m->dwindle_focus[ti];
		3530
		3531	wl_list_for_each(c, &clients, link) {
		3532	if (!VISIBLEON(c, m) \|\| c->isfloating \|\| c->isfullscreen \|\| c == dragging)
		3533	continue;
		3534	if (!dwindle_find_leaf(*root, c)) {
		3535	dwindle_insert(root, c, focused, NULL); /* TODO: wire to animation once that lands */
		3536	focused = c;
		3537	}
		3538	}
		3539
		3540	/* assign root box and recurse */
		3541	if (*root) {
		3542	(*root)->box = (struct wlr_box){
		3543	m->w.x + e,
		3544	m->w.y + e,
		3545	MAX(1, m->w.width - 2 * e),
		3546	MAX(1, m->w.height - 2 * e),
		3547	};
		3548	dwindle_recalc(*root, e);
		3549	}
		3550	}
		3551
		3552	void
		3553	togglefloating(const Arg *arg)
		3554	{
		3555	Client *sel = focustop(selmon);
		3556	/* return if fullscreen */
		3557	if (sel && !sel->isfullscreen)
		3558	setfloating(sel, !sel->isfloating);
		3559	}
		3560
		3561	void
		3562	togglefullscreen(const Arg *arg)
		3563	{
		3564	Client *sel = focustop(selmon);
		3565	if (sel)
		3566	setfullscreen(sel, !sel->isfullscreen);
		3567	}
		3568
		3569	void
		3570	togglegaps(const Arg *arg)
		3571	{
		3572	selmon->gaps = !selmon->gaps;
		3573	arrange(selmon);
		3574	}
		3575
		3576	/* swapdir is essentially focusdir but swap */
		3577
		3578	void
		3579	swapdir(const Arg *arg)
		3580	{
		3581	Client c, other = NULL;
		3582	Client *sel = focustop(selmon);
		3583	int sx, sy, cx, cy;
		3584	double bestdist = 1e18, dist;
		3585
		3586	if (!sel \|\| sel->isfloating \|\| sel->isfullscreen)
		3587	return;
		3588
		3589	client_center(sel, &sx, &sy);
		3590
		3591	wl_list_for_each(c, &clients, link) {
		3592	if (c == sel \|\| !VISIBLEON(c, selmon) \|\| c->isfloating \|\| c->isfullscreen)
		3593	continue;
		3594
		3595	client_center(c, &cx, &cy);
		3596
		3597	switch (arg->i) {
		3598	case WLR_DIRECTION_LEFT: if (cx >= sx) continue; break;
		3599	case WLR_DIRECTION_RIGHT: if (cx <= sx) continue; break;
		3600	case WLR_DIRECTION_UP: if (cy >= sy) continue; break;
		3601	case WLR_DIRECTION_DOWN: if (cy <= sy) continue; break;
		3602	default: return;
		3603	}
		3604
		3605	dist = (double)(cx - sx) * (cx - sx) + (double)(cy - sy) * (cy - sy);
		3606	if (dist < bestdist) {
		3607	bestdist = dist;
		3608	other = c;
		3609	}
		3610	}
		3611
		3612	if (!other)
		3613	return;
		3614
		3615	if (selmon->lt[selmon->sellt]->arrange == dwindle) {
		3616	int ti = current_tag_idx(selmon);
		3617	DwindleNode **root = &selmon->dwindle_root[ti];
		3618	if (*root) {
		3619	DwindleNode leaf_sel = dwindle_find_leaf(root, sel);
		3620	DwindleNode leaf_other = dwindle_find_leaf(root, other);
		3621	if (leaf_sel && leaf_other) {
		3622	leaf_sel->client = other;
		3623	leaf_other->client = sel;
		3624	int e = (selmon->gaps && cfg.appearance.gaps) ? (int)cfg.appearance.gaps : 0;
		3625	(*root)->box = (struct wlr_box){
		3626	selmon->w.x + e,
		3627	selmon->w.y + e,
		3628	MAX(1, selmon->w.width - 2 * e),
		3629	MAX(1, selmon->w.height - 2 * e),
		3630	};
		3631	dwindle_recalc(*root, e);
		3632	}
		3633	}
		3634	} else {
		3635	struct wlr_box tmp = sel->geom;
		3636	resize(sel, other->geom, 0);
		3637	resize(other, tmp, 0);
		3638	}
		3639
		3640	focusclient(sel, 1);
		3641	printstatus();
		3642	}
		3643
		3644	void
		3645	swaptiled(Client a, Client b)
		3646	{
		3647	Monitor *m;
		3648	if (!a \|\| !b \|\| a == b)
		3649	return;
		3650
		3651	wl_list_for_each(m, &mons, link) {
		3652	for (int i = 0; i < TAGCOUNT; i++) {
		3653	DwindleNode **root = &m->dwindle_root[i];
		3654	if (!*root)
		3655	continue;
		3656	DwindleNode la = dwindle_find_leaf(root, a);
		3657	DwindleNode lb = dwindle_find_leaf(root, b);
		3658	if (!la \|\| !lb)
		3659	continue;
		3660	la->client = b;
		3661	lb->client = a;
		3662	int e = (m->gaps && cfg.appearance.gaps) ? (int)cfg.appearance.gaps : 0;
		3663	(*root)->box = (struct wlr_box){
		3664	m->w.x + e,
		3665	m->w.y + e,
		3666	MAX(1, m->w.width - 2 * e),
		3667	MAX(1, m->w.height - 2 * e),
		3668	};
		3669	dwindle_recalc(*root, e);
		3670	}
		3671	}
		3672
		3673	focusclient(a, 1);
		3674	printstatus();
		3675	}
		3676
		3677	void
		3678	dwindle_move_to_edge(Client a, Client b, DwindleEdge edge)
		3679	{
		3680	if (!a \|\| !b \|\| a == b \|\| edge == EDGE_NONE)
		3681	return;
		3682
		3683	DwindleNode **root = &b->mon->dwindle_root[current_tag_idx(b->mon)];
		3684	if (!dwindle_find_leaf(root, a) \|\| !dwindle_find_leaf(root, b))
		3685	return;
		3686
		3687	dwindle_remove(root, a, NULL);
		3688	if (!dwindle_insert_at_edge(root, a, b, edge))
		3689	return; /* shouldn't happen (b was just confirmed present above) */
		3690
		3691	int e = (b->mon->gaps && cfg.appearance.gaps) ? (int)cfg.appearance.gaps : 0;
		3692	(*root)->box = (struct wlr_box){
		3693	b->mon->w.x + e,
		3694	b->mon->w.y + e,
		3695	MAX(1, b->mon->w.width - 2 * e),
		3696	MAX(1, b->mon->w.height - 2 * e),
		3697	};
		3698	dwindle_recalc(*root, e);
		3699
		3700	focusclient(a, 1);
		3701	printstatus();
		3702	}
		3703
		3704	void
		3705	toggletag(const Arg *arg)
		3706	{
		3707	uint32_t newtags;
		3708	Client *sel = focustop(selmon);
		3709	if (!sel \|\| !(newtags = sel->tags ^ (arg->ui & TAGMASK)))
		3710	return;
		3711
		3712	dwindle_remove_client(sel);
		3713	sel->tags = newtags;
		3714	focusclient(focustop(selmon), 1);
		3715	arrange(selmon);
		3716	printstatus();
		3717	}
		3718
		3719	void
		3720	toggleview(const Arg *arg)
		3721	{
		3722	uint32_t newtagset;
		3723	if (!(newtagset = selmon ? selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK) : 0))
		3724	return;
		3725
		3726	selmon->tagset[selmon->seltags] = newtagset;
		3727	focusclient(focustop(selmon), 1);
		3728	arrange(selmon);
		3729	printstatus();
		3730	}
		3731
		3732	void
		3733	unlocksession(struct wl_listener listener, void data)
		3734	{
		3735	SessionLock *lock = wl_container_of(listener, lock, unlock);
		3736	destroylock(lock, 1);
		3737	}
		3738
		3739	void
		3740	unmaplayersurfacenotify(struct wl_listener listener, void data)
		3741	{
		3742	LayerSurface *l = wl_container_of(listener, l, unmap);
		3743
		3744	l->mapped = 0;
		3745	wlr_scene_node_set_enabled(&l->scene->node, 0);
		3746	if (l == exclusive_focus)
		3747	exclusive_focus = NULL;
		3748	if (l->layer_surface->output && (l->mon = l->layer_surface->output->data))
		3749	arrangelayers(l->mon);
		3750	if (l->layer_surface->surface == seat->keyboard_state.focused_surface)
		3751	focusclient(focustop(selmon), 1);
		3752	motionnotify(0, NULL, 0, 0, 0, 0);
		3753	}
		3754
		3755	void
		3756	unmapnotify(struct wl_listener listener, void data)
		3757	{
		3758	/* Called when the surface is unmapped, and should no longer be shown. */
		3759	Client *c = wl_container_of(listener, c, unmap);
		3760	if (c == grabc) {
		3761	cursor_mode = CurNormal;
		3762	grabc = NULL;
		3763	}
		3764
		3765	if (client_is_unmanaged(c)) {
		3766	if (c == exclusive_focus) {
		3767	exclusive_focus = NULL;
		3768	focusclient(focustop(selmon), 1);
		3769	}
		3770	} else {
		3771	wl_list_remove(&c->link);
		3772	dwindle_remove_client(c);
		3773	setmon(c, NULL, 0);
		3774	wl_list_remove(&c->flink);
		3775	}
		3776
		3777	if (c->foreign_toplevel) {
		3778	wlr_foreign_toplevel_handle_v1_destroy(c->foreign_toplevel);
		3779	c->foreign_toplevel = NULL;
		3780	}
		3781
		3782	wlr_scene_node_destroy(&c->scene->node);
		3783	printstatus();
		3784	motionnotify(0, NULL, 0, 0, 0, 0);
		3785	}
		3786
		3787	void
		3788	updatemons(struct wl_listener listener, void data)
		3789	{
		3790	/*
		3791	* Called whenever the output layout changes: adding or removing a
		3792	* monitor, changing an output's mode or position, etc. This is where
		3793	* the change officially happens and we update geometry, window
		3794	* positions, focus, and the stored configuration in wlroots'
		3795	* output-manager implementation.
		3796	*/
		3797	struct wlr_output_configuration_v1 *config
		3798	= wlr_output_configuration_v1_create();
		3799	Client *c;
		3800	struct wlr_output_configuration_head_v1 *config_head;
		3801	Monitor *m;
		3802
		3803	/* First remove from the layout the disabled monitors */
		3804	wl_list_for_each(m, &mons, link) {
		3805	if (m->wlr_output->enabled \|\| m->asleep)
		3806	continue;
		3807	config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output);
		3808	config_head->state.enabled = 0;
		3809	/* Remove this output from the layout to avoid cursor enter inside it */
		3810	wlr_output_layout_remove(output_layout, m->wlr_output);
		3811	closemon(m);
		3812	m->m = m->w = (struct wlr_box){0};
		3813	}
		3814	/* Insert outputs that need to */
		3815	wl_list_for_each(m, &mons, link) {
		3816	if (m->wlr_output->enabled
		3817	&& !wlr_output_layout_get(output_layout, m->wlr_output))
		3818	wlr_output_layout_add_auto(output_layout, m->wlr_output);
		3819	}
		3820
		3821	/* Now that we update the output layout we can get its box */
		3822	wlr_output_layout_get_box(output_layout, NULL, &sgeom);
		3823
		3824	wlr_scene_node_set_position(&root_bg->node, sgeom.x, sgeom.y);
		3825	wlr_scene_rect_set_size(root_bg, sgeom.width, sgeom.height);
		3826
		3827	/* Make sure the clients are hidden when dwl is locked */
		3828	wlr_scene_node_set_position(&locked_bg->node, sgeom.x, sgeom.y);
		3829	wlr_scene_rect_set_size(locked_bg, sgeom.width, sgeom.height);
		3830
		3831	wl_list_for_each(m, &mons, link) {
		3832	if (!m->wlr_output->enabled)
		3833	continue;
		3834	config_head = wlr_output_configuration_head_v1_create(config, m->wlr_output);
		3835
		3836	/* Get the effective monitor geometry to use for surfaces */
		3837	wlr_output_layout_get_box(output_layout, m->wlr_output, &m->m);
		3838	m->w = m->m;
		3839	wlr_scene_output_set_position(m->scene_output, m->m.x, m->m.y);
		3840
		3841	wlr_scene_node_set_position(&m->fullscreen_bg->node, m->m.x, m->m.y);
		3842	wlr_scene_rect_set_size(m->fullscreen_bg, m->m.width, m->m.height);
		3843
		3844	if (m->lock_surface) {
		3845	struct wlr_scene_tree *scene_tree = m->lock_surface->surface->data;
		3846	wlr_scene_node_set_position(&scene_tree->node, m->m.x, m->m.y);
		3847	wlr_session_lock_surface_v1_configure(m->lock_surface, m->m.width, m->m.height);
		3848	}
		3849
		3850	/* Calculate the effective monitor geometry to use for clients */
		3851	arrangelayers(m);
		3852	/* Don't move clients to the left output when plugging monitors */
		3853	arrange(m);
		3854	/* make sure fullscreen clients have the right size */
		3855	if ((c = focustop(m)) && c->isfullscreen)
		3856	resize(c, m->m, 0);
		3857
		3858	/* Try to re-set the gamma LUT when updating monitors,
		3859	* it's only really needed when enabling a disabled output, but meh. */
		3860	m->gamma_lut_changed = 1;
		3861
		3862	config_head->state.x = m->m.x;
		3863	config_head->state.y = m->m.y;
		3864
		3865	if (!selmon) {
		3866	selmon = m;
		3867	}
		3868	}
		3869
		3870	if (selmon && selmon->wlr_output->enabled) {
		3871	wl_list_for_each(c, &clients, link) {
		3872	if (!c->mon && client_surface(c)->mapped)
		3873	setmon(c, selmon, c->tags);
		3874	}
		3875	focusclient(focustop(selmon), 1);
		3876	if (selmon->lock_surface) {
		3877	client_notify_enter(selmon->lock_surface->surface,
		3878	wlr_seat_get_keyboard(seat));
		3879	client_activate_surface(selmon->lock_surface->surface, 1);
		3880	}
		3881	}
		3882
		3883	wlr_cursor_move(cursor, NULL, 0, 0);
		3884
		3885	wlr_output_manager_v1_set_configuration(output_mgr, config);
		3886	}
		3887
		3888	void
		3889	updatetitle(struct wl_listener listener, void data)
		3890	{
		3891	Client *c = wl_container_of(listener, c, set_title);
		3892	if (c->foreign_toplevel)
		3893	wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel, client_get_title(c));
		3894	if (c == focustop(c->mon))
		3895	printstatus();
		3896	}
		3897
		3898	void
		3899	urgent(struct wl_listener listener, void data)
		3900	{
		3901	struct wlr_xdg_activation_v1_request_activate_event *event = data;
		3902	Client *c = NULL;
		3903	toplevel_from_wlr_surface(event->surface, &c, NULL);
		3904	if (!c \|\| c == focustop(selmon))
		3905	return;
		3906
		3907	c->isurgent = 1;
		3908	printstatus();
		3909
		3910	if (client_surface(c)->mapped)
		3911	client_set_border_color(c, cfg.appearance.inner_urgent_color, cfg.appearance.outer_urgent_color);
		3912	}
		3913
		3914	void
		3915	view(const Arg *arg)
		3916	{
		3917	if (!selmon \|\| (arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
		3918	return;
		3919	selmon->seltags ^= 1; /* toggle sel tagset */
		3920	if (arg->ui & TAGMASK)
		3921	selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
		3922	focusclient(focustop(selmon), 1);
		3923	arrange(selmon);
		3924	printstatus();
		3925	}
		3926
		3927	void
		3928	virtualkeyboard(struct wl_listener listener, void data)
		3929	{
		3930	struct wlr_virtual_keyboard_v1 *kb = data;
		3931	/* virtual keyboards shouldn't share keyboard group */
		3932	KeyboardGroup *group = createkeyboardgroup();
		3933	/* Set the keymap to match the group keymap */
		3934	wlr_keyboard_set_keymap(&kb->keyboard, group->wlr_group->keyboard.keymap);
		3935	LISTEN(&kb->keyboard.base.events.destroy, &group->destroy, destroykeyboardgroup);
		3936
		3937	/* Add the new keyboard to the group */
		3938	wlr_keyboard_group_add_keyboard(group->wlr_group, &kb->keyboard);
		3939	}
		3940
		3941	void
		3942	virtualpointer(struct wl_listener listener, void data)
		3943	{
		3944	struct wlr_virtual_pointer_v1_new_pointer_event *event = data;
		3945	struct wlr_input_device *device = &event->new_pointer->pointer.base;
		3946
		3947	wlr_cursor_attach_input_device(cursor, device);
		3948	if (event->suggested_output)
		3949	wlr_cursor_map_input_to_output(cursor, device, event->suggested_output);
		3950	}
		3951
		3952	Monitor *
		3953	xytomon(double x, double y)
		3954	{
		3955	struct wlr_output *o = wlr_output_layout_output_at(output_layout, x, y);
		3956	return o ? o->data : NULL;
		3957	}
		3958
		3959	static Client *
		3960	tiled_client_at(double x, double y, Client *exclude)
		3961	{
		3962	Client *c;
		3963	wl_list_for_each(c, &clients, link) {
		3964	if (c == exclude \|\| c->isfloating \|\| c->isfullscreen)
		3965	continue;
		3966	if (!c->mon \|\| !VISIBLEON(c, c->mon))
		3967	continue;
		3968	if (c->mon->lt[c->mon->sellt]->arrange != dwindle)
		3969	continue;
		3970	if (x >= c->geom.x && x < c->geom.x + c->geom.width
		3971	&& y >= c->geom.y && y < c->geom.y + c->geom.height)
		3972	return c;
		3973	}
		3974	return NULL;
		3975	}
		3976
		3977	void
		3978	xytonode(double x, double y, struct wlr_surface **psurface,
		3979	Client pc, LayerSurface pl, double nx, double ny)
		3980	{
		3981	struct wlr_scene_node node, pnode;
		3982	struct wlr_surface *surface = NULL;
		3983	Client *c = NULL;
		3984	LayerSurface *l = NULL;
		3985	int layer;
		3986
		3987	for (layer = NUM_LAYERS - 1; !surface && layer >= 0; layer--) {
		3988	if (!(node = wlr_scene_node_at(&layers[layer]->node, x, y, nx, ny)))
		3989	continue;
		3990
		3991	if (node->type == WLR_SCENE_NODE_BUFFER)
		3992	surface = wlr_scene_surface_try_from_buffer(
		3993	wlr_scene_buffer_from_node(node))->surface;
		3994	/* Walk the tree to find a node that knows the client */
		3995	for (pnode = node; pnode && !c; pnode = &pnode->parent->node)
		3996	c = pnode->data;
		3997	if (c && c->type == LayerShell) {
		3998	c = NULL;
		3999	l = pnode->data;
		4000	}
		4001	}
		4002
		4003	if (psurface) *psurface = surface;
		4004	if (pc) *pc = c;
		4005	if (pl) *pl = l;
		4006	}
		4007
		4008
		4009	void
		4010	createforeigntoplevel(Client *c)
		4011	{
		4012	c->foreign_toplevel = wlr_foreign_toplevel_handle_v1_create(foreign_toplevel_mgr);
		4013
		4014	LISTEN(&c->foreign_toplevel->events.request_activate, &c->factivate, factivatenotify);
		4015	LISTEN(&c->foreign_toplevel->events.request_close, &c->fclose, fclosenotify);
		4016	LISTEN(&c->foreign_toplevel->events.request_fullscreen, &c->ffullscreen, ffullscreennotify);
		4017	LISTEN(&c->foreign_toplevel->events.destroy, &c->fdestroy, fdestroynotify);
		4018	}
		4019
		4020	void
		4021	factivatenotify(struct wl_listener listener, void data)
		4022	{
		4023	Client *c = wl_container_of(listener, c, factivate);
		4024	if (c->mon == selmon)
		4025	c->tags = c->mon->tagset[c->mon->seltags];
		4026	else
		4027	setmon(c, selmon, 0);
		4028	focusclient(c, 1);
		4029	arrange(c->mon);
		4030	}
		4031
		4032	void
		4033	fclosenotify(struct wl_listener listener, void data)
		4034	{
		4035	Client *c = wl_container_of(listener, c, fclose);
		4036	client_send_close(c);
		4037	}
		4038
		4039	void
		4040	ffullscreennotify(struct wl_listener listener, void data)
		4041	{
		4042	Client *c = wl_container_of(listener, c, ffullscreen);
		4043	struct wlr_foreign_toplevel_handle_v1_fullscreen_event *event = data;
		4044	setfullscreen(c, event->fullscreen);
		4045	}
		4046
		4047	void
		4048	fdestroynotify(struct wl_listener listener, void data)
		4049	{
		4050	Client *c = wl_container_of(listener, c, fdestroy);
		4051	wl_list_remove(&c->factivate.link);
		4052	wl_list_remove(&c->fclose.link);
		4053	wl_list_remove(&c->ffullscreen.link);
		4054	wl_list_remove(&c->fdestroy.link);
		4055	}
		4056
		4057	#ifdef XWAYLAND
		4058	void
		4059	activatex11(struct wl_listener listener, void data)
		4060	{
		4061	Client *c = wl_container_of(listener, c, activate);
		4062
		4063	/* Only "managed" windows can be activated */
		4064	if (!client_is_unmanaged(c))
		4065	wlr_xwayland_surface_activate(c->surface.xwayland, 1);
		4066	}
		4067
		4068	void
		4069	associatex11(struct wl_listener listener, void data)
		4070	{
		4071	Client *c = wl_container_of(listener, c, associate);
		4072
		4073	LISTEN(&client_surface(c)->events.map, &c->map, mapnotify);
		4074	LISTEN(&client_surface(c)->events.unmap, &c->unmap, unmapnotify);
		4075	}
		4076
		4077	void
		4078	configurex11(struct wl_listener listener, void data)
		4079	{
		4080	Client *c = wl_container_of(listener, c, configure);
		4081	struct wlr_xwayland_surface_configure_event *event = data;
		4082	if (!client_surface(c) \|\| !client_surface(c)->mapped) {
		4083	wlr_xwayland_surface_configure(c->surface.xwayland,
		4084	event->x, event->y, event->width, event->height);
		4085	return;
		4086	}
		4087	if (client_is_unmanaged(c)) {
		4088	wlr_scene_node_set_position(&c->scene->node, event->x, event->y);
		4089	wlr_xwayland_surface_configure(c->surface.xwayland,
		4090	event->x, event->y, event->width, event->height);
		4091	return;
		4092	}
		4093	if ((c->isfloating && c != grabc) \|\| !c->mon->lt[c->mon->sellt]->arrange) {
		4094	resize(c, (struct wlr_box){.x = event->x - c->bw,
		4095	.y = event->y - c->bw, .width = event->width + c->bw * 2,
		4096	.height = event->height + c->bw * 2}, 0);
		4097	} else {
		4098	arrange(c->mon);
		4099	}
		4100	}
		4101
		4102	void
		4103	createnotifyx11(struct wl_listener listener, void data)
		4104	{
		4105	struct wlr_xwayland_surface *xsurface = data;
		4106	Client *c;
		4107
		4108	/* Allocate a Client for this surface */
		4109	c = xsurface->data = ecalloc(1, sizeof(*c));
		4110	c->surface.xwayland = xsurface;
		4111	c->type = X11;
		4112	if (client_is_unmanaged(c)) {
		4113	c->ibw = c->obw = c->bw = 0;
		4114	} else {
		4115	c->ibw = cfg.appearance.inner_border_px;
		4116	c->obw = cfg.appearance.outer_border_px;
		4117	c->bw = c->ibw + c->obw;
		4118	}
		4119
		4120	/* Listen to the various events it can emit */
		4121	LISTEN(&xsurface->events.associate, &c->associate, associatex11);
		4122	LISTEN(&xsurface->events.destroy, &c->destroy, destroynotify);
		4123	LISTEN(&xsurface->events.dissociate, &c->dissociate, dissociatex11);
		4124	LISTEN(&xsurface->events.request_activate, &c->activate, activatex11);
		4125	LISTEN(&xsurface->events.request_configure, &c->configure, configurex11);
		4126	LISTEN(&xsurface->events.request_fullscreen, &c->fullscreen, fullscreennotify);
		4127	LISTEN(&xsurface->events.set_hints, &c->set_hints, sethints);
		4128	LISTEN(&xsurface->events.set_title, &c->set_title, updatetitle);
		4129	}
		4130
		4131	void
		4132	dissociatex11(struct wl_listener listener, void data)
		4133	{
		4134	Client *c = wl_container_of(listener, c, dissociate);
		4135	wl_list_remove(&c->map.link);
		4136	wl_list_remove(&c->unmap.link);
		4137	}
		4138
		4139	void
		4140	sethints(struct wl_listener listener, void data)
		4141	{
		4142	Client *c = wl_container_of(listener, c, set_hints);
		4143	struct wlr_surface *surface = client_surface(c);
		4144	if (c == focustop(selmon) \|\| !c->surface.xwayland->hints)
		4145	return;
		4146
		4147	c->isurgent = xcb_icccm_wm_hints_get_urgency(c->surface.xwayland->hints);
		4148	printstatus();
		4149
		4150	if (c->isurgent && surface && surface->mapped)
		4151	client_set_border_color(c, cfg.appearance.inner_urgent_color, cfg.appearance.outer_urgent_color);
		4152	}
		4153
		4154	void
		4155	xwaylandready(struct wl_listener listener, void data)
		4156	{
		4157	struct wlr_xcursor *xcursor;
		4158	struct wlr_xcursor_image *image;
		4159
		4160	/* assign the one and only seat */
		4161	wlr_xwayland_set_seat(xwayland, seat);
		4162
		4163	/* Set the default XWayland cursor to match the rest of swindle. */
		4164	if ((xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "default", 1))) {
		4165	image = xcursor->images[0];
		4166	wlr_xwayland_set_cursor(xwayland,
		4167	wlr_xcursor_image_get_buffer(image),
		4168	image->hotspot_x, image->hotspot_y);
		4169	}
		4170	}
		4171	#endif
		4172
		4173	int
		4174	main(int argc, char *argv[])
		4175	{
		4176	char *startup_cmd = NULL;
		4177	int c;
		4178
		4179	while ((c = getopt(argc, argv, "c:s:hdv")) != -1) {
		4180	switch (c) {
		4181	case 'c':
		4182	{
		4183	struct stat st;
		4184	if (stat(optarg, &st) < 0) {
		4185	if (errno == ENOENT)
		4186	die("error: config file '%s' does not exist", optarg);
		4187	die("error: config file '%s': %s", optarg, strerror(errno));
		4188	}
		4189	if (S_ISDIR(st.st_mode))
		4190	die("error: config file '%s' is a directory, expected a regular file", optarg);
		4191	if (access(optarg, R_OK) < 0)
		4192	die("error: config file '%s' is not readable (permission denied)", optarg);
		4193	custom_cfg_path = optarg;
		4194	break;
		4195	}
		4196	case 's':
		4197	startup_cmd = optarg;
		4198	break;
		4199	case 'd':
		4200	cfg.log_level = WLR_DEBUG; /* override before setup() */
		4201	break;
		4202	case 'v':
		4203	die("swindle " VERSION);
		4204	default:
		4205	goto usage;
		4206	}
		4207	}
		4208	if (optind < argc)
		4209	goto usage;
		4210
		4211	/* Wayland requires XDG_RUNTIME_DIR for creating its communications socket */
		4212	if (!getenv("XDG_RUNTIME_DIR"))
		4213	die("XDG_RUNTIME_DIR must be set");
		4214	setup();
		4215	run(startup_cmd);
		4216	cleanup();
		4217	return EXIT_SUCCESS;
		4218
		4219	usage:
		4220	die("Usage: %s [-v] [-d] [-s startup command] [-c config file]", argv[0]);
		4221	}
		4222

src/util.c

0 created 644 +51 0

@@ -0,0 +1,51
	1	/* See LICENSE.dwm file for copyright and license details. */
	2	#include <stdarg.h>
	3	#include <stdio.h>
	4	#include <stdlib.h>
	5	#include <string.h>
	6	#include <fcntl.h>
	7
	8	#include "util.h"
	9
	10	void
	11	die(const char *fmt, ...) {
	12	va_list ap;
	13
	14	va_start(ap, fmt);
	15	vfprintf(stderr, fmt, ap);
	16	va_end(ap);
	17
	18	if (fmt[0] && fmt[strlen(fmt)-1] == ':') {
	19	fputc(' ', stderr);
	20	perror(NULL);
	21	} else {
	22	fputc('\n', stderr);
	23	}
	24
	25	exit(1);
	26	}
	27
	28	void *
	29	ecalloc(size_t nmemb, size_t size)
	30	{
	31	void *p;
	32
	33	if (!(p = calloc(nmemb, size)))
	34	die("calloc:");
	35	return p;
	36	}
	37
	38	int
	39	fd_set_nonblock(int fd) {
	40	int flags = fcntl(fd, F_GETFL);
	41	if (flags < 0) {
	42	perror("fcntl(F_GETFL):");
	43	return -1;
	44	}
	45	if (fcntl(fd, F_SETFL, flags \| O_NONBLOCK) < 0) {
	46	perror("fcntl(F_SETFL):");
	47	return -1;
	48	}
	49
	50	return 0;
	51	}

src/util.h

0 created 644 +5 0

@@ -0,0 +1,5
	1	/* See LICENSE.dwm file for copyright and license details. */
	2
	3	void die(const char *fmt, ...);
	4	void *ecalloc(size_t nmemb, size_t size);
	5	int fd_set_nonblock(int fd);

src/wlr_ext_workspace_v1.c

0 created 644 +975 0

This diff has been collapsed as it changes many lines, (975 lines changed) Show them Hide them
	@@ -0,0 +1,975
		1	#include "wlr_ext_workspace_v1.h"
		2	#include "ext-workspace-v1-protocol.h"
		3	#include <assert.h>
		4	#include <stdlib.h>
		5	#include <string.h>
		6	#include <wlr/types/wlr_output.h>
		7
		8	#define EXT_WORKSPACE_V1_VERSION 1
		9
		10	struct wlr_ext_workspace_v1_group_output {
		11	struct wlr_output *output;
		12	struct wlr_ext_workspace_group_handle_v1 *group;
		13	struct wl_listener output_bind;
		14	struct wl_listener output_destroy;
		15	struct wl_list link;
		16	};
		17
		18	// These structs wrap wl_resource of each interface to access the request queue
		19	// (wlr_ext_workspace_manager_v1_resource.requests) assigned per manager
		20	// resource
		21
		22	struct wlr_ext_workspace_manager_v1_resource {
		23	struct wl_resource *resource;
		24	struct wlr_ext_workspace_manager_v1 *manager;
		25	struct wl_list requests; // wlr_ext_workspace_v1_request.link
		26	struct wl_list workspace_resources; // wlr_ext_workspace_v1_resource.link
		27	struct wl_list group_resources; // wlr_ext_workspace_group_v1_resource.link
		28	struct wl_list link; // wlr_ext_workspace_manager_v1.resources
		29	};
		30
		31	struct wlr_ext_workspace_group_v1_resource {
		32	struct wl_resource *resource;
		33	struct wlr_ext_workspace_group_handle_v1 *group;
		34	struct wlr_ext_workspace_manager_v1_resource *manager;
		35	struct wl_list link; // wlr_ext_workspace_group_v1.resources
		36	struct wl_list
		37	manager_resource_link; // wlr_ext_workspace_manager_v1_resource.group_resources
		38	};
		39
		40	struct wlr_ext_workspace_v1_resource {
		41	struct wl_resource *resource;
		42	struct wlr_ext_workspace_handle_v1 *workspace;
		43	struct wlr_ext_workspace_manager_v1_resource *manager;
		44	struct wl_list link; // wlr_ext_workspace_v1.resources
		45	struct wl_list
		46	manager_resource_link; // wlr_ext_workspace_manager_v1_resource.workspace_resources
		47	};
		48
		49	static const struct ext_workspace_group_handle_v1_interface group_impl;
		50
		51	static struct wlr_ext_workspace_group_v1_resource *
		52	group_resource_from_resource(struct wl_resource *resource) {
		53	assert(wl_resource_instance_of(
		54	resource, &ext_workspace_group_handle_v1_interface, &group_impl));
		55	return wl_resource_get_user_data(resource);
		56	}
		57
		58	static const struct ext_workspace_handle_v1_interface workspace_impl;
		59
		60	static struct wlr_ext_workspace_v1_resource *
		61	workspace_resource_from_resource(struct wl_resource *resource) {
		62	assert(wl_resource_instance_of(resource, &ext_workspace_handle_v1_interface,
		63	&workspace_impl));
		64	return wl_resource_get_user_data(resource);
		65	}
		66
		67	static const struct ext_workspace_manager_v1_interface manager_impl;
		68
		69	static struct wlr_ext_workspace_manager_v1_resource *
		70	manager_resource_from_resource(struct wl_resource *resource) {
		71	assert(wl_resource_instance_of(
		72	resource, &ext_workspace_manager_v1_interface, &manager_impl));
		73	return wl_resource_get_user_data(resource);
		74	}
		75
		76	static void workspace_handle_destroy(struct wl_client *client,
		77	struct wl_resource *resource) {
		78	wl_resource_destroy(resource);
		79	}
		80
		81	static void workspace_handle_activate(struct wl_client *client,
		82	struct wl_resource *workspace_resource) {
		83	struct wlr_ext_workspace_v1_resource *workspace_res =
		84	workspace_resource_from_resource(workspace_resource);
		85	if (!workspace_res) {
		86	return;
		87	}
		88
		89	struct wlr_ext_workspace_v1_request req = calloc(1, sizeof(req));
		90	if (!req) {
		91	wl_resource_post_no_memory(workspace_resource);
		92	return;
		93	}
		94	req->type = WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE;
		95	req->activate.workspace = workspace_res->workspace;
		96	wl_list_insert(workspace_res->manager->requests.prev, &req->link);
		97	}
		98
		99	static void
		100	workspace_handle_deactivate(struct wl_client *client,
		101	struct wl_resource *workspace_resource) {
		102	struct wlr_ext_workspace_v1_resource *workspace_res =
		103	workspace_resource_from_resource(workspace_resource);
		104	if (!workspace_res) {
		105	return;
		106	}
		107
		108	struct wlr_ext_workspace_v1_request req = calloc(1, sizeof(req));
		109	if (!req) {
		110	wl_resource_post_no_memory(workspace_resource);
		111	return;
		112	}
		113	req->type = WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE;
		114	req->deactivate.workspace = workspace_res->workspace;
		115	wl_list_insert(workspace_res->manager->requests.prev, &req->link);
		116	}
		117
		118	static void workspace_handle_assign(struct wl_client *client,
		119	struct wl_resource *workspace_resource,
		120	struct wl_resource *group_resource) {
		121	struct wlr_ext_workspace_v1_resource *workspace_res =
		122	workspace_resource_from_resource(workspace_resource);
		123	struct wlr_ext_workspace_group_v1_resource *group_res =
		124	group_resource_from_resource(group_resource);
		125	if (!workspace_res \|\| !group_res) {
		126	return;
		127	}
		128
		129	struct wlr_ext_workspace_v1_request req = calloc(1, sizeof(req));
		130	if (!req) {
		131	wl_resource_post_no_memory(workspace_resource);
		132	return;
		133	}
		134	req->type = WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN;
		135	req->assign.group = group_res->group;
		136	req->assign.workspace = workspace_res->workspace;
		137	wl_list_insert(workspace_res->manager->requests.prev, &req->link);
		138	}
		139
		140	static void workspace_handle_remove(struct wl_client *client,
		141	struct wl_resource *workspace_resource) {
		142	struct wlr_ext_workspace_v1_resource *workspace_res =
		143	workspace_resource_from_resource(workspace_resource);
		144	if (!workspace_res) {
		145	return;
		146	}
		147
		148	struct wlr_ext_workspace_v1_request req = calloc(1, sizeof(req));
		149	if (!req) {
		150	wl_resource_post_no_memory(workspace_resource);
		151	return;
		152	}
		153	req->type = WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE;
		154	req->remove.workspace = workspace_res->workspace;
		155	wl_list_insert(workspace_res->manager->requests.prev, &req->link);
		156	}
		157
		158	static const struct ext_workspace_handle_v1_interface workspace_impl = {
		159	.destroy = workspace_handle_destroy,
		160	.activate = workspace_handle_activate,
		161	.deactivate = workspace_handle_deactivate,
		162	.assign = workspace_handle_assign,
		163	.remove = workspace_handle_remove,
		164	};
		165
		166	static void group_handle_create_workspace(struct wl_client *client,
		167	struct wl_resource *group_resource,
		168	const char *name) {
		169	struct wlr_ext_workspace_group_v1_resource *group_res =
		170	group_resource_from_resource(group_resource);
		171	if (!group_res) {
		172	return;
		173	}
		174
		175	struct wlr_ext_workspace_v1_request req = calloc(1, sizeof(req));
		176	if (!req) {
		177	wl_resource_post_no_memory(group_resource);
		178	return;
		179	}
		180	req->create_workspace.name = strdup(name);
		181	if (!req->create_workspace.name) {
		182	free(req);
		183	wl_resource_post_no_memory(group_resource);
		184	return;
		185	}
		186	req->type = WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE;
		187	req->create_workspace.group = group_res->group;
		188	wl_list_insert(group_res->manager->requests.prev, &req->link);
		189	}
		190
		191	static void group_handle_destroy(struct wl_client *client,
		192	struct wl_resource *resource) {
		193	wl_resource_destroy(resource);
		194	}
		195
		196	static const struct ext_workspace_group_handle_v1_interface group_impl = {
		197	.create_workspace = group_handle_create_workspace,
		198	.destroy = group_handle_destroy,
		199	};
		200
		201	static void destroy_workspace_resource(
		202	struct wlr_ext_workspace_v1_resource *workspace_res) {
		203	wl_list_remove(&workspace_res->link);
		204	wl_list_remove(&workspace_res->manager_resource_link);
		205	wl_resource_set_user_data(workspace_res->resource, NULL);
		206	free(workspace_res);
		207	}
		208
		209	static void workspace_resource_destroy(struct wl_resource *resource) {
		210	struct wlr_ext_workspace_v1_resource *workspace_res =
		211	workspace_resource_from_resource(resource);
		212	if (workspace_res) {
		213	destroy_workspace_resource(workspace_res);
		214	}
		215	}
		216
		217	static struct wlr_ext_workspace_v1_resource *create_workspace_resource(
		218	struct wlr_ext_workspace_handle_v1 *workspace,
		219	struct wlr_ext_workspace_manager_v1_resource *manager_res) {
		220	struct wlr_ext_workspace_v1_resource *workspace_res =
		221	calloc(1, sizeof(*workspace_res));
		222	if (!workspace_res) {
		223	return NULL;
		224	}
		225
		226	struct wl_client *client = wl_resource_get_client(manager_res->resource);
		227	workspace_res->resource =
		228	wl_resource_create(client, &ext_workspace_handle_v1_interface,
		229	wl_resource_get_version(manager_res->resource), 0);
		230	if (!workspace_res->resource) {
		231	free(workspace_res);
		232	return NULL;
		233	}
		234	wl_resource_set_implementation(workspace_res->resource, &workspace_impl,
		235	workspace_res, workspace_resource_destroy);
		236
		237	workspace_res->workspace = workspace;
		238	workspace_res->manager = manager_res;
		239	wl_list_insert(&workspace->resources, &workspace_res->link);
		240	wl_list_insert(&manager_res->workspace_resources,
		241	&workspace_res->manager_resource_link);
		242
		243	return workspace_res;
		244	}
		245
		246	static void
		247	destroy_group_resource(struct wlr_ext_workspace_group_v1_resource *group_res) {
		248	wl_list_remove(&group_res->link);
		249	wl_list_remove(&group_res->manager_resource_link);
		250	wl_resource_set_user_data(group_res->resource, NULL);
		251	free(group_res);
		252	}
		253
		254	static void group_handle_resource_destroy(struct wl_resource *resource) {
		255	struct wlr_ext_workspace_group_v1_resource *group_res =
		256	group_resource_from_resource(resource);
		257	if (group_res) {
		258	destroy_group_resource(group_res);
		259	}
		260	}
		261
		262	static struct wlr_ext_workspace_group_v1_resource *create_group_resource(
		263	struct wlr_ext_workspace_group_handle_v1 *group,
		264	struct wlr_ext_workspace_manager_v1_resource *manager_res) {
		265	struct wlr_ext_workspace_group_v1_resource *group_res =
		266	calloc(1, sizeof(*group_res));
		267	if (!group_res) {
		268	return NULL;
		269	}
		270
		271	struct wl_client *client = wl_resource_get_client(manager_res->resource);
		272	uint32_t version = wl_resource_get_version(manager_res->resource);
		273	group_res->resource = wl_resource_create(
		274	client, &ext_workspace_group_handle_v1_interface, version, 0);
		275	if (group_res->resource == NULL) {
		276	free(group_res);
		277	return NULL;
		278	}
		279	wl_resource_set_implementation(group_res->resource, &group_impl, group_res,
		280	group_handle_resource_destroy);
		281
		282	group_res->group = group;
		283	group_res->manager = manager_res;
		284	wl_list_insert(&group->resources, &group_res->link);
		285	wl_list_insert(&manager_res->group_resources,
		286	&group_res->manager_resource_link);
		287
		288	return group_res;
		289	}
		290
		291	static void
		292	destroy_requests(struct wlr_ext_workspace_manager_v1_resource *manager_res) {
		293	struct wlr_ext_workspace_v1_request req, tmp;
		294	wl_list_for_each_safe(req, tmp, &manager_res->requests, link) {
		295	if (req->type == WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE) {
		296	free(req->create_workspace.name);
		297	}
		298	wl_list_remove(&req->link);
		299	free(req);
		300	}
		301	}
		302
		303	static void
		304	clear_requests_by(struct wlr_ext_workspace_manager_v1_resource *manager_res,
		305	struct wlr_ext_workspace_group_handle_v1 *group,
		306	struct wlr_ext_workspace_handle_v1 *workspace) {
		307	struct wlr_ext_workspace_v1_request req, tmp;
		308	wl_list_for_each_safe(req, tmp, &manager_res->requests, link) {
		309	switch (req->type) {
		310	case WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE:
		311	if (group && req->create_workspace.group == group) {
		312	req->create_workspace.group = NULL;
		313	}
		314	break;
		315	case WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE:
		316	if (workspace && req->activate.workspace == workspace) {
		317	req->activate.workspace = NULL;
		318	}
		319	break;
		320	case WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE:
		321	if (workspace && req->deactivate.workspace == workspace) {
		322	req->deactivate.workspace = NULL;
		323	}
		324	break;
		325	case WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN:
		326	if (workspace && req->assign.workspace == workspace) {
		327	req->assign.workspace = NULL;
		328	}
		329	if (group && req->assign.group == group) {
		330	req->assign.group = NULL;
		331	}
		332	break;
		333	case WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE:
		334	if (workspace && req->remove.workspace == workspace) {
		335	req->remove.workspace = NULL;
		336	}
		337	break;
		338	}
		339	}
		340	}
		341
		342	static void manager_handle_commit(struct wl_client *client,
		343	struct wl_resource *resource) {
		344	struct wlr_ext_workspace_manager_v1_resource *manager_res =
		345	manager_resource_from_resource(resource);
		346	if (!manager_res) {
		347	return;
		348	}
		349
		350	struct wlr_ext_workspace_v1_commit_event commit_event = {
		351	.requests = &manager_res->requests,
		352	};
		353	wl_signal_emit_mutable(&manager_res->manager->events.commit, &commit_event);
		354	destroy_requests(manager_res);
		355	}
		356
		357	static void handle_idle(void *data) {
		358	struct wlr_ext_workspace_manager_v1 *manager = data;
		359
		360	struct wlr_ext_workspace_manager_v1_resource *manager_res;
		361	wl_list_for_each(manager_res, &manager->resources, link) {
		362	ext_workspace_manager_v1_send_done(manager_res->resource);
		363	}
		364	manager->idle_source = NULL;
		365	}
		366
		367	static void
		368	manager_schedule_done(struct wlr_ext_workspace_manager_v1 *manager) {
		369	if (!manager->idle_source) {
		370	manager->idle_source =
		371	wl_event_loop_add_idle(manager->event_loop, handle_idle, manager);
		372	}
		373	}
		374
		375	static void
		376	workspace_send_details(struct wlr_ext_workspace_v1_resource *workspace_res) {
		377	struct wlr_ext_workspace_handle_v1 *workspace = workspace_res->workspace;
		378	struct wl_resource *resource = workspace_res->resource;
		379
		380	ext_workspace_handle_v1_send_capabilities(resource, workspace->caps);
		381	if (workspace->coordinates.size > 0) {
		382	ext_workspace_handle_v1_send_coordinates(resource,
		383	&workspace->coordinates);
		384	}
		385	if (workspace->name) {
		386	ext_workspace_handle_v1_send_name(resource, workspace->name);
		387	}
		388	if (workspace->id) {
		389	ext_workspace_handle_v1_send_id(resource, workspace->id);
		390	}
		391	ext_workspace_handle_v1_send_state(resource, workspace->state);
		392	manager_schedule_done(workspace->manager);
		393	}
		394
		395	static void manager_handle_stop(struct wl_client *client,
		396	struct wl_resource *resource) {
		397	ext_workspace_manager_v1_send_finished(resource);
		398	wl_resource_destroy(resource);
		399	}
		400
		401	static const struct ext_workspace_manager_v1_interface manager_impl = {
		402	.commit = manager_handle_commit,
		403	.stop = manager_handle_stop,
		404	};
		405
		406	static void destroy_manager_resource(
		407	struct wlr_ext_workspace_manager_v1_resource *manager_res) {
		408	destroy_requests(manager_res);
		409
		410	struct wlr_ext_workspace_v1_resource workspace_res, tmp2;
		411	wl_list_for_each_safe(workspace_res, tmp2,
		412	&manager_res->workspace_resources,
		413	manager_resource_link) {
		414	destroy_workspace_resource(workspace_res);
		415	}
		416	struct wlr_ext_workspace_group_v1_resource group_res, tmp3;
		417	wl_list_for_each_safe(group_res, tmp3, &manager_res->group_resources,
		418	manager_resource_link) {
		419	destroy_group_resource(group_res);
		420	}
		421
		422	wl_list_remove(&manager_res->link);
		423	wl_resource_set_user_data(manager_res->resource, NULL);
		424	free(manager_res);
		425	}
		426
		427	static void manager_resource_destroy(struct wl_resource *resource) {
		428	struct wlr_ext_workspace_manager_v1_resource *manager_res =
		429	manager_resource_from_resource(resource);
		430	if (manager_res) {
		431	destroy_manager_resource(manager_res);
		432	}
		433	}
		434
		435	static void
		436	group_send_details(struct wlr_ext_workspace_group_v1_resource *group_res) {
		437	struct wlr_ext_workspace_group_handle_v1 *group = group_res->group;
		438	struct wl_resource *resource = group_res->resource;
		439	struct wl_client *client = wl_resource_get_client(resource);
		440
		441	ext_workspace_group_handle_v1_send_capabilities(resource, group->caps);
		442
		443	struct wlr_ext_workspace_v1_group_output *group_output;
		444	wl_list_for_each(group_output, &group->outputs, link) {
		445	struct wl_resource *output_resource;
		446	wl_resource_for_each(output_resource,
		447	&group_output->output->resources) {
		448	if (wl_resource_get_client(output_resource) == client) {
		449	ext_workspace_group_handle_v1_send_output_enter(
		450	resource, output_resource);
		451	}
		452	}
		453	}
		454
		455	manager_schedule_done(group->manager);
		456	}
		457
		458	static void manager_bind(struct wl_client client, void data, uint32_t version,
		459	uint32_t id) {
		460	struct wlr_ext_workspace_manager_v1 *manager = data;
		461
		462	struct wlr_ext_workspace_manager_v1_resource *manager_res =
		463	calloc(1, sizeof(*manager_res));
		464	if (!manager_res) {
		465	wl_client_post_no_memory(client);
		466	return;
		467	}
		468
		469	manager_res->manager = manager;
		470	wl_list_init(&manager_res->requests);
		471	wl_list_init(&manager_res->workspace_resources);
		472	wl_list_init(&manager_res->group_resources);
		473
		474	manager_res->resource = wl_resource_create(
		475	client, &ext_workspace_manager_v1_interface, version, id);
		476	if (!manager_res->resource) {
		477	free(manager_res);
		478	wl_client_post_no_memory(client);
		479	return;
		480	}
		481	wl_resource_set_implementation(manager_res->resource, &manager_impl,
		482	manager_res, manager_resource_destroy);
		483	wl_list_insert(&manager->resources, &manager_res->link);
		484
		485	struct wlr_ext_workspace_group_handle_v1 *group;
		486	wl_list_for_each(group, &manager->groups, link) {
		487	struct wlr_ext_workspace_group_v1_resource *group_res =
		488	create_group_resource(group, manager_res);
		489	if (!group_res) {
		490	wl_resource_post_no_memory(manager_res->resource);
		491	continue;
		492	}
		493	ext_workspace_manager_v1_send_workspace_group(manager_res->resource,
		494	group_res->resource);
		495	group_send_details(group_res);
		496	}
		497
		498	struct wlr_ext_workspace_handle_v1 *workspace;
		499	wl_list_for_each(workspace, &manager->workspaces, link) {
		500	struct wlr_ext_workspace_v1_resource *workspace_res =
		501	create_workspace_resource(workspace, manager_res);
		502	if (!workspace_res) {
		503	wl_resource_post_no_memory(manager_res->resource);
		504	continue;
		505	}
		506	ext_workspace_manager_v1_send_workspace(manager_res->resource,
		507	workspace_res->resource);
		508	workspace_send_details(workspace_res);
		509
		510	if (!workspace->group) {
		511	continue;
		512	}
		513	struct wlr_ext_workspace_group_v1_resource *group_res;
		514	wl_list_for_each(group_res, &workspace->group->resources, link) {
		515	if (group_res->manager == manager_res) {
		516	ext_workspace_group_handle_v1_send_workspace_enter(
		517	group_res->resource, workspace_res->resource);
		518	}
		519	}
		520	}
		521
		522	ext_workspace_manager_v1_send_done(manager_res->resource);
		523	}
		524
		525	static void manager_handle_display_destroy(struct wl_listener *listener,
		526	void *data) {
		527	struct wlr_ext_workspace_manager_v1 *manager =
		528	wl_container_of(listener, manager, display_destroy);
		529
		530	wl_signal_emit_mutable(&manager->events.destroy, NULL);
		531	assert(wl_list_empty(&manager->events.commit.listener_list));
		532	assert(wl_list_empty(&manager->events.destroy.listener_list));
		533
		534	struct wlr_ext_workspace_group_handle_v1 group, tmp;
		535	wl_list_for_each_safe(group, tmp, &manager->groups, link) {
		536	wlr_ext_workspace_group_handle_v1_destroy(group);
		537	}
		538
		539	struct wlr_ext_workspace_handle_v1 workspace, tmp2;
		540	wl_list_for_each_safe(workspace, tmp2, &manager->workspaces, link) {
		541	wlr_ext_workspace_handle_v1_destroy(workspace);
		542	}
		543
		544	struct wlr_ext_workspace_manager_v1_resource manager_res, tmp3;
		545	wl_list_for_each_safe(manager_res, tmp3, &manager->resources, link) {
		546	destroy_manager_resource(manager_res);
		547	}
		548
		549	if (manager->idle_source) {
		550	wl_event_source_remove(manager->idle_source);
		551	}
		552
		553	wl_list_remove(&manager->display_destroy.link);
		554	wl_global_destroy(manager->global);
		555	free(manager);
		556	}
		557
		558	struct wlr_ext_workspace_manager_v1 *
		559	wlr_ext_workspace_manager_v1_create(struct wl_display *display,
		560	uint32_t version) {
		561	assert(version <= EXT_WORKSPACE_V1_VERSION);
		562
		563	struct wlr_ext_workspace_manager_v1 manager = calloc(1, sizeof(manager));
		564	if (!manager) {
		565	return NULL;
		566	}
		567
		568	manager->global =
		569	wl_global_create(display, &ext_workspace_manager_v1_interface, version,
		570	manager, manager_bind);
		571	if (!manager->global) {
		572	free(manager);
		573	return NULL;
		574	}
		575
		576	manager->event_loop = wl_display_get_event_loop(display);
		577
		578	manager->display_destroy.notify = manager_handle_display_destroy;
		579	wl_display_add_destroy_listener(display, &manager->display_destroy);
		580
		581	wl_list_init(&manager->groups);
		582	wl_list_init(&manager->workspaces);
		583	wl_list_init(&manager->resources);
		584	wl_signal_init(&manager->events.commit);
		585	wl_signal_init(&manager->events.destroy);
		586
		587	return manager;
		588	}
		589
		590	struct wlr_ext_workspace_group_handle_v1 *
		591	wlr_ext_workspace_group_handle_v1_create(
		592	struct wlr_ext_workspace_manager_v1 *manager, uint32_t caps) {
		593	struct wlr_ext_workspace_group_handle_v1 group = calloc(1, sizeof(group));
		594	if (!group) {
		595	return NULL;
		596	}
		597
		598	group->manager = manager;
		599	group->caps = caps;
		600
		601	wl_list_init(&group->outputs);
		602	wl_list_init(&group->resources);
		603	wl_signal_init(&group->events.destroy);
		604
		605	wl_list_insert(manager->groups.prev, &group->link);
		606
		607	struct wlr_ext_workspace_manager_v1_resource *manager_res;
		608	wl_list_for_each(manager_res, &manager->resources, link) {
		609	struct wlr_ext_workspace_group_v1_resource *group_res =
		610	create_group_resource(group, manager_res);
		611	if (!group_res) {
		612	continue;
		613	}
		614	ext_workspace_manager_v1_send_workspace_group(manager_res->resource,
		615	group_res->resource);
		616	group_send_details(group_res);
		617	}
		618
		619	manager_schedule_done(manager);
		620
		621	return group;
		622	}
		623
		624	static void
		625	workspace_send_group(struct wlr_ext_workspace_handle_v1 *workspace,
		626	struct wlr_ext_workspace_group_handle_v1 *group,
		627	bool enter) {
		628
		629	struct wlr_ext_workspace_v1_resource *workspace_res;
		630	wl_list_for_each(workspace_res, &workspace->resources, link) {
		631	struct wlr_ext_workspace_group_v1_resource *group_res;
		632	wl_list_for_each(group_res, &group->resources, link) {
		633	if (group_res->manager != workspace_res->manager) {
		634	continue;
		635	}
		636	if (enter) {
		637	ext_workspace_group_handle_v1_send_workspace_enter(
		638	group_res->resource, workspace_res->resource);
		639	} else {
		640	ext_workspace_group_handle_v1_send_workspace_leave(
		641	group_res->resource, workspace_res->resource);
		642	}
		643	}
		644	}
		645
		646	manager_schedule_done(workspace->manager);
		647	}
		648
		649	static void
		650	destroy_group_output(struct wlr_ext_workspace_v1_group_output *group_output) {
		651	wl_list_remove(&group_output->output_bind.link);
		652	wl_list_remove(&group_output->output_destroy.link);
		653	wl_list_remove(&group_output->link);
		654	free(group_output);
		655	}
		656
		657	static void group_send_output(struct wlr_ext_workspace_group_handle_v1 *group,
		658	struct wlr_output *output, bool enter) {
		659
		660	struct wlr_ext_workspace_group_v1_resource *group_res;
		661	wl_list_for_each(group_res, &group->resources, link) {
		662	struct wl_client *client = wl_resource_get_client(group_res->resource);
		663
		664	struct wl_resource *output_resource;
		665	wl_resource_for_each(output_resource, &output->resources) {
		666	if (wl_resource_get_client(output_resource) != client) {
		667	continue;
		668	}
		669	if (enter) {
		670	ext_workspace_group_handle_v1_send_output_enter(
		671	group_res->resource, output_resource);
		672	} else {
		673	ext_workspace_group_handle_v1_send_output_leave(
		674	group_res->resource, output_resource);
		675	}
		676	}
		677	}
		678
		679	manager_schedule_done(group->manager);
		680	}
		681
		682	void wlr_ext_workspace_group_handle_v1_destroy(
		683	struct wlr_ext_workspace_group_handle_v1 *group) {
		684	if (!group) {
		685	return;
		686	}
		687
		688	wl_signal_emit_mutable(&group->events.destroy, NULL);
		689
		690	assert(wl_list_empty(&group->events.destroy.listener_list));
		691
		692	struct wlr_ext_workspace_handle_v1 *workspace;
		693	wl_list_for_each(workspace, &group->manager->workspaces, link) {
		694	if (workspace->group == group) {
		695	workspace_send_group(workspace, group, false);
		696	workspace->group = NULL;
		697	}
		698	}
		699
		700	struct wlr_ext_workspace_group_v1_resource group_res, tmp;
		701	wl_list_for_each_safe(group_res, tmp, &group->resources, link) {
		702	ext_workspace_group_handle_v1_send_removed(group_res->resource);
		703	destroy_group_resource(group_res);
		704	}
		705
		706	struct wlr_ext_workspace_manager_v1_resource *manager_res;
		707	wl_list_for_each(manager_res, &group->manager->resources, link) {
		708	clear_requests_by(manager_res, group, NULL);
		709	}
		710
		711	struct wlr_ext_workspace_v1_group_output group_output, tmp3;
		712	wl_list_for_each_safe(group_output, tmp3, &group->outputs, link) {
		713	group_send_output(group, group_output->output, false);
		714	destroy_group_output(group_output);
		715	}
		716
		717	manager_schedule_done(group->manager);
		718
		719	wl_list_remove(&group->link);
		720	free(group);
		721	}
		722
		723	static void handle_output_bind(struct wl_listener listener, void data) {
		724	struct wlr_ext_workspace_v1_group_output *group_output =
		725	wl_container_of(listener, group_output, output_bind);
		726	struct wlr_output_event_bind *event = data;
		727	struct wl_client *client = wl_resource_get_client(event->resource);
		728
		729	struct wlr_ext_workspace_group_v1_resource *group_res;
		730	wl_list_for_each(group_res, &group_output->group->resources, link) {
		731	if (wl_resource_get_client(group_res->resource) == client) {
		732	ext_workspace_group_handle_v1_send_output_enter(group_res->resource,
		733	event->resource);
		734	}
		735	}
		736
		737	manager_schedule_done(group_output->group->manager);
		738	}
		739
		740	static void handle_output_destroy(struct wl_listener listener, void data) {
		741	struct wlr_ext_workspace_v1_group_output *group_output =
		742	wl_container_of(listener, group_output, output_destroy);
		743	group_send_output(group_output->group, group_output->output, false);
		744	destroy_group_output(group_output);
		745	}
		746
		747	static struct wlr_ext_workspace_v1_group_output *
		748	get_group_output(struct wlr_ext_workspace_group_handle_v1 *group,
		749	struct wlr_output *output) {
		750	struct wlr_ext_workspace_v1_group_output *group_output;
		751	wl_list_for_each(group_output, &group->outputs, link) {
		752	if (group_output->output == output) {
		753	return group_output;
		754	}
		755	}
		756	return NULL;
		757	}
		758
		759	void wlr_ext_workspace_group_handle_v1_output_enter(
		760	struct wlr_ext_workspace_group_handle_v1 *group,
		761	struct wlr_output *output) {
		762	if (get_group_output(group, output)) {
		763	return;
		764	}
		765	struct wlr_ext_workspace_v1_group_output *group_output =
		766	calloc(1, sizeof(*group_output));
		767	if (!group_output) {
		768	return;
		769	}
		770	group_output->output = output;
		771	group_output->group = group;
		772	wl_list_insert(&group->outputs, &group_output->link);
		773
		774	group_output->output_bind.notify = handle_output_bind;
		775	wl_signal_add(&output->events.bind, &group_output->output_bind);
		776	group_output->output_destroy.notify = handle_output_destroy;
		777	wl_signal_add(&output->events.destroy, &group_output->output_destroy);
		778
		779	group_send_output(group, output, true);
		780	}
		781
		782	void wlr_ext_workspace_group_handle_v1_output_leave(
		783	struct wlr_ext_workspace_group_handle_v1 *group,
		784	struct wlr_output *output) {
		785	struct wlr_ext_workspace_v1_group_output *group_output =
		786	get_group_output(group, output);
		787	if (!group_output) {
		788	return;
		789	}
		790
		791	group_send_output(group, output, false);
		792	destroy_group_output(group_output);
		793	}
		794
		795	struct wlr_ext_workspace_handle_v1 *
		796	wlr_ext_workspace_handle_v1_create(struct wlr_ext_workspace_manager_v1 *manager,
		797	const char *id, uint32_t caps) {
		798	struct wlr_ext_workspace_handle_v1 *workspace =
		799	calloc(1, sizeof(*workspace));
		800	if (!workspace) {
		801	return NULL;
		802	}
		803
		804	workspace->manager = manager;
		805	workspace->caps = caps;
		806
		807	if (id) {
		808	workspace->id = strdup(id);
		809	if (!workspace->id) {
		810	free(workspace);
		811	return NULL;
		812	}
		813	}
		814
		815	wl_list_init(&workspace->resources);
		816	wl_array_init(&workspace->coordinates);
		817	wl_signal_init(&workspace->events.destroy);
		818
		819	wl_list_insert(manager->workspaces.prev, &workspace->link);
		820
		821	struct wlr_ext_workspace_manager_v1_resource *manager_res;
		822	wl_list_for_each(manager_res, &manager->resources, link) {
		823	struct wlr_ext_workspace_v1_resource *workspace_res =
		824	create_workspace_resource(workspace, manager_res);
		825	if (!workspace_res) {
		826	continue;
		827	}
		828	ext_workspace_manager_v1_send_workspace(manager_res->resource,
		829	workspace_res->resource);
		830	workspace_send_details(workspace_res);
		831	}
		832
		833	manager_schedule_done(manager);
		834
		835	return workspace;
		836	}
		837
		838	void wlr_ext_workspace_handle_v1_destroy(
		839	struct wlr_ext_workspace_handle_v1 *workspace) {
		840	if (!workspace) {
		841	return;
		842	}
		843
		844	wl_signal_emit_mutable(&workspace->events.destroy, NULL);
		845
		846	assert(wl_list_empty(&workspace->events.destroy.listener_list));
		847
		848	if (workspace->group) {
		849	workspace_send_group(workspace, workspace->group, false);
		850	}
		851
		852	struct wlr_ext_workspace_v1_resource workspace_res, tmp;
		853	wl_list_for_each_safe(workspace_res, tmp, &workspace->resources, link) {
		854	ext_workspace_handle_v1_send_removed(workspace_res->resource);
		855	destroy_workspace_resource(workspace_res);
		856	}
		857
		858	struct wlr_ext_workspace_manager_v1_resource *manager_res;
		859	wl_list_for_each(manager_res, &workspace->manager->resources, link) {
		860	clear_requests_by(manager_res, NULL, workspace);
		861	}
		862
		863	manager_schedule_done(workspace->manager);
		864
		865	wl_list_remove(&workspace->link);
		866	wl_array_release(&workspace->coordinates);
		867	free(workspace->id);
		868	free(workspace->name);
		869	free(workspace);
		870	}
		871
		872	void wlr_ext_workspace_handle_v1_set_group(
		873	struct wlr_ext_workspace_handle_v1 *workspace,
		874	struct wlr_ext_workspace_group_handle_v1 *group) {
		875	if (workspace->group == group) {
		876	return;
		877	}
		878
		879	if (workspace->group) {
		880	workspace_send_group(workspace, workspace->group, false);
		881	}
		882	workspace->group = group;
		883	if (group) {
		884	workspace_send_group(workspace, group, true);
		885	}
		886	}
		887
		888	void wlr_ext_workspace_handle_v1_set_name(
		889	struct wlr_ext_workspace_handle_v1 workspace, const char name) {
		890	assert(name);
		891
		892	if (workspace->name && strcmp(workspace->name, name) == 0) {
		893	return;
		894	}
		895
		896	free(workspace->name);
		897	workspace->name = strdup(name);
		898	if (workspace->name == NULL) {
		899	return;
		900	}
		901
		902	struct wlr_ext_workspace_v1_resource *workspace_res;
		903	wl_list_for_each(workspace_res, &workspace->resources, link) {
		904	ext_workspace_handle_v1_send_name(workspace_res->resource,
		905	workspace->name);
		906	}
		907
		908	manager_schedule_done(workspace->manager);
		909	}
		910
		911	void wlr_ext_workspace_handle_v1_set_coordinates(
		912	struct wlr_ext_workspace_handle_v1 workspace, const uint32_t coords,
		913	size_t coords_len) {
		914	size_t size = coords_len * sizeof(coords[0]);
		915	if (size == workspace->coordinates.size &&
		916	(size == 0 \|\| memcmp(workspace->coordinates.data, coords, size) == 0)) {
		917	return;
		918	}
		919
		920	wl_array_release(&workspace->coordinates);
		921	wl_array_init(&workspace->coordinates);
		922	struct wl_array arr = {
		923	.data = (void *)coords,
		924	.size = size,
		925	};
		926	wl_array_copy(&workspace->coordinates, &arr);
		927
		928	struct wlr_ext_workspace_v1_resource *workspace_res;
		929	wl_list_for_each(workspace_res, &workspace->resources, link) {
		930	ext_workspace_handle_v1_send_coordinates(workspace_res->resource,
		931	&workspace->coordinates);
		932	}
		933
		934	manager_schedule_done(workspace->manager);
		935	}
		936
		937	static void workspace_set_state(struct wlr_ext_workspace_handle_v1 *workspace,
		938	enum ext_workspace_handle_v1_state state,
		939	bool enabled) {
		940	uint32_t old_state = workspace->state;
		941	if (enabled) {
		942	workspace->state \|= state;
		943	} else {
		944	workspace->state &= ~state;
		945	}
		946	if (old_state == workspace->state) {
		947	return;
		948	}
		949
		950	struct wlr_ext_workspace_v1_resource *workspace_res;
		951	wl_list_for_each(workspace_res, &workspace->resources, link) {
		952	ext_workspace_handle_v1_send_state(workspace_res->resource,
		953	workspace->state);
		954	}
		955
		956	manager_schedule_done(workspace->manager);
		957	}
		958
		959	void wlr_ext_workspace_handle_v1_set_active(
		960	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) {
		961	workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_ACTIVE,
		962	enabled);
		963	}
		964
		965	void wlr_ext_workspace_handle_v1_set_urgent(
		966	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) {
		967	workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_URGENT,
		968	enabled);
		969	}
		970
		971	void wlr_ext_workspace_handle_v1_set_hidden(
		972	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) {
		973	workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_HIDDEN,
		974	enabled);
		975	}

src/wlr_ext_workspace_v1.h

0 created 644 +150 0

@@ -0,0 +1,150
	1	/*
	2	* This an unstable interface of wlroots. No guarantees are made regarding the
	3	* future consistency of this API.
	4	*/
	5	#ifndef WLR_USE_UNSTABLE
	6	#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features"
	7	#endif
	8
	9	#ifndef WLR_TYPES_WLR_EXT_WORKSPACE_V1_H
	10	#define WLR_TYPES_WLR_EXT_WORKSPACE_V1_H
	11
	12	#include <wayland-protocols/ext-workspace-v1-enum.h>
	13	#include <wayland-server-core.h>
	14
	15	struct wlr_output;
	16
	17	enum wlr_ext_workspace_v1_request_type {
	18	WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE,
	19	WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE,
	20	WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE,
	21	WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN,
	22	WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE,
	23	};
	24
	25	struct wlr_ext_workspace_v1_request {
	26	enum wlr_ext_workspace_v1_request_type type;
	27	struct wl_list link; // wlr_ext_workspace_manager_v1_resource.requests
	28	union {
	29	struct {
	30	char *name;
	31	struct wlr_ext_workspace_group_handle_v1
	32	*group; // NULL if destroyed
	33	} create_workspace;
	34	struct {
	35	struct wlr_ext_workspace_handle_v1 *workspace; // NULL if destroyed
	36	} activate;
	37	struct {
	38	struct wlr_ext_workspace_handle_v1 *workspace; // NULL if destroyed
	39	} deactivate;
	40	struct {
	41	struct wlr_ext_workspace_handle_v1 *workspace; // NULL if destroyed
	42	struct wlr_ext_workspace_group_handle_v1
	43	*group; // NULL if destroyed
	44	} assign;
	45	struct {
	46	struct wlr_ext_workspace_handle_v1 *workspace; // NULL if destroyed
	47	} remove;
	48	};
	49	};
	50
	51	struct wlr_ext_workspace_v1_commit_event {
	52	struct wl_list *requests; // wlr_ext_workspace_v1_request.link
	53	};
	54
	55	struct wlr_ext_workspace_manager_v1 {
	56	struct wl_global *global;
	57	struct wl_list groups; // wlr_ext_workspace_group_handle_v1.link
	58	struct wl_list workspaces; // wlr_ext_workspace_handle_v1.link
	59
	60	struct {
	61	struct wl_signal commit; // wlr_ext_workspace_v1_commit_event
	62	struct wl_signal destroy;
	63	} events;
	64
	65	void *data;
	66
	67	struct {
	68	struct wl_list resources; // wlr_ext_workspace_manager_v1_resource.link
	69	struct wl_event_source *idle_source;
	70	struct wl_event_loop *event_loop;
	71	struct wl_listener display_destroy;
	72	};
	73	};
	74
	75	struct wlr_ext_workspace_group_handle_v1 {
	76	struct wlr_ext_workspace_manager_v1 *manager;
	77	uint32_t caps; // ext_workspace_group_handle_v1_group_capabilities
	78	struct {
	79	struct wl_signal destroy;
	80	} events;
	81
	82	struct wl_list link; // wlr_ext_workspace_manager_v1.groups
	83
	84	void *data;
	85
	86	struct {
	87	struct wl_list outputs; // wlr_ext_workspace_v1_group_output.link
	88	struct wl_list resources; // wlr_ext_workspace_manager_v1_resource.link
	89	};
	90	};
	91
	92	struct wlr_ext_workspace_handle_v1 {
	93	struct wlr_ext_workspace_manager_v1 *manager;
	94	struct wlr_ext_workspace_group_handle_v1 *group; // May be NULL
	95	char *id;
	96	char *name;
	97	struct wl_array coordinates;
	98	uint32_t caps; // ext_workspace_handle_v1_workspace_capabilities
	99	uint32_t state; // ext_workspace_handle_v1_state
	100
	101	struct {
	102	struct wl_signal destroy;
	103	} events;
	104
	105	struct wl_list link; // wlr_ext_workspace_manager_v1.workspaces
	106
	107	void *data;
	108
	109	struct {
	110	struct wl_list resources; // wlr_ext_workspace_v1_resource.link
	111	};
	112	};
	113
	114	struct wlr_ext_workspace_manager_v1 *
	115	wlr_ext_workspace_manager_v1_create(struct wl_display *display,
	116	uint32_t version);
	117
	118	struct wlr_ext_workspace_group_handle_v1 *
	119	wlr_ext_workspace_group_handle_v1_create(
	120	struct wlr_ext_workspace_manager_v1 *manager, uint32_t caps);
	121	void wlr_ext_workspace_group_handle_v1_destroy(
	122	struct wlr_ext_workspace_group_handle_v1 *group);
	123
	124	void wlr_ext_workspace_group_handle_v1_output_enter(
	125	struct wlr_ext_workspace_group_handle_v1 group, struct wlr_output output);
	126	void wlr_ext_workspace_group_handle_v1_output_leave(
	127	struct wlr_ext_workspace_group_handle_v1 group, struct wlr_output output);
	128
	129	struct wlr_ext_workspace_handle_v1 *
	130	wlr_ext_workspace_handle_v1_create(struct wlr_ext_workspace_manager_v1 *manager,
	131	const char *id, uint32_t caps);
	132	void wlr_ext_workspace_handle_v1_destroy(
	133	struct wlr_ext_workspace_handle_v1 *workspace);
	134
	135	void wlr_ext_workspace_handle_v1_set_group(
	136	struct wlr_ext_workspace_handle_v1 *workspace,
	137	struct wlr_ext_workspace_group_handle_v1 *group);
	138	void wlr_ext_workspace_handle_v1_set_name(
	139	struct wlr_ext_workspace_handle_v1 workspace, const char name);
	140	void wlr_ext_workspace_handle_v1_set_coordinates(
	141	struct wlr_ext_workspace_handle_v1 workspace, const uint32_t coords,
	142	size_t coords_len);
	143	void wlr_ext_workspace_handle_v1_set_active(
	144	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled);
	145	void wlr_ext_workspace_handle_v1_set_urgent(
	146	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled);
	147	void wlr_ext_workspace_handle_v1_set_hidden(
	148	struct wlr_ext_workspace_handle_v1 *workspace, bool enabled);
	149
	150	#endif

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages