preview.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
#include <glib.h>
#include "preview.h"


static void
preview_close_cb
(
        GtkWidget * widget,
        GtkWidget *preview_window
)
{
        gtk_widget_destroy (preview_window);
}


static gboolean
preview_configure_event
(
        GtkWidget *widget,
        GdkEventConfigure *event
)
{
        gint depth = -1;
        if (pixmap)
                g_object_unref (pixmap);
        pixmap = gdk_pixmap_new (
                widget->window,
                widget->allocation.width,
                widget->allocation.height,
                depth);
        gdk_draw_rectangle (
                pixmap,
                widget->style->white_gc,
                TRUE,
                0,
                0,
                widget->allocation.width,
                widget->allocation.height);
        return TRUE;
}


void
preview_delete_event
(
        GtkWidget *widget,
        GdkEvent *event
)
{
        gtk_widget_destroy (widget);
}


int
preview_set_fg_color
(
        GdkGC *gc,
        const char *color_name
)
{
        if (!gc)
                return (EXIT_FAILURE);
        if (!color_name)
        {
                fprintf (stderr, "WARNING in %s():  color_name = NULL, setting color to magenta.\n",
                        __FUNCTION__);
                color_name = "magenta";
                return (EXIT_FAILURE);
        }
        GdkColor color;
        if (!gdk_color_parse (color_name, &color))
        {
                fprintf (stderr, "WARNING in %s():  could not parse color %s.\n",
                        __FUNCTION__, color_name);
                return (EXIT_FAILURE);
        }
        gdk_gc_set_foreground (gc, &color);
        return (EXIT_SUCCESS);
}


int
preview_set_fill_mode
(
        GdkGC *gc,
        GdkFill fill_mode
)
{
        if (!gc)
                return (EXIT_FAILURE);
        if (!fill_mode)
        {
                fprintf (stderr, "WARNING in %s():  fill mode = NULL, setting fill mode to SOLID.\n",
                        __FUNCTION__);
                fill_mode = GDK_SOLID;
                return (EXIT_FAILURE);
        }
        gdk_gc_set_fill
        (
                gc,
                fill_mode
        );
        return (EXIT_SUCCESS);
}


int
preview_set_line_cap
(
        GdkGC *gc,
        GdkCapStyle line_cap
)
{
        if (!gc)
                return (EXIT_FAILURE);
        if (!line_cap)
        {
                fprintf (stderr, "WARNING in %s():  line cap = NULL, setting line cap to ROUND.\n",
                        __FUNCTION__);
                line_cap = GDK_CAP_ROUND;
                return (EXIT_FAILURE);
        }
        GdkGCValues gc_values;
        gdk_gc_get_values (gc, &gc_values);
        gdk_gc_set_line_attributes
        (
                gc,
                gc_values.line_width,
                gc_values.line_style,
                line_cap,
                gc_values.join_style
        );
        return (EXIT_SUCCESS);
}


int
preview_set_line_style
(
        GdkGC *gc,
        GdkLineStyle line_style
)
{
        if (!gc)
                return (EXIT_FAILURE);
        if (!line_style)
        {
                fprintf (stderr, "WARNING in %s():  line style = NULL, setting line style  to SOLID.\n",
                        __FUNCTION__);
                line_style = GDK_LINE_SOLID;
                return (EXIT_FAILURE);
        }
        GdkGCValues gc_values;
        gdk_gc_get_values (gc, &gc_values);
        gdk_gc_set_line_attributes
        (
                gc,
                gc_values.line_width,
                line_style,
                gc_values.cap_style,
                gc_values.join_style
        );
        return (EXIT_SUCCESS);
}


int
preview_set_line_width
(
        GdkGC *gc,
        gint line_width
)
{
        if ((!gc) || (line_width == 0))
        {
                return (EXIT_FAILURE);
        }
        GdkGCValues gc_values;
        gdk_gc_get_values (gc, &gc_values);
        if (line_width < 0)
        {
                gdk_gc_set_line_attributes
                (
                        gc,
                        abs (line_width),
                        GDK_LINE_DOUBLE_DASH,
                        gc_values.cap_style,
                        gc_values.join_style
                );
        }
        else
        {
                gdk_gc_set_line_attributes
                (
                        gc,
                        line_width,
                        gc_values.line_style,
                        gc_values.cap_style,
                        gc_values.join_style
                );
        }
        return (EXIT_SUCCESS);
}


int
preview_use_gc
(
        GdkDrawable *drawable,
        GdkGC *gc,
        const char * color_name,
        gint line_width,
        GdkCapStyle line_cap,
        GdkLineStyle line_style,
        GdkFill fill_mode
)
{
        if (!drawable)
        {
                fprintf (stderr, "WARNING: couldn't allocate a gc, invalid drawable was passed.\n");
                return (EXIT_FAILURE);
        }
        if (!gc)
        {
                GdkGC *gc = gdk_gc_new (drawable);
                preview_set_fg_color (gc, color_name);
                preview_set_line_width (gc, line_width);
                preview_set_line_cap (gc, line_cap);
                preview_set_line_style (gc, line_style);
                preview_set_fill_mode (gc, fill_mode);
//                preview_set_draw_xor (gc, gc->xor);
                return (EXIT_SUCCESS);
        }
}


static void
preview_draw_arc
(
        GtkWidget *widget,
        preview_arc arc
)
{
        if (!arc)
        {
                fprintf (stderr, "WARNING: passed arc was invalid.\n");
                return;
        }
        /* Modify angles from degrees to Gdk format */
        arc->angle1 = 64.0 * arc->angle1;
        gdk_draw_arc
        (
                arc->drawable,
                arc->gc,
                arc->filled,
                arc->x,
                arc->y,
                arc->width,
                arc->height,
                arc->angle1,
                arc->angle2
        );
}


static void
preview_draw_background
(
        GtkWidget *widget,
        gdouble x,
        gdouble y
)
{
        GdkRectangle update_rect;
        update_rect.x = x - 5;
        update_rect.y = y - 5;
        update_rect.width = 10;
        update_rect.height = 10;
        gdk_draw_rectangle
        (
                pixmap,
                widget->style->black_gc,
                TRUE,
                update_rect.x,
                update_rect.y,
                update_rect.width,
                update_rect.height
        );
        gtk_widget_queue_draw_area
        (
                widget,
                update_rect.x,
                update_rect.y,
                update_rect.width,
                update_rect.height
        );
}


static void
preview_draw_line
(
        GtkWidget *widget,
        preview_line line
)
{
        if (!line)
        {
                fprintf (stderr, "WARNING: passed line was invalid.\n");
                return;
        }
        gdk_draw_line
        (
                line->drawable,
                line->gc,
                line->x1,
                line->y1,
                line->x2,
                line->y2
        );
}


static void
preview_draw_pad
(
        GtkWidget *widget
)
{
}


static void
preview_draw_pin
(
        GtkWidget *widget
)
{
}


static void
preview_draw_polygon
(
        GtkWidget *widget,
        preview_polygon polygon
)
{
        if (!polygon)
        {
                fprintf (stderr, "WARNING: passed polygon was invalid.\n");
                return;
        }
        gdk_draw_polygon
        (
                polygon->drawable,
                polygon->gc,
                polygon->filled,
                polygon->points,
                polygon->npoints
        );
}


static void
preview_draw_rectangle
(
        GtkWidget *widget,
        preview_rectangle rectangle
)
{
        if (!rectangle)
        {
                fprintf (stderr, "WARNING: passed rectangle was invalid.\n");
                return;
        }
        gdk_draw_rectangle
        (
                rectangle->drawable,
                rectangle->gc,
                rectangle->filled,
                rectangle->x,
                rectangle->y,
                rectangle->width,
                rectangle->height
        );
}


static gboolean
preview_expose_event
(
        GtkWidget *widget,
        GdkEventExpose *event
)
{
        gdk_draw_drawable (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;
}


int
preview_create_window
(
        gchar *footprint_name,
        gint width,
        gint height
)
{
        /* Create a preview window */
        GtkWidget *preview_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        /* Destroy the preview window when the main window of pcb-gfpw gets
         * destroyed */
        gtk_window_set_destroy_with_parent (GTK_WINDOW (preview_window), TRUE);
        /* Set the preview window title */
        gchar *preview_window_title = g_strdup_printf ("pcb-fpw preview: %s",
                footprint_name);
        gtk_window_set_title (GTK_WINDOW (preview_window),
                preview_window_title);
        g_free (preview_window_title);
        gtk_container_set_border_width (GTK_CONTAINER (preview_window), 10);
        /* Set signals for the window */
        g_signal_connect
        (
                GTK_OBJECT (preview_window),
                "delete_event",
                (GtkSignalFunc) preview_delete_event,
                NULL
        );
        /* Create a vertical box */
        GtkWidget *vbox = gtk_vbox_new (FALSE, 10);
        gtk_container_add (GTK_CONTAINER (preview_window), vbox);
        /* Create a preview drawing area */
        GtkWidget *preview_drawing_area = gtk_drawing_area_new ();
        gtk_widget_set_size_request (preview_drawing_area, width, height);
        /* Set signals for the drawing area */
        g_signal_connect
        (
                GTK_OBJECT (preview_drawing_area),
                "expose_event",
                (GtkSignalFunc) preview_expose_event,
                NULL
        );
        g_signal_connect
        (
                GTK_OBJECT (preview_drawing_area),
                "configure_event",
                (GtkSignalFunc) preview_configure_event,
                NULL
        );
        gtk_widget_set_events
        (
                preview_drawing_area,
                GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK
        );
        /* Create an adjustable viewport */
        GtkWidget *preview_viewport = gtk_viewport_new (NULL, NULL);
        gtk_viewport_set_shadow_type (GTK_VIEWPORT (preview_viewport), GTK_SHADOW_IN);
        /* Pack the viewport into the vbox */
        gtk_box_pack_start (GTK_BOX (vbox), preview_viewport, TRUE, TRUE, 0);
        /* Add the drawing area to the viewport container */
        gtk_container_add (GTK_CONTAINER (preview_viewport), preview_drawing_area);
        /* Create a horizontal button box */
        GtkWidget *hbox = gtk_hbutton_box_new ();
        gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
        /* Create a close button */
        GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
        g_signal_connect
        (
                G_OBJECT (button),
                "clicked",
                G_CALLBACK (preview_close_cb),
                preview_window
        );
        /* Pack the button into the hbox */
        gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
        /* Pack the hbox into the vbox */
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
        /* Get the correct size for the preview window */
        gtk_window_set_default_size
        (
                GTK_WINDOW (preview_window),
                width + 50,
                height + 50
        );
        /* Show the window */
        gtk_widget_realize (preview_window);
        gtk_widget_show_all (preview_window);
        /* Enter the GTK main loop */
        gtk_main ();
        return 0;
}

/* EOF */