Upload files to ".suckless"
This commit is contained in:
coast
parent
8fa6f01cfd
commit
a584b8842f
5 changed files with 1023 additions and 0 deletions
405
.suckless/config.h
Normal file
405
.suckless/config.h
Normal file
|
|
@ -0,0 +1,405 @@
|
|||
/*
|
||||
*
|
||||
**
|
||||
** All credits to suckless.org and Swindles McCoop
|
||||
** Coasteen's DWM configuration
|
||||
** https://www.github.com/coasteen/suckless/
|
||||
** __ _ _
|
||||
** ___ ___ _ __ / _(_) __ _ | |__
|
||||
** / __/ _ \| '_ \| |_| |/ _` | | '_ \
|
||||
** | (_| (_) | | | | _| | (_| |_| | | |
|
||||
** \___\___/|_| |_|_| |_|\__, (_)_| |_|
|
||||
** |___/
|
||||
**
|
||||
*
|
||||
*/
|
||||
|
||||
/* appearance */
|
||||
static const unsigned int borderpx = 3; /* border pixel of windows */
|
||||
static const unsigned int snap = 0; /* snap pixel */
|
||||
static const unsigned int barborderpx = 3; /* border pixel of bar */
|
||||
static const int swallowfloating = 1; /* 1 means swallow floating windows by default */
|
||||
static const unsigned int gappih = 10; /* horiz inner gap between windows */
|
||||
static const unsigned int gappiv = 10; /* vert inner gap between windows */
|
||||
static const unsigned int gappoh = 10; /* horiz outer gap between windows and screen edge */
|
||||
static const unsigned int gappov = 30; /* vert outer gap between windows and screen edge */
|
||||
static const int smartgaps_fact = 1; /* gap factor when there is only one client; 0 = no gaps, 3 = 3x outer gaps */
|
||||
static const int showbar = 1; /* 0 means no bar */
|
||||
static const int topbar = 1; /* 0 means bottom bar */
|
||||
/* Status is to be shown on: -1 (all monitors), 0 (a specific monitor by index), 'A' (active monitor) */
|
||||
static const int statusmon = 'A';
|
||||
|
||||
/* Indicators: see patch/bar_indicators.h for options */
|
||||
static int tagindicatortype = INDICATOR_NONE;
|
||||
static int tiledindicatortype = INDICATOR_NONE;
|
||||
static int floatindicatortype = INDICATOR_NONE;
|
||||
static const char *fonts[] = { "monospace:size=9" };
|
||||
static const char dmenufont[] = "monospacee:size=9";
|
||||
|
||||
static char c000000[] = "#000000"; // placeholder value
|
||||
|
||||
static char normfgcolor[] = "#bbbbbb";
|
||||
static char normbgcolor[] = "#222222";
|
||||
static char normbordercolor[] = "#444444";
|
||||
static char normfloatcolor[] = "#db8fd9";
|
||||
|
||||
static char selfgcolor[] = "#eeeeee";
|
||||
static char selbgcolor[] = "#005577";
|
||||
static char selbordercolor[] = "#005577";
|
||||
static char selfloatcolor[] = "#005577";
|
||||
|
||||
static char titlenormfgcolor[] = "#bbbbbb";
|
||||
static char titlenormbgcolor[] = "#222222";
|
||||
static char titlenormbordercolor[] = "#444444";
|
||||
static char titlenormfloatcolor[] = "#db8fd9";
|
||||
|
||||
static char titleselfgcolor[] = "#eeeeee";
|
||||
static char titleselbgcolor[] = "#005577";
|
||||
static char titleselbordercolor[] = "#005577";
|
||||
static char titleselfloatcolor[] = "#005577";
|
||||
|
||||
static char tagsnormfgcolor[] = "#bbbbbb";
|
||||
static char tagsnormbgcolor[] = "#222222";
|
||||
static char tagsnormbordercolor[] = "#444444";
|
||||
static char tagsnormfloatcolor[] = "#db8fd9";
|
||||
|
||||
static char tagsselfgcolor[] = "#eeeeee";
|
||||
static char tagsselbgcolor[] = "#005577";
|
||||
static char tagsselbordercolor[] = "#005577";
|
||||
static char tagsselfloatcolor[] = "#005577";
|
||||
|
||||
static char hidnormfgcolor[] = "#005577";
|
||||
static char hidselfgcolor[] = "#227799";
|
||||
static char hidnormbgcolor[] = "#222222";
|
||||
static char hidselbgcolor[] = "#222222";
|
||||
|
||||
static char urgfgcolor[] = "#bbbbbb";
|
||||
static char urgbgcolor[] = "#222222";
|
||||
static char urgbordercolor[] = "#ff0000";
|
||||
static char urgfloatcolor[] = "#db8fd9";
|
||||
|
||||
|
||||
static const unsigned int baralpha = 0xd0;
|
||||
static const unsigned int borderalpha = OPAQUE;
|
||||
static const unsigned int alphas[][3] = {
|
||||
/* fg bg border */
|
||||
[SchemeNorm] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeSel] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeTitleNorm] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeTitleSel] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeTagsNorm] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeTagsSel] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeHidNorm] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeHidSel] = { OPAQUE, baralpha, borderalpha },
|
||||
[SchemeUrg] = { OPAQUE, baralpha, borderalpha },
|
||||
};
|
||||
static char *colors[][ColCount] = {
|
||||
/* fg bg border float */
|
||||
[SchemeNorm] = { normfgcolor, normbgcolor, normbordercolor, normfloatcolor },
|
||||
[SchemeSel] = { selfgcolor, selbgcolor, selbordercolor, selfloatcolor },
|
||||
[SchemeTitleNorm] = { titlenormfgcolor, titlenormbgcolor, titlenormbordercolor, titlenormfloatcolor },
|
||||
[SchemeTitleSel] = { titleselfgcolor, titleselbgcolor, titleselbordercolor, titleselfloatcolor },
|
||||
[SchemeTagsNorm] = { tagsnormfgcolor, tagsnormbgcolor, tagsnormbordercolor, tagsnormfloatcolor },
|
||||
[SchemeTagsSel] = { tagsselfgcolor, tagsselbgcolor, tagsselbordercolor, tagsselfloatcolor },
|
||||
[SchemeHidNorm] = { hidnormfgcolor, hidnormbgcolor, c000000, c000000 },
|
||||
[SchemeHidSel] = { hidselfgcolor, hidselbgcolor, c000000, c000000 },
|
||||
[SchemeUrg] = { urgfgcolor, urgbgcolor, urgbordercolor, urgfloatcolor },
|
||||
};
|
||||
|
||||
|
||||
|
||||
static const char *const autostart[] = {
|
||||
//"sh", "-c", "$HOME/.xprofile", NULL,
|
||||
NULL /* terminate */
|
||||
};
|
||||
|
||||
const char *spcmd1[] = {"st", NULL };
|
||||
static Sp scratchpads[] = {
|
||||
/* name cmd */
|
||||
{"spterm", spcmd1},
|
||||
};
|
||||
|
||||
/* Tags
|
||||
* In a traditional dwm the number of tags in use can be changed simply by changing the number
|
||||
* of strings in the tags array. This build does things a bit different which has some added
|
||||
* benefits. If you need to change the number of tags here then change the NUMTAGS macro in dwm.c.
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* 1) static char *tagicons[][NUMTAGS*2] = {
|
||||
* [DEFAULT_TAGS] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I" },
|
||||
* }
|
||||
*
|
||||
* 2) static char *tagicons[][1] = {
|
||||
* [DEFAULT_TAGS] = { "•" },
|
||||
* }
|
||||
*
|
||||
* The first example would result in the tags on the first monitor to be 1 through 9, while the
|
||||
* tags for the second monitor would be named A through I. A third monitor would start again at
|
||||
* 1 through 9 while the tags on a fourth monitor would also be named A through I. Note the tags
|
||||
* count of NUMTAGS*2 in the array initialiser which defines how many tag text / icon exists in
|
||||
* the array. This can be changed to *3 to add separate icons for a third monitor.
|
||||
*
|
||||
* For the second example each tag would be represented as a bullet point. Both cases work the
|
||||
* same from a technical standpoint - the icon index is derived from the tag index and the monitor
|
||||
* index. If the icon index is is greater than the number of tag icons then it will wrap around
|
||||
* until it an icon matches. Similarly if there are two tag icons then it would alternate between
|
||||
* them. This works seamlessly with alternative tags and alttagsdecoration patches.
|
||||
*/
|
||||
static char *tagicons[][NUMTAGS] = {
|
||||
[DEFAULT_TAGS] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" },
|
||||
[ALTERNATIVE_TAGS] = { "A", "B", "C", "D", "E", "F", "G", "H", "I" },
|
||||
[ALT_TAGS_DECORATION] = { "<1>", "<2>", "<3>", "<4>", "<5>", "<6>", "<7>", "<8>", "<9>" },
|
||||
};
|
||||
|
||||
|
||||
/* There are two options when it comes to per-client rules:
|
||||
* - a typical struct table or
|
||||
* - using the RULE macro
|
||||
*
|
||||
* A traditional struct table looks like this:
|
||||
* // class instance title wintype tags mask isfloating monitor
|
||||
* { "Gimp", NULL, NULL, NULL, 1 << 4, 0, -1 },
|
||||
* { "Firefox", NULL, NULL, NULL, 1 << 7, 0, -1 },
|
||||
*
|
||||
* The RULE macro has the default values set for each field allowing you to only
|
||||
* specify the values that are relevant for your rule, e.g.
|
||||
*
|
||||
* RULE(.class = "Gimp", .tags = 1 << 4)
|
||||
* RULE(.class = "Firefox", .tags = 1 << 7)
|
||||
*
|
||||
* Refer to the Rule struct definition for the list of available fields depending on
|
||||
* the patches you enable.
|
||||
*/
|
||||
static const Rule rules[] = {
|
||||
/* xprop(1):
|
||||
* WM_CLASS(STRING) = instance, class
|
||||
* WM_NAME(STRING) = title
|
||||
* WM_WINDOW_ROLE(STRING) = role
|
||||
* _NET_WM_WINDOW_TYPE(ATOM) = wintype
|
||||
*/
|
||||
RULE(.wintype = WTYPE "DIALOG", .isfloating = 1)
|
||||
RULE(.wintype = WTYPE "UTILITY", .isfloating = 1)
|
||||
RULE(.wintype = WTYPE "TOOLBAR", .isfloating = 1)
|
||||
RULE(.wintype = WTYPE "SPLASH", .isfloating = 1)
|
||||
//RULE(.class = "Gimp", .tags = 1 << 4)
|
||||
//RULE(.class = "Firefox", .tags = 1 << 7)
|
||||
RULE(.instance = "spterm", .tags = SPTAG(0), .isfloating = 1)
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Bar rules allow you to configure what is shown where on the bar, as well as
|
||||
* introducing your own bar modules.
|
||||
*
|
||||
* monitor:
|
||||
* -1 show on all monitors
|
||||
* 0 show on monitor 0
|
||||
* 'A' show on active monitor (i.e. focused / selected) (or just -1 for active?)
|
||||
* bar - bar index, 0 is default, 1 is extrabar
|
||||
* alignment - how the module is aligned compared to other modules
|
||||
* widthfunc, drawfunc, clickfunc - providing bar module width, draw and click functions
|
||||
* name - does nothing, intended for visual clue and for logging / debugging
|
||||
*/
|
||||
static const BarRule barrules[] = {
|
||||
/* monitor bar alignment widthfunc drawfunc clickfunc hoverfunc name */
|
||||
{ -1, 0, BAR_ALIGN_LEFT, width_tags, draw_tags, click_tags, hover_tags, "tags" },
|
||||
{ -1, 0, BAR_ALIGN_LEFT, width_ltsymbol, draw_ltsymbol, click_ltsymbol, NULL, "layout" },
|
||||
{ statusmon, 0, BAR_ALIGN_RIGHT, width_status, draw_status, click_status, NULL, "status" },
|
||||
{ -1, 0, BAR_ALIGN_NONE, width_wintitle, draw_wintitle, click_wintitle, NULL, "wintitle" },
|
||||
};
|
||||
|
||||
/* layout(s) */
|
||||
static const float mfact = 0.55; /* factor of master area size [0.05..0.95] */
|
||||
static const int nmaster = 1; /* number of clients in master area */
|
||||
static const int resizehints = 0; /* 1 means respect size hints in tiled resizals */
|
||||
static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */
|
||||
|
||||
|
||||
|
||||
static const Layout layouts[] = {
|
||||
/* symbol arrange function */
|
||||
{ "[]=", tile }, /* first entry is default */
|
||||
{ "><>", NULL }, /* no layout function means floating behavior */
|
||||
};
|
||||
|
||||
/* key definitions */
|
||||
#define MODKEY Mod4Mask
|
||||
#define TAGKEYS(KEY,TAG) \
|
||||
{ MODKEY, KEY, view, {.ui = 1 << TAG} }, \
|
||||
{ MODKEY|ControlMask, KEY, toggleview, {.ui = 1 << TAG} }, \
|
||||
{ MODKEY|ShiftMask, KEY, tag, {.ui = 1 << TAG} }, \
|
||||
{ MODKEY|ControlMask|ShiftMask, KEY, toggletag, {.ui = 1 << TAG} },
|
||||
|
||||
/* helper for spawning shell commands in the pre dwm-5.0 fashion */
|
||||
#define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
|
||||
|
||||
/* commands */
|
||||
static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
|
||||
static const char *dmenucmd[] = {
|
||||
"dmenu_run",
|
||||
"-m", dmenumon,
|
||||
"-fn", dmenufont,
|
||||
"-nb", normbgcolor,
|
||||
"-nf", normfgcolor,
|
||||
"-sb", selbgcolor,
|
||||
"-sf", selfgcolor,
|
||||
NULL
|
||||
};
|
||||
|
||||
static const char *termcmd[] = { "st", NULL };
|
||||
static const char *caja[] = { "caja", NULL };
|
||||
//static const char *floorp[] = { "floorp", NULL };
|
||||
static const char *firemenu[] = { "firemenu", NULL };
|
||||
|
||||
///////////////////////////////////////////////KEYBINDS//////////////////////////////////////////////
|
||||
#include <X11/XF86keysym.h>
|
||||
//different commands per OS
|
||||
#ifdef __linux__
|
||||
#define VOL_UP "pamixer --allow-boost -i 10; kill -44 $(pidof dwmblocks)"
|
||||
#define XK_UP "pamixer --allow-boost -i 5; kill -44 $(pidof dwmblocks)"
|
||||
#define VOL_DOWN "pamixer --allow-boost -d 10; kill -44 $(pidof dwmblocks)"
|
||||
#define XK_DOWN "pamixer --allow-boost -d 5; kill -44 $(pidof dwmblocks)"
|
||||
#define VOL_MUTE "pamixer -t; kill -44 $(pidof dwmblocks)"
|
||||
#define VOL_KILL "kill -44 $(pidof dwmblocks)"
|
||||
#elif __OpenBSD__
|
||||
#define VOL_UP "sndioctl output.level=+0.10; pkill -SIGUSR1 dwmblocks"
|
||||
#define XK_UP "sndioctl output.level=+0.05; pkill -SIGUSR1 dwmblocks"
|
||||
#define VOL_DOWN "sndioctl output.level=-0.10; pkill -SIGUSR1 dwmblocks"
|
||||
#define XK_DOWN "sndioctl output.level=-0.05; pkill -SIGUSR1 dwmblocks"
|
||||
#define VOL_MUTE "sndioctl output.mute=!; pkill -SIGUSR1 dwmblocks"
|
||||
#define VOL_KILL "pkill -SIGUSR1 dwmblocks"
|
||||
#elif __FreeBSD__
|
||||
#define VOL_UP "sndioctl output.level=+0.10"
|
||||
#define XK_UP "sndioctl output.level=+0.05"
|
||||
#define VOL_DOWN "sndioctl output.level=-0.10"
|
||||
#define XK_DOWN "sndioctl output.level=-0.05"
|
||||
#define VOL_MUTE "sndioctl output.level=-1"
|
||||
#define VOL_KILL "pkill -SIGUSR2 dwmblocks"
|
||||
#endif
|
||||
|
||||
static Key keys[] = {
|
||||
/*modifierkey function argument */
|
||||
{ Mod4Mask|ShiftMask, XK_r, spawn, {.v = firemenu } },
|
||||
{ MODKEY, XK_f, spawn, {.v = caja } },
|
||||
{ MODKEY, XK_r, spawn, {.v = dmenucmd } },
|
||||
{ MODKEY, XK_j, focusstack, {.i = +1 } },
|
||||
{ MODKEY, XK_k, focusstack, {.i = -1 } },
|
||||
{ MODKEY, XK_Down, moveresize, {.v = "0x 25y 0w 0h" } },
|
||||
{ MODKEY, XK_Up, moveresize, {.v = "0x -25y 0w 0h" } },
|
||||
{ MODKEY, XK_Right, moveresize, {.v = "25x 0y 0w 0h" } },
|
||||
{ MODKEY, XK_Left, moveresize, {.v = "-25x 0y 0w 0h" } },
|
||||
{ MODKEY|ShiftMask, XK_Down, moveresize, {.v = "0x 0y 0w 25h" } },
|
||||
{ MODKEY|ShiftMask, XK_Up, moveresize, {.v = "0x 0y 0w -25h" } },
|
||||
{ MODKEY|ShiftMask, XK_Right, moveresize, {.v = "0x 0y 25w 0h" } },
|
||||
{ MODKEY|ShiftMask, XK_Left, moveresize, {.v = "0x 0y -25w 0h" } },
|
||||
{ MODKEY, XK_Tab, view, {0} },
|
||||
{ MODKEY|ShiftMask, XK_F5, xrdb, {.v = NULL } },
|
||||
{ MODKEY, XK_t, setlayout, {.v = &layouts[0]} },
|
||||
{ MODKEY, XK_space, setlayout, {0} },
|
||||
{ MODKEY|ShiftMask, XK_space, togglefloating, {0} },
|
||||
{ MODKEY, XK_grave, togglescratch, {.ui = 0 } },
|
||||
{ MODKEY|ControlMask, XK_grave, setscratch, {.ui = 0 } },
|
||||
{ MODKEY|ShiftMask, XK_grave, removescratch, {.ui = 0 } },
|
||||
{ MODKEY, XK_w, togglefullscreen, {0} },
|
||||
{ MODKEY, XK_0, view, {.ui = ~SPTAGMASK } },
|
||||
{ MODKEY|ShiftMask, XK_0, tag, {.ui = ~SPTAGMASK } },
|
||||
|
||||
TAGKEYS( XK_1, 0)
|
||||
TAGKEYS( XK_2, 1)
|
||||
TAGKEYS( XK_3, 2)
|
||||
TAGKEYS( XK_4, 3)
|
||||
TAGKEYS( XK_5, 4)
|
||||
TAGKEYS( XK_6, 5)
|
||||
TAGKEYS( XK_7, 6)
|
||||
TAGKEYS( XK_8, 7)
|
||||
TAGKEYS( XK_9, 8)
|
||||
|
||||
{ MODKEY, XK_h, setmfact, {.f = -0.05} },
|
||||
{ MODKEY, XK_l, setmfact, {.f = +0.05} },
|
||||
{ MODKEY|ShiftMask, XK_q,quit, {0} },
|
||||
//{ MODKEY, XK_b, spawn, {.v = floorp} },
|
||||
{ MODKEY, XK_b, spawn, SHCMD("brave") },
|
||||
{ MODKEY, XK_m, togglebar, {0} },
|
||||
{ MODKEY, XK_o, incnmaster, {.i = +1 } },
|
||||
{ MODKEY, XK_Return, spawn, {.v = termcmd } },
|
||||
{ MODKEY|ShiftMask, XK_o, incnmaster, {.i = -1 } },
|
||||
{ MODKEY, XK_s, killclient, {0} },
|
||||
{ MODKEY|ShiftMask, XK_j, movestack, {.i = +1 } },
|
||||
{ MODKEY|ShiftMask, XK_k, movestack, {.i = -1 } },
|
||||
{ MODKEY|ShiftMask, XK_Return, togglescratch, {.ui = 0 } },
|
||||
{ 0, XK_F12, togglescratch, {.ui = 0 } },
|
||||
|
||||
//volume control
|
||||
{ Mod1Mask, XK_equal, spawn, SHCMD(VOL_UP) },
|
||||
{ Mod1Mask, XK_minus, spawn, SHCMD(VOL_DOWN) },
|
||||
{ Mod1Mask, XK_minus, spawn, SHCMD(VOL_DOWN) },
|
||||
{ 0, XF86XK_AudioMute, spawn, SHCMD(VOL_MUTE) },
|
||||
{ 0, XF86XK_AudioRaiseVolume, spawn, SHCMD(XK_UP) },
|
||||
{ 0, XF86XK_AudioLowerVolume, spawn, SHCMD(XK_DOWN) },
|
||||
//lock
|
||||
{ MODKEY|ShiftMask, XK_l, spawn, SHCMD("slock") },
|
||||
{ 0, XK_Print, spawn, SHCMD("screenie") },
|
||||
};
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/* button definitions */
|
||||
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
|
||||
static Button buttons[] = {
|
||||
/* click event mask button function argument */
|
||||
{ ClkLtSymbol, 0, Button1, setlayout, {0} },
|
||||
{ ClkLtSymbol, 0, Button3, setlayout, {.v = &layouts[2]} },
|
||||
{ ClkWinTitle, 0, Button2, zoom, {0} },
|
||||
{ ClkStatusText, 0, Button2, spawn, {.v = termcmd } },
|
||||
{ ClkClientWin, MODKEY, Button1, movemouse, {0} },
|
||||
{ ClkClientWin, MODKEY, Button2, togglefloating, {0} },
|
||||
{ ClkClientWin, MODKEY, Button3, resizemouse, {0} },
|
||||
{ ClkTagBar, 0, Button1, view, {0} },
|
||||
{ ClkTagBar, 0, Button3, toggleview, {0} },
|
||||
{ ClkTagBar, MODKEY, Button1, tag, {0} },
|
||||
{ ClkTagBar, MODKEY, Button3, toggletag, {0} },
|
||||
};
|
||||
|
||||
/* signal definitions */
|
||||
/* signum must be greater than 0 */
|
||||
/* trigger signals using `xsetroot -name "fsignal:<signame> [<type> <value>]"` */
|
||||
static Signal signals[] = {
|
||||
/* signum function */
|
||||
{ "focusstack", focusstack },
|
||||
{ "setmfact", setmfact },
|
||||
{ "togglebar", togglebar },
|
||||
{ "incnmaster", incnmaster },
|
||||
{ "togglefloating", togglefloating },
|
||||
{ "focusmon", focusmon },
|
||||
{ "tagmon", tagmon },
|
||||
{ "zoom", zoom },
|
||||
{ "incrgaps", incrgaps },
|
||||
{ "incrigaps", incrigaps },
|
||||
{ "incrogaps", incrogaps },
|
||||
{ "incrihgaps", incrihgaps },
|
||||
{ "incrivgaps", incrivgaps },
|
||||
{ "incrohgaps", incrohgaps },
|
||||
{ "incrovgaps", incrovgaps },
|
||||
{ "togglegaps", togglegaps },
|
||||
{ "defaultgaps", defaultgaps },
|
||||
{ "setgaps", setgapsex },
|
||||
{ "view", view },
|
||||
{ "viewall", viewallex },
|
||||
{ "viewex", viewex },
|
||||
{ "toggleview", toggleview },
|
||||
{ "toggleviewex", toggleviewex },
|
||||
{ "tag", tag },
|
||||
{ "tagall", tagallex },
|
||||
{ "tagex", tagex },
|
||||
{ "toggletag", toggletag },
|
||||
{ "toggletagex", toggletagex },
|
||||
{ "togglefullscreen", togglefullscreen },
|
||||
{ "fullscreen", fullscreen },
|
||||
{ "togglescratch", togglescratch },
|
||||
{ "killclient", killclient },
|
||||
{ "xrdb", xrdb },
|
||||
{ "quit", quit },
|
||||
{ "setlayout", setlayout },
|
||||
{ "setlayoutex", setlayoutex },
|
||||
};
|
||||
55
.suckless/config.mk
Normal file
55
.suckless/config.mk
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
# dwm version
|
||||
VERSION = 6.3
|
||||
|
||||
# Customize below to fit your system
|
||||
|
||||
# paths
|
||||
PREFIX = /usr/local
|
||||
MANPREFIX = ${PREFIX}/share/man
|
||||
|
||||
X11INC = /usr/X11R6/include
|
||||
X11LIB = /usr/X11R6/lib
|
||||
|
||||
# Xinerama, comment if you don't want it
|
||||
XINERAMALIBS = -lXinerama
|
||||
XINERAMAFLAGS = -DXINERAMA
|
||||
|
||||
# freetype
|
||||
FREETYPELIBS = -lfontconfig -lXft
|
||||
FREETYPEINC = /usr/include/freetype2
|
||||
|
||||
# Uncomment this for the alpha patch and the winicon patch (BAR_ALPHA_PATCH, BAR_WINICON_PATCH)
|
||||
XRENDER = -lXrender
|
||||
|
||||
# Uncomment this for the mdpcontrol patch / MDPCONTROL_PATCH
|
||||
#MPDCLIENT = -lmpdclient
|
||||
|
||||
# Uncomment for the pango patch / BAR_PANGO_PATCH
|
||||
#PANGOINC = `pkg-config --cflags xft pango pangoxft`
|
||||
#PANGOLIB = `pkg-config --libs xft pango pangoxft`
|
||||
|
||||
# Uncomment for the ipc patch / IPC_PATCH
|
||||
#YAJLLIBS = -lyajl
|
||||
#YAJLINC = -I/usr/include/yajl
|
||||
|
||||
# Uncomment this for the rounded corners patch / ROUNDED_CORNERS_PATCH
|
||||
#XEXTLIB = -lXext
|
||||
|
||||
# Uncomment this for the swallow patch / SWALLOW_PATCH
|
||||
XCBLIBS = -lX11-xcb -lxcb -lxcb-res
|
||||
|
||||
# This is needed for the winicon and tagpreview patches / BAR_WINICON_PATCH / BAR_TAGPREVIEW_PATCH
|
||||
#IMLIB2LIBS = -lImlib2
|
||||
|
||||
# includes and libs
|
||||
INCS = -I${X11INC} -I${FREETYPEINC} ${YAJLINC} ${PANGOINC}
|
||||
LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} ${XRENDER} ${MPDCLIENT} ${XEXTLIB} ${XCBLIBS} ${KVMLIB} ${PANGOLIB} ${YAJLLIBS} ${IMLIB2LIBS}
|
||||
|
||||
# flags
|
||||
CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_POSIX_C_SOURCE=200809L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS}
|
||||
#CFLAGS = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
|
||||
CFLAGS = -std=c99 -pedantic -Wall -Wno-unused-function -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS}
|
||||
LDFLAGS = ${LIBS}
|
||||
|
||||
# compiler and linker
|
||||
CC = cc
|
||||
40
.suckless/configure
vendored
Normal file
40
.suckless/configure
vendored
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
#!/bin/sh
|
||||
|
||||
#OS=$(printf 'Linux\nOpenBSD\nFreeBSD\nSolaris' | fzf --layout=reverse --height 40%)
|
||||
OS=$(uname)
|
||||
|
||||
case $OS in
|
||||
Linux) cp -f mkconfig/config.mk.linux config.mk ;;
|
||||
OpenBSD) cp -f mkconfig/config.mk.openbsd config.mk ;;
|
||||
FreeBSD) cp -f mkconfig/config.mk.freebsd config.mk ;;
|
||||
Solaris) cp -f mkconfig/config.mk.solaris config.mk ;;
|
||||
esac
|
||||
|
||||
#sed -i 's/##/#/g' config.mk
|
||||
#sed -i '14 s/^/#/' config.mk
|
||||
#sed -i '15 s/^/#/' config.mk
|
||||
#sed -i '25 s/^/#/' config.mk
|
||||
#sed -i '27 s/^/#/' config.mk
|
||||
#sed -i '29 s/^/#/' config.mk
|
||||
#sed -i '65 s/^/#/' config.mk
|
||||
#sed -i '66 s/^/#/' config.mk
|
||||
#sed -i 's/##/#/g' config.mk
|
||||
#
|
||||
#if [ "$OS" = "Linux" ]; then
|
||||
# true
|
||||
#else if [ "$OS" = "OpenBSD" ]; then
|
||||
# sed -i '27 s/.//' config.mk
|
||||
# sed -i '29 s/.//' config.mk
|
||||
#else if [ "$OS" = "FreeBSD" ]; then
|
||||
# sed -i '14 s/.//' config.mk
|
||||
# sed -i '15 s/.//' config.mk
|
||||
# sed -i '25 s/.//' config.mk
|
||||
#else if [ "$OS" = "Solaris" ]; then
|
||||
# sed -i '65 s/.//' config.mk
|
||||
# sed -i '66 s/.//' config.mk
|
||||
#fi
|
||||
#fi
|
||||
#fi
|
||||
#fi
|
||||
#
|
||||
#sed -i 's/##/#/g' config.mk
|
||||
451
.suckless/drw.c
Normal file
451
.suckless/drw.c
Normal file
|
|
@ -0,0 +1,451 @@
|
|||
/* See LICENSE file for copyright and license details. */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xft/Xft.h>
|
||||
|
||||
#include "drw.h"
|
||||
#include "util.h"
|
||||
|
||||
#define UTF_INVALID 0xFFFD
|
||||
#define UTF_SIZ 4
|
||||
|
||||
static const unsigned char utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0};
|
||||
static const unsigned char utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
|
||||
static const long utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000};
|
||||
static const long utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
|
||||
|
||||
|
||||
static long
|
||||
utf8decodebyte(const char c, size_t *i)
|
||||
{
|
||||
for (*i = 0; *i < (UTF_SIZ + 1); ++(*i))
|
||||
if (((unsigned char)c & utfmask[*i]) == utfbyte[*i])
|
||||
return (unsigned char)c & ~utfmask[*i];
|
||||
return 0;
|
||||
}
|
||||
|
||||
static size_t
|
||||
utf8validate(long *u, size_t i)
|
||||
{
|
||||
if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
|
||||
*u = UTF_INVALID;
|
||||
for (i = 1; *u > utfmax[i]; ++i)
|
||||
;
|
||||
return i;
|
||||
}
|
||||
|
||||
static size_t
|
||||
utf8decode(const char *c, long *u, size_t clen)
|
||||
{
|
||||
size_t i, j, len, type;
|
||||
long udecoded;
|
||||
|
||||
*u = UTF_INVALID;
|
||||
if (!clen)
|
||||
return 0;
|
||||
udecoded = utf8decodebyte(c[0], &len);
|
||||
if (!BETWEEN(len, 1, UTF_SIZ))
|
||||
return 1;
|
||||
for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
|
||||
udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
|
||||
if (type)
|
||||
return j;
|
||||
}
|
||||
if (j < len)
|
||||
return 0;
|
||||
*u = udecoded;
|
||||
utf8validate(u, len);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
Drw *
|
||||
drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h, Visual *visual, unsigned int depth, Colormap cmap)
|
||||
{
|
||||
Drw *drw = ecalloc(1, sizeof(Drw));
|
||||
|
||||
drw->dpy = dpy;
|
||||
drw->screen = screen;
|
||||
drw->root = root;
|
||||
drw->w = w;
|
||||
drw->h = h;
|
||||
|
||||
drw->visual = visual;
|
||||
drw->depth = depth;
|
||||
drw->cmap = cmap;
|
||||
drw->drawable = XCreatePixmap(dpy, root, w, h, depth);
|
||||
drw->gc = XCreateGC(dpy, drw->drawable, 0, NULL);
|
||||
XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);
|
||||
|
||||
return drw;
|
||||
}
|
||||
|
||||
void
|
||||
drw_resize(Drw *drw, unsigned int w, unsigned int h)
|
||||
{
|
||||
if (!drw)
|
||||
return;
|
||||
|
||||
drw->w = w;
|
||||
drw->h = h;
|
||||
if (drw->drawable)
|
||||
XFreePixmap(drw->dpy, drw->drawable);
|
||||
drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, drw->depth);
|
||||
}
|
||||
|
||||
void
|
||||
drw_free(Drw *drw)
|
||||
{
|
||||
XFreePixmap(drw->dpy, drw->drawable);
|
||||
XFreeGC(drw->dpy, drw->gc);
|
||||
drw_fontset_free(drw->fonts);
|
||||
free(drw);
|
||||
}
|
||||
|
||||
/* This function is an implementation detail. Library users should use
|
||||
* drw_fontset_create instead.
|
||||
*/
|
||||
static Fnt *
|
||||
xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
|
||||
{
|
||||
Fnt *font;
|
||||
XftFont *xfont = NULL;
|
||||
FcPattern *pattern = NULL;
|
||||
|
||||
if (fontname) {
|
||||
/* Using the pattern found at font->xfont->pattern does not yield the
|
||||
* same substitution results as using the pattern returned by
|
||||
* FcNameParse; using the latter results in the desired fallback
|
||||
* behaviour whereas the former just results in missing-character
|
||||
* rectangles being drawn, at least with some fonts. */
|
||||
if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname))) {
|
||||
fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname);
|
||||
return NULL;
|
||||
}
|
||||
if (!(pattern = FcNameParse((FcChar8 *) fontname))) {
|
||||
fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname);
|
||||
XftFontClose(drw->dpy, xfont);
|
||||
return NULL;
|
||||
}
|
||||
} else if (fontpattern) {
|
||||
if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern))) {
|
||||
fprintf(stderr, "error, cannot load font from pattern.\n");
|
||||
return NULL;
|
||||
}
|
||||
} else {
|
||||
die("no font specified.");
|
||||
}
|
||||
|
||||
/* Do not allow using color fonts. This is a workaround for a BadLength
|
||||
* error from Xft with color glyphs. Modelled on the Xterm workaround. See
|
||||
* https://bugzilla.redhat.com/show_bug.cgi?id=1498269
|
||||
* https://lists.suckless.org/dev/1701/30932.html
|
||||
* https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=916349
|
||||
* and lots more all over the internet.
|
||||
*/
|
||||
FcBool iscol;
|
||||
if (FcPatternGetBool(xfont->pattern, FC_COLOR, 0, &iscol) == FcResultMatch && iscol) {
|
||||
XftFontClose(drw->dpy, xfont);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
font = ecalloc(1, sizeof(Fnt));
|
||||
font->xfont = xfont;
|
||||
font->pattern = pattern;
|
||||
font->h = xfont->ascent + xfont->descent;
|
||||
font->dpy = drw->dpy;
|
||||
|
||||
return font;
|
||||
}
|
||||
|
||||
static void
|
||||
xfont_free(Fnt *font)
|
||||
{
|
||||
if (!font)
|
||||
return;
|
||||
if (font->pattern)
|
||||
FcPatternDestroy(font->pattern);
|
||||
XftFontClose(font->dpy, font->xfont);
|
||||
free(font);
|
||||
}
|
||||
|
||||
Fnt*
|
||||
drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount)
|
||||
{
|
||||
Fnt *cur, *ret = NULL;
|
||||
size_t i;
|
||||
|
||||
if (!drw || !fonts)
|
||||
return NULL;
|
||||
|
||||
for (i = 1; i <= fontcount; i++) {
|
||||
if ((cur = xfont_create(drw, fonts[fontcount - i], NULL))) {
|
||||
cur->next = ret;
|
||||
ret = cur;
|
||||
}
|
||||
}
|
||||
return (drw->fonts = ret);
|
||||
}
|
||||
|
||||
void
|
||||
drw_fontset_free(Fnt *font)
|
||||
{
|
||||
if (font) {
|
||||
drw_fontset_free(font->next);
|
||||
xfont_free(font);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
drw_clr_create(
|
||||
Drw *drw,
|
||||
Clr *dest,
|
||||
const char *clrname
|
||||
, unsigned int alpha
|
||||
) {
|
||||
if (!drw || !dest || !clrname)
|
||||
return;
|
||||
|
||||
if (!XftColorAllocName(drw->dpy, drw->visual, drw->cmap,
|
||||
clrname, dest))
|
||||
die("error, cannot allocate color '%s'", clrname);
|
||||
|
||||
dest->pixel = (dest->pixel & 0x00ffffffU) | (alpha << 24);
|
||||
}
|
||||
|
||||
/* Wrapper to create color schemes. The caller has to call free(3) on the
|
||||
* returned color scheme when done using it. */
|
||||
Clr *
|
||||
drw_scm_create(
|
||||
Drw *drw,
|
||||
char *clrnames[],
|
||||
const unsigned int alphas[],
|
||||
size_t clrcount
|
||||
) {
|
||||
size_t i;
|
||||
Clr *ret;
|
||||
|
||||
/* need at least two colors for a scheme */
|
||||
if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
|
||||
return NULL;
|
||||
|
||||
for (i = 0; i < clrcount; i++)
|
||||
drw_clr_create(drw, &ret[i], clrnames[i], alphas[i]);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void
|
||||
drw_setfontset(Drw *drw, Fnt *set)
|
||||
{
|
||||
if (drw)
|
||||
drw->fonts = set;
|
||||
}
|
||||
|
||||
void
|
||||
drw_setscheme(Drw *drw, Clr *scm)
|
||||
{
|
||||
if (drw)
|
||||
drw->scheme = scm;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
|
||||
{
|
||||
if (!drw || !drw->scheme)
|
||||
return;
|
||||
XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
|
||||
if (filled)
|
||||
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
|
||||
else
|
||||
XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
|
||||
}
|
||||
|
||||
int
|
||||
drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert, Bool ignored)
|
||||
{
|
||||
char buf[1024];
|
||||
int ty;
|
||||
unsigned int ew;
|
||||
XftDraw *d = NULL;
|
||||
Fnt *usedfont, *curfont, *nextfont;
|
||||
size_t i, len;
|
||||
int utf8strlen, utf8charlen, render = x || y || w || h;
|
||||
long utf8codepoint = 0;
|
||||
const char *utf8str;
|
||||
FcCharSet *fccharset;
|
||||
FcPattern *fcpattern;
|
||||
FcPattern *match;
|
||||
XftResult result;
|
||||
int charexists = 0;
|
||||
|
||||
if (!drw || (render && !drw->scheme) || !text || !drw->fonts)
|
||||
return 0;
|
||||
|
||||
if (!render) {
|
||||
w = ~w;
|
||||
} else {
|
||||
XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
|
||||
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
|
||||
d = XftDrawCreate(drw->dpy, drw->drawable, drw->visual, drw->cmap);
|
||||
x += lpad;
|
||||
w -= lpad;
|
||||
}
|
||||
|
||||
usedfont = drw->fonts;
|
||||
while (1) {
|
||||
utf8strlen = 0;
|
||||
utf8str = text;
|
||||
nextfont = NULL;
|
||||
while (*text) {
|
||||
utf8charlen = utf8decode(text, &utf8codepoint, UTF_SIZ);
|
||||
for (curfont = drw->fonts; curfont; curfont = curfont->next) {
|
||||
charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
|
||||
if (charexists) {
|
||||
if (curfont == usedfont) {
|
||||
utf8strlen += utf8charlen;
|
||||
text += utf8charlen;
|
||||
} else {
|
||||
nextfont = curfont;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!charexists || nextfont)
|
||||
break;
|
||||
else
|
||||
charexists = 0;
|
||||
}
|
||||
|
||||
if (utf8strlen) {
|
||||
drw_font_getexts(usedfont, utf8str, utf8strlen, &ew, NULL);
|
||||
/* shorten text if necessary */
|
||||
for (len = MIN(utf8strlen, sizeof(buf) - 1); len && ew > w; drw_font_getexts(usedfont, utf8str, len, &ew, NULL))
|
||||
len--;
|
||||
|
||||
if (len) {
|
||||
memcpy(buf, utf8str, len);
|
||||
buf[len] = '\0';
|
||||
if (len < utf8strlen)
|
||||
for (i = len; i && i > len - 3; buf[--i] = '.')
|
||||
; /* NOP */
|
||||
|
||||
if (render) {
|
||||
ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
|
||||
XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
|
||||
usedfont->xfont, x, ty, (XftChar8 *)buf, len);
|
||||
}
|
||||
x += ew;
|
||||
w -= ew;
|
||||
}
|
||||
}
|
||||
|
||||
if (!*text) {
|
||||
break;
|
||||
} else if (nextfont) {
|
||||
charexists = 0;
|
||||
usedfont = nextfont;
|
||||
} else {
|
||||
/* Regardless of whether or not a fallback font is found, the
|
||||
* character must be drawn. */
|
||||
charexists = 1;
|
||||
|
||||
fccharset = FcCharSetCreate();
|
||||
FcCharSetAddChar(fccharset, utf8codepoint);
|
||||
|
||||
if (!drw->fonts->pattern) {
|
||||
/* Refer to the comment in xfont_create for more information. */
|
||||
die("the first font in the cache must be loaded from a font string.");
|
||||
}
|
||||
|
||||
fcpattern = FcPatternDuplicate(drw->fonts->pattern);
|
||||
FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
|
||||
FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);
|
||||
FcPatternAddBool(fcpattern, FC_COLOR, FcFalse);
|
||||
|
||||
FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
|
||||
FcDefaultSubstitute(fcpattern);
|
||||
match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);
|
||||
|
||||
FcCharSetDestroy(fccharset);
|
||||
FcPatternDestroy(fcpattern);
|
||||
|
||||
if (match) {
|
||||
usedfont = xfont_create(drw, NULL, match);
|
||||
if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint)) {
|
||||
for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
|
||||
; /* NOP */
|
||||
curfont->next = usedfont;
|
||||
} else {
|
||||
xfont_free(usedfont);
|
||||
usedfont = drw->fonts;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (d)
|
||||
XftDrawDestroy(d);
|
||||
|
||||
return x + (render ? w : 0);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
|
||||
{
|
||||
if (!drw)
|
||||
return;
|
||||
|
||||
XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
|
||||
XSync(drw->dpy, False);
|
||||
}
|
||||
|
||||
unsigned int
|
||||
drw_fontset_getwidth(Drw *drw, const char *text, Bool markup)
|
||||
{
|
||||
if (!drw || !drw->fonts || !text)
|
||||
return 0;
|
||||
return drw_text(drw, 0, 0, 0, 0, 0, text, 0, markup);
|
||||
}
|
||||
|
||||
void
|
||||
drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
|
||||
{
|
||||
XGlyphInfo ext;
|
||||
|
||||
if (!font || !text)
|
||||
return;
|
||||
|
||||
XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
|
||||
if (w)
|
||||
*w = ext.xOff;
|
||||
if (h)
|
||||
*h = font->h;
|
||||
}
|
||||
|
||||
Cur *
|
||||
drw_cur_create(Drw *drw, int shape)
|
||||
{
|
||||
Cur *cur;
|
||||
|
||||
if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
|
||||
return NULL;
|
||||
|
||||
cur->cursor = XCreateFontCursor(drw->dpy, shape);
|
||||
|
||||
return cur;
|
||||
}
|
||||
|
||||
void
|
||||
drw_cur_free(Drw *drw, Cur *cursor)
|
||||
{
|
||||
if (!cursor)
|
||||
return;
|
||||
|
||||
XFreeCursor(drw->dpy, cursor->cursor);
|
||||
free(cursor);
|
||||
}
|
||||
|
||||
72
.suckless/drw.h
Normal file
72
.suckless/drw.h
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
/* See LICENSE file for copyright and license details. */
|
||||
|
||||
|
||||
typedef struct {
|
||||
Cursor cursor;
|
||||
} Cur;
|
||||
|
||||
typedef struct Fnt {
|
||||
Display *dpy;
|
||||
unsigned int h;
|
||||
XftFont *xfont;
|
||||
FcPattern *pattern;
|
||||
struct Fnt *next;
|
||||
} Fnt;
|
||||
|
||||
enum { ColFg, ColBg, ColBorder, ColFloat, ColCount }; /* Clr scheme index */
|
||||
typedef XftColor Clr;
|
||||
|
||||
typedef struct {
|
||||
unsigned int w, h;
|
||||
Display *dpy;
|
||||
int screen;
|
||||
Window root;
|
||||
Visual *visual;
|
||||
unsigned int depth;
|
||||
Colormap cmap;
|
||||
Drawable drawable;
|
||||
GC gc;
|
||||
Clr *scheme;
|
||||
Fnt *fonts;
|
||||
} Drw;
|
||||
|
||||
/* Drawable abstraction */
|
||||
Drw *drw_create(Display *dpy, int screen, Window win, unsigned int w, unsigned int h, Visual *visual, unsigned int depth, Colormap cmap);
|
||||
void drw_resize(Drw *drw, unsigned int w, unsigned int h);
|
||||
void drw_free(Drw *drw);
|
||||
|
||||
/* Fnt abstraction */
|
||||
Fnt *drw_fontset_create(Drw* drw, const char *fonts[], size_t fontcount);
|
||||
void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h);
|
||||
void drw_fontset_free(Fnt* set);
|
||||
unsigned int drw_fontset_getwidth(Drw *drw, const char *text, Bool markup);
|
||||
|
||||
/* Colorscheme abstraction */
|
||||
void drw_clr_create(
|
||||
Drw *drw,
|
||||
Clr *dest,
|
||||
const char *clrname
|
||||
, unsigned int alpha
|
||||
);
|
||||
Clr *drw_scm_create(
|
||||
Drw *drw,
|
||||
char *clrnames[],
|
||||
const unsigned int alphas[],
|
||||
size_t clrcount
|
||||
);
|
||||
|
||||
/* Cursor abstraction */
|
||||
Cur *drw_cur_create(Drw *drw, int shape);
|
||||
void drw_cur_free(Drw *drw, Cur *cursor);
|
||||
|
||||
/* Drawing context manipulation */
|
||||
void drw_setfontset(Drw *drw, Fnt *set);
|
||||
void drw_setscheme(Drw *drw, Clr *scm);
|
||||
|
||||
/* Drawing functions */
|
||||
void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert);
|
||||
int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert, Bool markup);
|
||||
|
||||
/* Map functions */
|
||||
void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h);
|
||||
|
||||
Loading…
Add table
Reference in a new issue