swindle Commit - r0:54692361a243

init

Tsuki -

r0:54692361a243 default

parent child

The requested changes are too big and content was truncated. Show full diff

.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 0 0

	1		NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

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