308 lines
7.3 KiB
C
308 lines
7.3 KiB
C
/* grTk2.c -
|
|
*
|
|
* Copyright 2003 Open Circuit Design, Inc., for MultiGiG Ltd.
|
|
*
|
|
* This file contains additional functions to manipulate an X
|
|
* color display. Included here are rectangle drawing and color map
|
|
* loading.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
char *getenv();
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
|
|
#include "tcltk/tclmagic.h"
|
|
#include "utils/magic.h"
|
|
#include "textio/textio.h"
|
|
#include "utils/geometry.h"
|
|
#include "graphics/glyphs.h"
|
|
#include "windows/windows.h"
|
|
#include "graphics/graphics.h"
|
|
#include "graphics/graphicsInt.h"
|
|
#include "grTkInt.h"
|
|
|
|
extern unsigned long grPixels[256];
|
|
extern unsigned long grPlanes[256];
|
|
extern XColor colors[256 * 3];
|
|
extern Colormap grXcmap;
|
|
|
|
|
|
/*---------------------------------------------------------------------
|
|
* GrXSetCMap:
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* The values in the color map are set from the default colormap
|
|
* table (see grCMap.c). X color cells are allocated if this
|
|
* display has more than 1 plane.
|
|
*
|
|
*---------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
GrTkSetCMap()
|
|
{
|
|
int i,j;
|
|
int red, green, blue;
|
|
int red_size, green_size, blue_size;
|
|
int red_shift, green_shift, blue_shift;
|
|
unsigned long grCompleteMask;
|
|
|
|
/* grCompleteMask is a mask of all the planes not used by this
|
|
* technology. It is OR'd in with the mask that magic supplies
|
|
* to ensure that unused bits of the pixel are cleared.
|
|
*/
|
|
|
|
if (grDisplay.planeCount > 8) {
|
|
grCompleteMask = 0;
|
|
if (grDisplay.planeCount == 16)
|
|
{
|
|
red_size = 5;
|
|
green_size = 6;
|
|
blue_size = 5;
|
|
}
|
|
else if (grDisplay.planeCount == 15)
|
|
{
|
|
red_size = 5;
|
|
green_size = 5;
|
|
blue_size = 5;
|
|
}
|
|
else {
|
|
red_size = 8;
|
|
green_size = 8;
|
|
blue_size = 8;
|
|
}
|
|
red_shift = green_size + blue_size;
|
|
green_shift = blue_size;
|
|
if ((grDisplay.planeCount == 24) && (grDisplay.red_mask == 0xff))
|
|
{
|
|
/* this is SUN Solaris doing it backwards: BGR */
|
|
red_shift = 0;
|
|
green_shift = red_size;
|
|
blue_shift = green_size + red_size;
|
|
}
|
|
|
|
/* DANGER! Modify the code below with care: gcc 2.7.2 generates bad */
|
|
/* code if the masks are not used as below. */
|
|
|
|
for (i = 0; i < grDisplay.colorCount; i++)
|
|
{
|
|
if (!(GrGetColor(i, &red, &green, &blue))) break;
|
|
|
|
if ((grDisplay.planeCount == 16) || (grDisplay.planeCount ==15))
|
|
{
|
|
grPixels[i] = (long)((red >> (8 - red_size))
|
|
<< (green_size + blue_size)) & grDisplay.red_mask; /* red */
|
|
grPixels[i] |= (long)((green >> (8 - green_size))
|
|
<< blue_size) & grDisplay.green_mask; /* green */
|
|
grPixels[i] |= (long)(blue >> (8 - blue_size))
|
|
& grDisplay.blue_mask; /* blue */
|
|
}
|
|
else if ((grDisplay.planeCount == 24) && (grDisplay.red_mask == 0xff))
|
|
{
|
|
/* this is SUN Solaris doing it backwards: BGR */
|
|
grPixels[i] = (long)(red & grDisplay.red_mask);
|
|
/* here is where gcc really goes wrong (sign extends) */
|
|
grPixels[i] |= (long)((green << green_shift) & grDisplay.green_mask);
|
|
grPixels[i] |= (long)((blue << blue_shift) & grDisplay.blue_mask);
|
|
}
|
|
else {
|
|
grPixels[i] = (long)((red << red_shift) & grDisplay.red_mask);
|
|
grPixels[i] |= (long)((green << green_shift) & grDisplay.green_mask);
|
|
grPixels[i] |= (long)(blue & grDisplay.blue_mask);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < grDisplay.planeCount; i++)
|
|
{
|
|
grDisplay.planes[i] = 1 << i;
|
|
grPlanes[i] = 0;
|
|
for (j = 0; j != grDisplay.planeCount; j++)
|
|
if (i & (1 << j))
|
|
{
|
|
grPlanes[i] |= grDisplay.planes[j];
|
|
}
|
|
}
|
|
}
|
|
else /* grDisplay.planeCount <= 8 */
|
|
{
|
|
grCompleteMask = 0;
|
|
for (i=0; i < grDisplay.planeCount; i++)
|
|
{
|
|
grCompleteMask |= grDisplay.planes[i];
|
|
}
|
|
grCompleteMask = AllPlanes & ~grCompleteMask;
|
|
|
|
for (i = 0; i < grDisplay.colorCount; i++)
|
|
{
|
|
grPixels[i] = grDisplay.basepixel;
|
|
grPlanes[i] = grCompleteMask;
|
|
for (j = 0; j != grDisplay.planeCount; j++)
|
|
if (i & (1 << j))
|
|
{
|
|
grPixels[i] |= grDisplay.planes[j];
|
|
grPlanes[i] |= grDisplay.planes[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (grDisplay.depth)
|
|
{
|
|
for (i = 0; i < grDisplay.realColors; i++)
|
|
{
|
|
if (!(GrGetColor(i, &red, &green, &blue))) break;
|
|
colors[i].pixel = grPixels[i];
|
|
colors[i].red = (unsigned short)(red << 8);
|
|
colors[i].green = (unsigned short)(green << 8);
|
|
colors[i].blue = (unsigned short)(blue << 8);
|
|
colors[i].flags = DoRed | DoGreen | DoBlue;
|
|
}
|
|
if (grDisplay.planeCount <= 8)
|
|
{
|
|
XStoreColors(grXdpy, grXcmap, colors, grDisplay.realColors);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
grPixels[0] = WhitePixel(grXdpy,grXscrn);
|
|
grPixels[1] = BlackPixel(grXdpy,grXscrn);
|
|
grPlanes[0] = 0;
|
|
grPlanes[1] = AllPlanes;
|
|
}
|
|
}
|
|
|
|
XSegment grtkLines[TK_BATCH_SIZE];
|
|
int grtkNbLines=0;
|
|
XRectangle grtkRects[TK_BATCH_SIZE];
|
|
int grtkNbRects=0;
|
|
|
|
|
|
/*---------------------------------------------------------
|
|
* grtkDrawLines:
|
|
* This routine draws a batch of lines.
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* Draw a bunch of lines.
|
|
*---------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
grtkDrawLines(lines, nb)
|
|
XSegment lines[];
|
|
int nb;
|
|
{
|
|
XDrawSegments(grXdpy, grCurrent.windowid, grGCDraw,
|
|
lines, nb);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------
|
|
* grtkDrawLine:
|
|
* This routine draws a line.
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* Draw a line for (x1, y1) to (x2, y2) inclusive.
|
|
*---------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
grtkDrawLine (x1, y1, x2, y2)
|
|
int x1, y1; /* Screen coordinates of first point. */
|
|
int x2, y2; /* Screen coordinates of second point. */
|
|
{
|
|
if (grtkNbLines == TK_BATCH_SIZE) GR_TK_FLUSH_LINES();
|
|
grtkLines[grtkNbLines].x1 = x1;
|
|
grtkLines[grtkNbLines].y1 = grMagicToX(y1);
|
|
grtkLines[grtkNbLines].x2 = x2;
|
|
grtkLines[grtkNbLines].y2 = grMagicToX(y2);
|
|
|
|
grtkNbLines++;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------
|
|
* grtkFillRects:
|
|
* This routine draws a bunch of solid rectangles.
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* Drawing.
|
|
*---------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
grtkFillRects(rects, nb)
|
|
XRectangle rects[];
|
|
int nb;
|
|
{
|
|
XFillRectangles(grXdpy, grCurrent.windowid, grGCFill, rects, nb);
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------
|
|
* grtkFillRect:
|
|
* This routine draws a solid rectangle.
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* Drawing.
|
|
*---------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
grtkFillRect(r)
|
|
Rect *r; /* Address of a rectangle in screen
|
|
* coordinates.
|
|
*/
|
|
{
|
|
if (grtkNbRects == TK_BATCH_SIZE) GR_TK_FLUSH_RECTS();
|
|
grtkRects[grtkNbRects].x = r->r_xbot;
|
|
grtkRects[grtkNbRects].y = grMagicToX(r->r_ytop);
|
|
grtkRects[grtkNbRects].width = r->r_xtop - r->r_xbot + 1;
|
|
grtkRects[grtkNbRects].height = r->r_ytop - r->r_ybot + 1;
|
|
|
|
grtkNbRects++;
|
|
|
|
}
|
|
|
|
/*
|
|
*---------------------------------------------------------
|
|
*
|
|
* grtkFillPolygon:
|
|
* This routine draws a solid polygon
|
|
*
|
|
* Results: None.
|
|
*
|
|
* Side Effects:
|
|
* Drawing.
|
|
*
|
|
*---------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
grtkFillPolygon(tp, np)
|
|
Point *tp;
|
|
int np;
|
|
{
|
|
XPoint xp[5];
|
|
int i;
|
|
|
|
for (i = 0; i < np; i++)
|
|
{
|
|
xp[i].x = tp[i].p_x;
|
|
xp[i].y = grMagicToX(tp[i].p_y);
|
|
}
|
|
XFillPolygon(grXdpy, grCurrent.windowid, grGCFill, xp, np,
|
|
Convex, CoordModeOrigin);
|
|
}
|
|
|