palette.cpp

Go to the documentation of this file.

#ifndef PALETTE_IMPLEMENTATION_FILE
#define PALETTE_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : palette                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "palette.h"
#include "wp_implementation.h"

#include <basis/function.h>
#include <basis/guards.h>

#include <stdlib.h>

static bool color_initted = false;
color BLACK(0, 0, 0);
color WHITE(MAXIMUM_COLOR_INTENSITY, MAXIMUM_COLOR_INTENSITY,
    MAXIMUM_COLOR_INTENSITY);

const int MAXIMUM_DEFAULT_COLORS = 64;

palette::palette(window_handle parent, int install_gray)
: _parent(parent, parent),
  graymap(NIL),
  number_in_graymap(0),
  maximum_colors_on_screen(0)
{
#ifdef __XWINDOWS__
  _colormap = XCreateColormap(_parent.display(), _parent.window(),
     DefaultVisual(_parent.display(), DefaultScreen(_parent.display())),
     AllocNone);
  if (!_colormap) non_continuable_error("palette", "palette", "NIL colormap");
  XSetWindowColormap(_parent.display(), _parent.window(), _colormap);
  maximum_colors_on_screen = DisplayCells
    (_parent.display(), DefaultScreen(_parent.display()));

  if (!color_initted) {
    add(BLACK);
    // copy part of the default colormap...
    Colormap default_colors = DefaultColormap
      (_parent.display(), DefaultScreen(_parent.display()));
    int colors_to_steal = minimum
      (maximum_colors_on_screen, MAXIMUM_DEFAULT_COLORS);
//hmmm: this really should be using the number actually currently mapped
//      rather than the total supported by the screen....
    for (int i = 0; i < colors_to_steal; i++) {
      XColor color_i;
      color_i.pixel = i;
      XQueryColor(_parent.display(), default_colors, &color_i);
      color to_stuff(color_i.red, color_i.green, color_i.blue);
      add(to_stuff);
        // updates colormap of ours by adding a default color to it.
    }
    add(WHITE);
    if (install_gray) install_gray_colormap(install_gray);
    color_initted = true;
  }
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}

palette::~palette() { if (graymap) delete [] graymap; }

void palette::apply(window_handle to_apply_to)
{
  nub to_attach(to_apply_to, to_apply_to);
  XSetWindowColormap(to_attach.display(), to_attach.window(), _colormap);
}

int palette::size_of_colormap() const { return maximum_colors_on_screen; }

window_color palette::translate(color &to_add_or_find)
{
  bool result;
  return add(to_add_or_find, result);
}

void palette::install_gray_colormap(int number_of_colors)
{
  if (number_of_colors <= 0) return;
    // no colors to allocate.
  if ( (number_in_graymap > 0) && graymap) return;
    // already allocated some colors.  in future this should be done better
    // by deallocating current gray scale colors...?

  number_in_graymap = number_of_colors;

  int gray_offset = 10000;
    // gray_offset: Chosen to lighten the images.
  int scale_factor
    = (MAXIMUM_COLOR_INTENSITY - gray_offset) / maximum_colors_on_screen;
  int map_ratio = maximum_colors_on_screen / number_of_colors;
  if (!map_ratio) map_ratio = 1;  // if more to allocate than possible?

//LOG(isprintf("number cols %d, scale %d, max col int %d, map ratio %d", number_of_colors, scale_factor, 255*scale_factor + gray_offset, map_ratio));

  graymap = new Pixel[maximum_colors_on_screen];

  for (int i = 0; i < maximum_colors_on_screen; i += map_ratio) {
//LOG(isprintf("i=%d, c=%d", i, gray_offset+i * scale_factor));
    int rgb_color_value = gray_offset + i * scale_factor;
    color pix_color(rgb_color_value, rgb_color_value, rgb_color_value);
    window_color mapped = translate(pix_color);
    int inner_bound = minimum(maximum_colors_on_screen, i + map_ratio);
    for (int j = i; j < inner_bound; j++) graymap[j] = mapped.pixel;
  }
}

bool palette::add(color &to_add)
{ bool result; add(to_add, result); return result; }

window_color palette::add(color &to_add, bool &success)
{
  FUNCDEF("add");
#ifdef __XWINDOWS__
  window_color to_return;
  if (to_add.index() >= 0) {
    to_return.pixel = to_add.index();
    to_return.flags = DoRed | DoGreen | DoBlue;
    XQueryColor(_parent.display(), _colormap, &to_return);
    return to_return;
  }
  to_return.red = to_add.red();
  to_return.green = to_add.green();
  to_return.blue = to_add.blue();
  success = XAllocColor(_parent.display(), _colormap, &to_return);
if (!success) LOG("could not add color");
  to_add.red(to_return.red);
  to_add.green(to_return.green);
  to_add.blue(to_return.blue);
  to_add.index(to_return.pixel);
    // the index must come after the three color values are set because the
    // color modifier functions reset the pixel index.
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
  return to_return;
}    

void palette::make_map(Pixel *map)
{
  if (!number_in_graymap) return;
  for (int i = 0; i < maximum_colors_on_screen; i++) map[i] = graymap[i];
}

color palette::lookup(const char *color_name)
{
  FUNCDEF("lookup");
#ifdef __XWINDOWS__
  Colormap temp = DefaultColormap(_parent.display(), _parent.screen());
  window_color approx;
  window_color exact;
  if (XLookupColor(_parent.display(), temp, color_name, &exact, &approx)) {
    color to_return(approx.red, approx.green, approx.blue);
    add(to_return);
    return to_return;
  } else {
    LOG(isprintf("cannot find color %s", color_name));
    return BLACK;
  }
#elif defined(MS_WINDOWS)
#elif defined(OS_2)
#endif
}


#endif //PALETTE_IMPLEMENTATION_FILE

---