Colors.cpp

   1 #include "Colors.h"
   2
   3 Colors colors;
   4
   5
   6 static uint16_t sixd_to_16bit(int x)
   7 {
   8         // This formula comes from st.
   9         return x == 0 ? 0 : 0x3737 + 0x2828 * x;
  10 }
  11
  12 void Colors::init(Display* display_in)
  13 {
  14         if (initialized)
  15                 return;
  16
  17         int i;
  18
  19         display = display_in;
  20         int screen = XDefaultScreen(display);
  21         Visual* visual = XDefaultVisual(display, screen);
  22         Colormap colormap = XDefaultColormap(display, screen);
  23         XRenderColor render_color;
  24         render_color.alpha = 0xFFFF;
  25
  26         // 16 "themed" colors.
  27         static uint32_t default_color_theme[] = {
  28                 0x000000, 0xCD0000, 0x00CD00, 0xCDCD00, 0x0000EE, 0xCD00CD, 0x00CDCD, 0xE5E5E5,
  29                 0x7F7F7F, 0xFF0000, 0x00FF00, 0xFFFF00, 0x5C5CFF, 0xFF00FF, 0x00FFFF, 0xFFFFFF,
  30                 };
  31         for (i = 0; i < 16; ++i) {
  32                 uint32_t color = default_color_theme[i];
  33                 render_color.red = (color & 0xFF0000) >> 8 | (color & 0xFF0000) >> 16;
  34                 render_color.green = (color & 0xFF00) | (color & 0xFF00) >> 8;
  35                 render_color.blue = (color & 0xFF) << 8 | (color & 0xFF);
  36                 XftColorAllocValue(
  37                         display, visual, colormap,
  38                         &render_color, &indexed_colors[i]);
  39                 }
  40
  41         // 216 6x6x6 colors.
  42         static const int greyscale_start = 16 + 6 * 6 * 6;
  43         for (i = 16; i < greyscale_start; ++i) {
  44                 int color = i - 16;
  45                 render_color.red = sixd_to_16bit((color / 36) % 6);
  46                 render_color.green = sixd_to_16bit((color / 6) % 6);
  47                 render_color.blue = sixd_to_16bit(color % 6);
  48                 XftColorAllocValue(
  49                         display, visual, colormap,
  50                         &render_color, &indexed_colors[i]);
  51                 }
  52
  53         // 24 greyscale colors.
  54         for (i = greyscale_start; i < 256; ++i) {
  55                 int greyness = i - greyscale_start;
  56                 render_color.red = 0x0808 + 0x0A0A * greyness;
  57                 render_color.green = render_color.blue = render_color.red;
  58                 XftColorAllocValue(
  59                         display, visual, colormap,
  60                         &render_color, &indexed_colors[i]);
  61                 }
  62
  63         initialized = true;
  64 }
  65
  66
  67 Colors::~Colors()
  68 {
  69         if (!initialized)
  70                 return;
  71
  72         int screen = XDefaultScreen(display);
  73         Visual* visual = XDefaultVisual(display, screen);
  74         Colormap colormap = XDefaultColormap(display, screen);
  75
  76         for (int i = 0; i < 256; ++i)
  77                 XftColorFree(display, visual, colormap, &indexed_colors[i]);
  78         for (auto& color: true_colors)
  79                 XftColorFree(display, visual, colormap, &color.second);
  80 }
  81
  82
  83 const XftColor* Colors::xft_color(uint32_t color)
  84 {
  85         if (color < 256)
  86                 return &indexed_colors[color];
  87
  88         // Otherwise, treat it as true color (even if the true_color_bit isn't set).
  89         color &= ~true_color_bit;
  90         if (true_colors.find(color) == true_colors.end()) {
  91                 // Don't have it yet.
  92                 XRenderColor render_color;
  93                 render_color.alpha = 0xFFFF;
  94                 render_color.red = (color & 0xFF0000) >> 8 | (color & 0xFF0000) >> 16;
  95                 render_color.green = (color & 0xFF00) | (color & 0xFF00) >> 8;
  96                 render_color.blue = (color & 0xFF) << 8 | (color & 0xFF);
  97
  98                 int screen = XDefaultScreen(display);
  99                 Visual* visual = XDefaultVisual(display, screen);
 100                 Colormap colormap = XDefaultColormap(display, screen);
 101                 XftColorAllocValue(
 102                         display, visual, colormap,
 103                         &render_color, &true_colors[color]);
 104                 }
 105         return &true_colors[color];
 106 }
 107
 108
 109