problem with colors

[Ned Danieley <ned danieley duke edu>]

I need to display a bunch of colored rectangles, each of which could
have a different color. however, I'm unable to get more than 5 or 6
colors out of 256 tries. below is my test program (copied from
scribble-simple); can anyone see what I'm doing wrong? the palette
seems to be loading correctly, and in other tests produces a reasonable
spectrum.

is there a better way? I'm drawing cardiac activation maps, and I'll
eventually need 528 rectangles, with the ability to update the picture
when the user changes the input file.


/* example-start actMap actMap.c */

#include <stdio.h>
#include "gtk/gtk.h"

char *palette[256];

static GdkPixmap *pixmap = NULL;        /* Backing pixmap for drawing area */


/* Create a new backing pixmap of the appropriate size */
static gint
configure_event(GtkWidget *widget, GdkEventConfigure *event )
{
GtkRcStyle *rc_style;
GdkColor color;

        if (pixmap) gdk_pixmap_unref(pixmap);

        pixmap = gdk_pixmap_new(widget->window, widget->allocation.width,
                widget->allocation.height, -1);

        gdk_draw_rectangle (pixmap, widget->style->bg_gc[GTK_STATE_NORMAL],
                TRUE, 0, 0, widget->allocation.width, widget->allocation.height);

        return TRUE;
}

gint
delete_event( GtkWidget *widget, GdkEvent *event, gpointer data )
{
        gtk_main_quit();
        return(FALSE);
}

/* Draw a rectangle on the screen */

static void
drawRect(GtkWidget *widget, gpointer data)
{
GdkRectangle update_rect;
GtkRcStyle *rc_style;
GdkColor color;
gint i, j, num, temp;
char label[10];

        update_rect.width = 10;
        update_rect.height = 10;

        for (i = 0; i < 16; i++) {
                for (j = 0; j < 16; j++) {

                        update_rect.x = j * 20;
                        update_rect.y = i * 20;

                        gdk_color_parse (palette[(i * 16 + j)], &color);

/* After filling in your GdkColor, create a GtkRcStyle */

                        rc_style = gtk_rc_style_new ();

/* Set foreground (fg) color in normal state to color */
                        rc_style->fg[GTK_STATE_NORMAL] = color;

/* Indicate which colors the GtkRcStyle will affect; 
 * unflagged colors will follow the theme
 */
                        rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;

                        gtk_widget_modify_style (widget, rc_style);

                        gdk_draw_rectangle (pixmap, widget->style->fg_gc[GTK_STATE_NORMAL],
                                TRUE, update_rect.x, update_rect.y, update_rect.width,
                                update_rect.height);

                        gtk_rc_style_unref (rc_style);
                        }
                }
}

/* Redraw the screen from the backing pixmap */
static gint
expose_event(GtkWidget *widget, GdkEventExpose *event )
{
        gdk_draw_pixmap(widget->window,
                widget->style->fg_gc[GTK_WIDGET_STATE (widget)], pixmap,
                event->area.x, event->area.y, event->area.x, event->area.y,
                event->area.width, event->area.height);

        return FALSE;
}


void
loadPalette()
{
gint i;
guint16 red, green, blue;

        for (i = 0; i < 256; i++) palette[i] = (char *)malloc(8 * sizeof(char));

        for (i = 0; i < 256; i++) {
                if (i < 48) {
                        red = 255 * (48 - i) / 48;
                        green = 0;
                        blue = 255;
                        }
                else if (i < 86) {
                        red = 0;
                        green = 255 * (i - 48) / 38;
                        blue = 255;
                        }
                else if (i < 116) {
                        red = 0;
                        green = 255;
                        blue = 255 * (116 - i) / 30;
                        }
                else if (i < 162) {
                        red = 255 * (i - 116) / 46;
                        green = 255;
                        blue = 0;
                        }
                else if (i < 208) {
                        red = 255;
                        green = 255 * (208 - i) / 46;
                        blue = 0;
                        }
                else {
                        red = 255;
                        green = 0;
                        blue = 0;
                        }
                sprintf(palette[i], "#%.2x%.2x%.2x", red, green, blue);
                }

/*
        for (i = 0; i < 256; i++)
                fprintf(stderr, "palette[%d] %s\n", i, palette[i]);
*/
}


int
main(int argc, char *argv[]) 
{
void loadPalette();
GtkWidget *window;
GtkWidget *drawing_area;
GtkWidget *quitB, *updateB;
GtkWidget *vbox;
gint i;
        

        /* Our init, don't forget this! :) */
        gtk_init (&argc, &argv);

        loadPalette();

/* Create our window */

        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

/* You should always remember to connect the delete_event signal
 * to the main window. This is very important for proper intuitive
 * behavior
 */
        gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (delete_event), NULL);
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_container_add (GTK_CONTAINER (window), vbox);
        gtk_widget_show (vbox);

        drawing_area = gtk_drawing_area_new ();
        gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 350, 350);
        gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

        gtk_widget_show (drawing_area);

/* Signals used to handle backing pixmap */

        gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                (GtkSignalFunc) expose_event, NULL);
        gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                (GtkSignalFunc) configure_event, NULL);

/* update button. */
        updateB = gtk_button_new_with_label ("Update");

/* Setup the signal to update the display when the button is clicked */
        gtk_signal_connect(GTK_OBJECT (updateB), "clicked",
                GTK_SIGNAL_FUNC (drawRect), NULL);

        gtk_box_pack_start (GTK_BOX (vbox), updateB, FALSE, FALSE, 0);

/* Our quit button. */
        quitB = gtk_button_new_with_label ("Quit");

/* Setup the signal to terminate the program when the button is clicked */
        gtk_signal_connect_object (GTK_OBJECT (quitB), "clicked",
                GTK_SIGNAL_FUNC (gtk_main_quit), GTK_OBJECT (window));

        gtk_box_pack_start (GTK_BOX (vbox), quitB, FALSE, FALSE, 0);

        gtk_widget_show (updateB);
        gtk_widget_show (quitB);

/* Showing the window last so everything pops up at once. */
        gtk_widget_show (window);
        
        drawRect(drawing_area, 0);

        /* And of course, our main function. */
        gtk_main ();

        /* Control returns here when gtk_main_quit() is called, but not when 
         * gtk_exit is used. */
        
        return(0);
}
/* example-end */
-- 
Ned Danieley (ned danieley duke edu)
Experimental Electrophysiology Laboratory
Box 90295, Duke University
Durham, NC  27708   (919) 660-5111