natcolormap.cc

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

/* Copyright (C) 2000  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

// Needed to avoid linking in libstdc++
#ifndef __STL_USE_EXCEPTIONS
#   include <java/lang/OutOfMemoryError.h>
#   define __THROW_BAD_ALLOC throw new java::lang::OutOfMemoryError()
#endif

#include <vector>

#include <X11/Xlib.h>

#include <gcj/cni.h>
#include <java/lang/RuntimeException.h>
#include <gnu/gcj/xlib/Display.h>
#include <gnu/gcj/xlib/Screen.h>
#include <gnu/gcj/xlib/Colormap.h>
#include <gnu/gcj/xlib/XColor.h>
#include <gnu/gcj/RawData.h>

jlong gnu::gcj::xlib::Colormap::allocateColorPixel(XColor* color)
{
  ::Display* dpy = (::Display*) (screen->getDisplay()->display);
  ::XColor* col = (::XColor*) (color->structure);
  Status result = XAllocColor(dpy, xid, col);
  if (result == 0)
    throw new java::lang::RuntimeException(
      JvNewStringLatin1("Unable to allocate color pixel."));

  return col->pixel;
}

typedef JArray<gnu::gcj::xlib::XColor*>* xcolorarray;

xcolorarray gnu::gcj::xlib::Colormap::getSharedColors()
{
  ::Display* dpy = (::Display*) (screen->getDisplay()->display);
  unsigned int nCells = CellsOfScreen(ScreenOfDisplay(dpy, screen->screenNumber));

  typedef ::XColor xcolor;
  std::vector<xcolor> colors(nCells);
  for (unsigned int i=0; i<nCells; i++)
    colors[i].pixel = i;
  ::XColor* cols = colors.get_allocator().address(colors.front());
  XQueryColors(dpy, xid, cols,
	       nCells);

  int nShared = 0;
  for (unsigned int i=0; i<nCells; i++)
    {
      ::XColor color = colors[i];

      if (!XAllocColor(dpy, xid, &color))
	continue;

      /* FIXME: In some cases this algorithm may identify a free
	 color cell as a shared one. */
      if (color.pixel != i)
	{
	  // Oops, the color wasn't shared. Free it.
	  XFreeColors(dpy, xid, &(color.pixel), 1, 0);
	  colors[i].flags = FLAG_NOT_SHARED;
	  continue;
	}
      
      // FIXME: Shared or free?
      
      nShared++;
      colors[i].flags = FLAG_SHARED;
    }
  
  JArray<XColor*>* shared = newXColorArray(nShared);
  int si=0;
  for (unsigned int i=0; i<nCells; i++)
    {
      if (colors[i].flags != FLAG_SHARED)
	continue;
      
      XColor* col = elements(shared)[si++];
      gnu::gcj::RawData* colorData = col->structure;
      ::XColor* colStruct = reinterpret_cast<xcolor*>(colorData);
      *colStruct = colors[i];
    }

  return shared;
}

xcolorarray gnu::gcj::xlib::Colormap::getXColors()
{
  ::Display* dpy = (::Display*) (screen->getDisplay()->display);
  unsigned int nCells =
    CellsOfScreen(ScreenOfDisplay(dpy, screen->screenNumber));
  
  typedef ::XColor xcolor;
  std::vector<xcolor> colors(nCells);
  
  JArray<XColor*>* colArray = newXColorArray(nCells);
  
  for (unsigned int i=0; i<nCells; i++)
    colors[i].pixel = i;
  
  XQueryColors(dpy, xid, &(colors.front()), nCells);

  /* TODO: The current problem with this code is that it relies on
     (color.pixel == i) as an indicator that the color is
     shared. However, (color.pixel == i), may also occur simply
     because color cell i simply was the next free in the list of
     unallocated color cells.  IDEA: run through the list both
     backwards and forwards, and only pick out the colorcells that
     have been identified as shared during both passes.  Reversing the
     traversal direction might prevent i from corresponding to the
     next free colorcell, atleast in one of the passes. */
  for (unsigned int i=0; i<nCells; i++)
    {
      ::XColor color = colors[i];
      
      char flag = FLAG_NOT_SHARED;
      if (XAllocColor(dpy, xid, &color))
	{
	  if (color.pixel == i)
	    {
	      flag = FLAG_SHARED;
	    }
	  else
	    {
	      // Oops, the color wasn't shared. Free it.
	      XFreeColors(dpy, xid, &(color.pixel), 1, 0);
	    }
	}
      
      // Copy color data into object in array
      XColor* col = elements(colArray)[i];
      gnu::gcj::RawData* colorData = col->structure;
      ::XColor* colStruct = reinterpret_cast<xcolor*>(colorData);
      *colStruct = colors[i];
      colStruct->flags = flag;
    }
  
  return colArray;
}