bonkmaykr/amiwm-neo
1
0
Fork 0
mirror of https://github.com/amiwm/amiwm.git synced 2026-03-23 17:19:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove unused gnome.c

Browse Source 
The gnome.c file implemented the protocol used for early versions of
GNOME.  This protocol is deprecated, for it is already covered by the
more general EWMH standard (aka _NET properties) from freedesktop.org
(aka XDG).

In particular:
• Properties in gnome_setup() got deprecated by the _NET_SUPPORT{ED,ING_WM_CHECK}
  properties; already implemented in amiwm.
• Properties in gnome_managed_clients() got deprecated by the _NET_CLIENT_LIST
  property; not implemented in amiwm yet.
• Properties in gnome_multiple_desktops() got deprecated by the _NET_CURRENT_DESKTOP
  and _NET_NUMBER_OF_DESKTOPS properties; not implemented in amiwm yet.

Further EWMH support are be implemented in upcoming commits.

Also, this file was not even compiled and linked into amiwm anyway...
This commit is contained in:
Lucas de Sena
2026-02-24 18:54:52 +00:00
parent 0c75c83e3b
commit e3f4248e8f
1 changed files with 0 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
gnome.c
View File

@@ -1,184 +0,0 @@
/* GNOME Window Manager Compliance support for amiwm
by Peter Bortas february 2000 */
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xproto.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
extern void gnome_setup()
{
/* Section 1 - Detection of a GNOME compliant Window Manager
There is a single unambiguous way to detect if there currently is
a GNOME compliant Window Manager running. It is the job of the
Window Manager to set up a few things to make this
possible. Using the following method it is also possible for
applications to detect compliance by receiving an event when the
Window Manager exits.
To do this the Window Manager should create a Window, that is a
child of the root window. There is no need to map it, just create
it. The Window Manager may reuse ANY window it has for this
purpose - even if it is mapped, just as long as the window is
never destroyed while the Window Manager is running.
Once the Window is created the Window Manager should set a
property on the root window of the name _WIN_SUPPORTING_WM_CHECK,
and type CARDINAL. The atom's data would be a CARDINAL that is
the Window ID of the window that was created above. The window
that was created would ALSO have this property set on it with the
same values and type.*/
Display *disp;
Window root_window;
Atom atom_set;
CARD32 val;
Window win;
Atom list[10];
atom_set = XInternAtom(disp, "_WIN_SUPPORTING_WM_CHECK", False);
win = XCreateSimpleWindow(disp, root_window, -200, -200, 5, 5, 0, 0, 0);
val = win;
XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&val, 1);
XChangeProperty(disp, win, atom_set, XA_CARDINAL, 32, PropModeReplace,
(unsigned char *)&val, 1);
/* Section 2 - Listing GNOME Window Manager Compliance
It is important to list which parts of GNOME Window Manager
compliance are supported. This is done fairly easily by doing the
following:
Create a property on the root window of the atom name
_WIN_PROTOCOLS. This property contains a list(array)of atoms that
are all the properties the Window Manager supports. These atoms
are any number of the following:
_WIN_LAYER
_WIN_STATE
_WIN_HINTS
_WIN_APP_STATE
_WIN_EXPANDED_SIZE
_WIN_ICONS
_WIN_WORKSPACE
_WIN_WORKSPACE_COUNT
_WIN_WORKSPACE_NAMES
_WIN_CLIENT_LIST
If you list one of these properties then you support it and
applications can expect information provided by, or accepted by
the Window Manager to work. */
atom_set = XInternAtom(disp, "_WIN_PROTOCOLS", False);
list[0] = XInternAtom(disp, "_WIN_LAYER", False);
list[1] = XInternAtom(disp, "_WIN_STATE", False);
list[2] = XInternAtom(disp, "_WIN_HINTS", False);
list[3] = XInternAtom(disp, "_WIN_APP_STATE", False);
list[4] = XInternAtom(disp, "_WIN_EXPANDED_SIZE", False);
list[5] = XInternAtom(disp, "_WIN_ICONS", False);
list[6] = XInternAtom(disp, "_WIN_WORKSPACE", False);
list[7] = XInternAtom(disp, "_WIN_WORKSPACE_COUNT", False);
list[8] = XInternAtom(disp, "_WIN_WORKSPACE_NAMES", False);
list[9] = XInternAtom(disp, "_WIN_CLIENT_LIST", False);
XChangeProperty(disp, root_window, atom_set, XA_ATOM, 32, PropModeReplace,
(unsigned char *)list, 10);
}
extern void gnome_managed_clients()
{
/* Section 3 - Providing Shortcuts Managed Clients
As an aide in having external applications be able to list and
access clients being managed by the Window Manager, a property
should be set on the root window of the name _WIN_CLIENT_LIST
which is an array of type CARDINAL. Each entry is the Window ID
of a managed client. If the list of managed clients changes,
clients are added or deleted, this list should be updated. */
Display *disp;
Window root_window;
Atom atom_set;
Window *wl;
int num;
fprintf(stderr, "FIXME: snome_managed_clients is a stub\n");
atom_set = XInternAtom(disp, "_WIN_CLIENT_LIST", False);
num = 0; /* FIXME: number of clients goes here */
wl = malloc(sizeof(Window) * num);
/* FIXME: Fill in array of window ID's */
XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)wl, num);
if (wl)
free(wl);
}
extern void gnome_multiple_desktops()
{
/* Section 3 - Providing Multiple/Virtual Desktop Information.
If your Window Manager supports the concept of Multiple/Virtual
Desktops or Workspaces then you will definitely want to include
it. This involves your Window Manager setting several properties
on the root window.
First you should advertise how many Desktops your Window Manager
supports. This is done by setting a property on the root window
with the atom name _WIN_WORKSPACE_COUNT of type CARDINAL. The
properties data is a 32-bit integer that is the number of
Desktops your Window Manager currently supports. If you can add
and delete desktops while running, you may change this property
and its value whenever required. You should also set a property
of the atom _WIN_WORKSPACE of type CARDINAL that contains the
number of the currently active desktop (which is a number between
0 and the number advertised by _WIN_WORKSPACE_COUNT -
1). Whenever the active desktop changes, change this property.
Lastly you should set a property that is a list of strings called
_WIN_WORKSPACE_NAMES that contains names for the desktops (the
first string is the name of the first desktop, the second string
is the second desktop, etc.). This will allow applications toq
know what the name of the desktop is too, possibly to display it. */
Display *disp;
Window root_window;
Atom atom_set;
XTextProperty text;
int i, current_desk, number_of_desks;
char **names, s[1024];
CARD32 val;
/* FIXME: set current_desk, number_of_desks names */
atom_set = XInternAtom(disp, "_WIN_WORKSPACE", False);
val = (CARD32) current_desk;
XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&val, 1);
atom_set = XInternAtom(disp, "_WIN_WORKSPACE_COUNT", False);
val = (CARD32) number_of_desks;
XChangeProperty(disp, root_window, atom_set, XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&val, 1);
atom_set = XInternAtom(disp, "_WIN_WORKSPACE_NAMES", False);
names = malloc(sizeof(char *) * number_of_desks);
for (i = 0; i < number_of_desks; i++)
{
snprintf(s, sizeof(s), "Desktop %i", i);
names[i] = malloc(strlen(s) + 1);
strcpy(names[i], s);
}
if (XStringListToTextProperty(names, mode.numdesktops, ))
{
XSetTextProperty(disp, root_window, &val, atom_set);
XFree(text.value);
}
for (i = 0; i < number_of_desks; i++)
free(names[i]);
free(names);
}