NeoMutt  2024-02-01-23-g345d7b
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
attr.c
Go to the documentation of this file.
1
30#include "config.h"
31#include <stddef.h>
32#include <assert.h>
33#include <string.h>
34#include "mutt/lib.h"
35#include "config/lib.h"
36#include "core/lib.h"
37#include "gui/lib.h"
38#include "attr.h"
39#include "color.h"
40#include "curses2.h"
41#include "debug.h"
42
50{
51 if (!ac)
52 return;
53
54 if (ac->curses_color)
55 color_debug(LL_DEBUG5, "clear %p\n", (void *) ac);
57
58 memset(&ac->fg, 0, sizeof(ac->fg));
59 memset(&ac->bg, 0, sizeof(ac->bg));
60
63 ac->attrs = A_NORMAL;
64}
65
70void attr_color_free(struct AttrColor **ptr)
71{
72 if (!ptr || !*ptr)
73 return;
74
75 struct AttrColor *ac = *ptr;
76 if (ac->ref_count > 1)
77 {
78 ac->ref_count--;
79 *ptr = NULL;
80 return;
81 }
82
84 FREE(ptr);
85}
86
92{
93 struct AttrColor *ac = mutt_mem_calloc(1, sizeof(*ac));
94
96 ac->fg.type = CT_SIMPLE;
98
100 ac->bg.type = CT_SIMPLE;
102
103 ac->attrs = A_NORMAL;
104
105 ac->ref_count = 1;
106
107 return ac;
108}
109
118void attr_color_list_clear(struct AttrColorList *acl)
119{
120 if (!acl)
121 return;
122
123 struct AttrColor *ac = NULL;
124 struct AttrColor *tmp = NULL;
125 TAILQ_FOREACH_SAFE(ac, acl, entries, tmp)
126 {
127 TAILQ_REMOVE(acl, ac, entries);
128 attr_color_free(&ac);
129 }
130}
131
140struct AttrColor *attr_color_list_find(struct AttrColorList *acl, color_t fg,
141 color_t bg, int attrs)
142{
143 if (!acl)
144 return NULL;
145
146 struct AttrColor *ac = NULL;
147 TAILQ_FOREACH(ac, acl, entries)
148 {
149 if (ac->attrs != attrs)
150 continue;
151
152 struct CursesColor *cc = ac->curses_color;
153 if (!cc)
154 continue;
155
156 if ((cc->fg == fg) && (cc->bg == bg))
157 return ac;
158 }
159 return NULL;
160}
161
167struct AttrColor attr_color_copy(const struct AttrColor *ac)
168{
169 if (ac)
170 return *ac;
171 else
172 return (struct AttrColor){ 0 };
173}
174
180bool attr_color_is_set(const struct AttrColor *ac)
181{
182 if (!ac)
183 return false;
184
185 return ((ac->attrs != A_NORMAL) || ac->curses_color);
186}
187
194bool attr_color_match(struct AttrColor *ac1, struct AttrColor *ac2)
195{
196 if ((!ac1) ^ (!ac2)) // One is set, but not the other
197 return false;
198
199 if (!ac1) // Two empty colours match
200 return true;
201
202 return ((ac1->curses_color == ac2->curses_color) && (ac1->attrs == ac2->attrs));
203}
204
212void modify_color_by_prefix(enum ColorPrefix prefix, bool is_fg, color_t *col, int *attrs)
213{
214 if (prefix == COLOR_PREFIX_NONE)
215 return; // nothing to do here
216
217 if (prefix == COLOR_PREFIX_ALERT)
218 {
219 *attrs |= A_BOLD;
220 *attrs |= A_BLINK;
221 }
222 else if (is_fg)
223 {
224 if ((COLORS >= 16) && (prefix == COLOR_PREFIX_LIGHT))
225 {
226 if (*col <= 7)
227 {
228 /* Advance the color 0-7 by 8 to get the light version */
229 *col += 8;
230 }
231 }
232 else
233 {
234 *attrs |= A_BOLD;
235 }
236 }
237 else
238 {
239 if (COLORS >= 16)
240 {
241 if (*col <= 7)
242 {
243 /* Advance the color 0-7 by 8 to get the light version */
244 *col += 8;
245 }
246 }
247 }
248}
249
250#ifdef NEOMUTT_DIRECT_COLORS
322{
323 static const color_t basic[] = {
324 0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080,
325 0x008080, 0xc0c0c0, 0x808080, 0xff0000, 0x00ff00, 0xffff00,
326 0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
327 };
328
329 assert(color < 256);
330
331 if (color < 0)
332 return color;
333
334 const bool c_color_directcolor = cs_subset_bool(NeoMutt->sub, "color_directcolor");
335 if (!c_color_directcolor)
336 {
337 return color;
338 }
339
340 if (color < 16)
341 {
342 color_debug(LL_DEBUG5, "Converted color 0-15: %d\n", color);
343 /* The first 16 colours are the "usual" terminal colours */
344 return basic[color];
345 }
346
347 if (color < 232)
348 {
349 /* The Color palette is divided in 6x6x6 colours, i.e. each R, G, B channel
350 * has six values:
351 *
352 * value: 1 2 3 4 5 6
353 * color: 0x00 0x5f 0x87 0xaf 0xd7 0xff
354 *
355 * The steps between the values is 0x28 = 40, the EXCEPT for the first one
356 * where it is 0x5f = 95.
357 *
358 * If we express the xterm color number minus 16 to base 6, i.e.
359 *
360 * color - 16 = (vr * 36) + (vg * 6) + (vb * 1)
361 *
362 * with vr, vg, vb integers between 0 and 5, then vr, vg, vb is the channel
363 * value for red, green, and blue, respectively.
364 */
365
366 color_t normalised_color = color - 16;
367 color_t vr = (normalised_color % 216) / 36; /* 216 = 6*6*6 */
368 color_t vg = (normalised_color % 36) / 6;
369 color_t vb = (normalised_color % 6) / 1;
370
371 /* First step is wider than the other ones, so add the difference if needed */
372 color_t r = (vr * 0x28) + ((vr > 0) ? (0x5f - 0x28) : 0);
373 color_t g = (vg * 0x28) + ((vg > 0) ? (0x5f - 0x28) : 0);
374 color_t b = (vb * 0x28) + ((vb > 0) ? (0x5f - 0x28) : 0);
375
376 color_t rgb = (r << 16) + (g << 8) + (b << 0);
377 color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
378 return rgb;
379 }
380
381 /* Grey scale starts at 0x08 and adds 0xa = 10 in very step ending in 0xee.
382 * There are a total of 6*4 = 24 grey colors in total. */
383 color_t steps = color - 232;
384 color_t grey = (steps * 0x0a) + 0x08;
385 color_t rgb = (grey << 16) + (grey << 8) + (grey << 0);
386 color_debug(LL_DEBUG5, "Converted xterm color %d to RGB #%x:\n", color, rgb);
387 return rgb;
388}
389#endif
390
396void attr_color_overwrite(struct AttrColor *ac_old, struct AttrColor *ac_new)
397{
398 if (!ac_old || !ac_new)
399 return;
400
401 color_t fg = ac_new->fg.color;
402 color_t bg = ac_new->bg.color;
403 int attrs = ac_new->attrs;
404
405 modify_color_by_prefix(ac_new->fg.prefix, true, &fg, &attrs);
406 modify_color_by_prefix(ac_new->bg.prefix, false, &bg, &attrs);
407
408#ifdef NEOMUTT_DIRECT_COLORS
409 if ((ac_new->fg.type == CT_SIMPLE) || (ac_new->fg.type == CT_PALETTE))
411 else if (fg < 8)
412 fg = 8;
413 if ((ac_new->bg.type == CT_SIMPLE) || (ac_new->bg.type == CT_PALETTE))
415 else if (bg < 8)
416 bg = 8;
417#endif
418
419 struct CursesColor *cc = curses_color_new(fg, bg);
421 ac_old->fg = ac_new->fg;
422 ac_old->bg = ac_new->bg;
423 ac_old->attrs = attrs;
424 ac_old->curses_color = cc;
425}
struct AttrColor * attr_color_list_find(struct AttrColorList *acl, color_t fg, color_t bg, int attrs)
Find an AttrColor in a list.
Definition: attr.c:140
void attr_color_overwrite(struct AttrColor *ac_old, struct AttrColor *ac_new)
Update an AttrColor in-place.
Definition: attr.c:396
void attr_color_clear(struct AttrColor *ac)
Free the contents of an AttrColor.
Definition: attr.c:49
color_t color_xterm256_to_24bit(const color_t color)
Convert a xterm color to its RGB value.
Definition: attr.c:321
bool attr_color_match(struct AttrColor *ac1, struct AttrColor *ac2)
Do the colours match?
Definition: attr.c:194
struct AttrColor attr_color_copy(const struct AttrColor *ac)
Copy a colour.
Definition: attr.c:167
struct AttrColor * attr_color_new(void)
Create a new AttrColor.
Definition: attr.c:91
void attr_color_free(struct AttrColor **ptr)
Free an AttrColor.
Definition: attr.c:70
void modify_color_by_prefix(enum ColorPrefix prefix, bool is_fg, color_t *col, int *attrs)
Modify a colour/attributes based on a prefix, e.g.
Definition: attr.c:212
void attr_color_list_clear(struct AttrColorList *acl)
Free the contents of an AttrColorList.
Definition: attr.c:118
bool attr_color_is_set(const struct AttrColor *ac)
Is the object coloured?
Definition: attr.c:180
Colour and attributes.
ColorPrefix
Constants for colour prefixes of named colours.
Definition: attr.h:45
@ COLOR_PREFIX_NONE
no prefix
Definition: attr.h:46
@ COLOR_PREFIX_ALERT
"alert" colour prefix
Definition: attr.h:47
@ COLOR_PREFIX_LIGHT
"light" colour prefix
Definition: attr.h:49
@ CT_SIMPLE
Simple colour, e.g. "Red".
Definition: attr.h:36
@ CT_PALETTE
Palette colour, e.g. "color207".
Definition: attr.h:37
Color and attribute parsing.
#define COLOR_DEFAULT
Definition: color.h:100
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:48
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
Curses Colour.
int32_t color_t
Type for 24-bit colour value.
Definition: curses2.h:31
struct CursesColor * curses_color_new(color_t fg, color_t bg)
Create a new CursesColor.
Definition: curses.c:151
void curses_color_free(struct CursesColor **ptr)
Free a CursesColor.
Definition: curses.c:120
Colour Debugging.
static int color_debug(enum LogLevel level, const char *format,...)
Definition: debug.h:53
Convenience wrapper for the gui headers.
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
#define FREE(x)
Definition: memory.h:45
Convenience wrapper for the library headers.
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:735
#define TAILQ_REMOVE(head, elm, field)
Definition: queue.h:841
A curses colour and its attributes.
Definition: attr.h:66
struct ColorElement bg
Background colour.
Definition: attr.h:68
struct ColorElement fg
Foreground colour.
Definition: attr.h:67
short ref_count
Number of users.
Definition: attr.h:71
int attrs
Text attributes, e.g. A_BOLD.
Definition: attr.h:69
struct CursesColor * curses_color
Underlying Curses colour.
Definition: attr.h:70
enum ColorType type
Type of Colour.
Definition: attr.h:58
color_t color
Colour.
Definition: attr.h:57
enum ColorPrefix prefix
Optional Colour Modifier.
Definition: attr.h:59
Colour in the ncurses palette.
Definition: curses2.h:41
color_t fg
Foreground colour.
Definition: curses2.h:42
color_t bg
Background colour.
Definition: curses2.h:43
Container for Accounts, Notifications.
Definition: neomutt.h:41
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:45