o_picture.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * gschem - gEDA Schematic Capture
 * Copyright (C) 1998-2010 Ales Hvezda
 * Copyright (C) 1998-2011 gEDA Contributors (see ChangeLog for details)
 *
 * 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 program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <config.h>
#include <math.h>
#include <stdio.h>

#include "gschem.h"

/* This works, but using one macro inside of other doesn't */
#define GET_PICTURE_WIDTH(w)            \
  abs((w)->second_wx - (w)->first_wx) 
#define GET_PICTURE_HEIGHT(w)                       \
  (w)->pixbuf_wh_ratio == 0 ? 0 : abs((w)->second_wx - (w)->first_wx)/(w)->pixbuf_wh_ratio
#define GET_PICTURE_LEFT(w)         \
  min((w)->first_wx, (w)->second_wx)
#define GET_PICTURE_TOP(w)                      \
  (w)->first_wy > (w)->second_wy ? (w)->first_wy  :         \
  (w)->first_wy+abs((w)->second_wx - (w)->first_wx)/(w)->pixbuf_wh_ratio

void o_picture_start(GSCHEM_TOPLEVEL *w_current, int w_x, int w_y)
{
  /* init first_w[x|y], second_w[x|y] to describe box */
  w_current->first_wx = w_current->second_wx = w_x;
  w_current->first_wy = w_current->second_wy = w_y;

  /* start to draw the box */
  o_picture_invalidate_rubber (w_current);
  w_current->rubber_visible = 1;
}

void o_picture_end(GSCHEM_TOPLEVEL *w_current, int w_x, int w_y)
{
  TOPLEVEL *toplevel = w_current->toplevel;
  OBJECT *new_obj;
  int picture_width, picture_height;
  int picture_left, picture_top;

  g_assert( w_current->inside_action != 0 );

  /* erase the temporary picture */
  /* o_picture_draw_rubber(w_current); */
  w_current->rubber_visible = 0;
  
  picture_width  = GET_PICTURE_WIDTH (w_current);
  picture_height = GET_PICTURE_HEIGHT(w_current);
  picture_left   = GET_PICTURE_LEFT  (w_current);
  picture_top    = GET_PICTURE_TOP   (w_current);

  /* pictures with null width and height are not allowed */
  if ((picture_width == 0) && (picture_height == 0)) {
    /* cancel the object creation */
    return;
  }

  /* create the object */
  new_obj = o_picture_new(toplevel,
                          NULL, 0, w_current->pixbuf_filename,
                          OBJ_PICTURE,
                          picture_left, picture_top,
                          picture_left + picture_width,
                          picture_top - picture_height,
                          0, FALSE, FALSE);
  s_page_append (toplevel, toplevel->page_current, new_obj);

  /* Run %add-objects-hook */
  g_run_hook_object (w_current, "%add-objects-hook", new_obj);

  toplevel->page_current->CHANGED = 1;
  o_undo_savestate(w_current, UNDO_ALL);
}

void picture_selection_dialog (GSCHEM_TOPLEVEL *w_current)
{
  TOPLEVEL *toplevel = w_current->toplevel;
  gchar *filename;
  GdkPixbuf *pixbuf;
  GError *error = NULL;
  
  w_current->pfswindow = gtk_file_chooser_dialog_new ("Select a picture file...",
                              GTK_WINDOW(w_current->main_window),
                              GTK_FILE_CHOOSER_ACTION_OPEN,
                              GTK_STOCK_CANCEL, 
                              GTK_RESPONSE_CANCEL,
                              GTK_STOCK_OPEN, 
                              GTK_RESPONSE_ACCEPT,
                              NULL);
  /* Set the alternative button order (ok, cancel, help) for other systems */
  gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow),
                      GTK_RESPONSE_ACCEPT,
                      GTK_RESPONSE_CANCEL,
                      -1);

  if (w_current->pixbuf_filename)
    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), 
                  w_current->pixbuf_filename);
    
  if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) {

    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow));
    gtk_widget_destroy(w_current->pfswindow);
    w_current->pfswindow=NULL;

    pixbuf = gdk_pixbuf_new_from_file (filename, &error);
    
    if (!pixbuf) {
      GtkWidget *dialog;
      
      dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),
                       GTK_DIALOG_DESTROY_WITH_PARENT,
                       GTK_MESSAGE_ERROR,
                       GTK_BUTTONS_CLOSE,
                       _("Failed to load picture: %s"),
                       error->message);
      /* Wait for any user response */
      gtk_dialog_run (GTK_DIALOG (dialog));
      
      g_error_free (error);
      gtk_widget_destroy(dialog);
    }
    else {
#if DEBUG
      printf("Picture loaded succesfully.\n");
#endif
      
      o_invalidate_rubber(w_current);
      i_update_middle_button(w_current, i_callback_add_picture, _("Picture"));
      w_current->inside_action = 0;
      
      o_picture_set_pixbuf(w_current, pixbuf, filename);
    
      toplevel->page_current->CHANGED=1;
      i_set_state(w_current, DRAWPICTURE);
    }
    g_free (filename);
  }

  i_update_toolbar(w_current);
  if (w_current->pfswindow) {
    gtk_widget_destroy(w_current->pfswindow);
    w_current->pfswindow=NULL;
  }
}

void o_picture_invalidate_rubber (GSCHEM_TOPLEVEL *w_current)
{
  int left, top, width, height;

  WORLDtoSCREEN (w_current,
                 GET_PICTURE_LEFT(w_current), GET_PICTURE_TOP(w_current),
                 &left, &top);
  width = SCREENabs (w_current, GET_PICTURE_WIDTH (w_current));
  height = SCREENabs (w_current, GET_PICTURE_HEIGHT(w_current));

  o_invalidate_rect (w_current, left, top, left + width, top);
  o_invalidate_rect (w_current, left, top, left, top + height);
  o_invalidate_rect (w_current, left + width, top, left + width, top + height);
  o_invalidate_rect (w_current, left, top + height, left + width, top + height);
}

void o_picture_motion (GSCHEM_TOPLEVEL *w_current, int w_x, int w_y)
{
#if DEBUG
  printf("o_picture_rubberbox called\n");
#endif
  g_assert( w_current->inside_action != 0 );

  /* erase the previous temporary box */
  if (w_current->rubber_visible)
    o_picture_invalidate_rubber (w_current);

  /*
   * New values are fixed according to the <B>w_x</B> and <B>w_y</B> parameters. 
   * These are saved in <B>w_current</B> pointed structure as new temporary values. 
   * The new box is then drawn.
   */

  /* update the coords of the corner */
  w_current->second_wx = w_x;
  w_current->second_wy = w_y;

  /* draw the new temporary box */
  o_picture_invalidate_rubber (w_current);
  w_current->rubber_visible = 1;
}

void o_picture_draw_rubber (GSCHEM_TOPLEVEL *w_current)
{
  int left, top, width, height;

  /* get the width/height and the upper left corner of the picture */
  left =   GET_PICTURE_LEFT (w_current);
  top =    GET_PICTURE_TOP (w_current);
  width =  GET_PICTURE_WIDTH (w_current);
  height = GET_PICTURE_HEIGHT (w_current);

  gschem_cairo_box (w_current, 0, left, top - height, left + width, top);

  gschem_cairo_set_source_color (w_current,
                                 x_color_lookup_dark (SELECT_COLOR));
  gschem_cairo_stroke (w_current, TYPE_SOLID, END_NONE, 0, -1, -1);
}

void o_picture_draw (GSCHEM_TOPLEVEL *w_current, OBJECT *o_current)
{
  int s_upper_x, s_upper_y, s_lower_x, s_lower_y;
  GdkPixbuf *pixbuf;

  g_return_if_fail (w_current != NULL);
  g_return_if_fail (w_current->toplevel != NULL);
  g_return_if_fail (o_current != NULL);
  g_return_if_fail (o_current->picture != NULL);

  pixbuf = o_picture_get_pixbuf (w_current->toplevel, o_current);

  /* If the image failed to load, get the fallback image. */
  if (pixbuf == NULL) pixbuf = o_picture_get_fallback_pixbuf (w_current->toplevel);
  /* If the fallback image failed to load, draw a box with a cross in it. */
  if (pixbuf == NULL) {
    int line_width = (w_current->toplevel->line_style == THICK) ? LINE_WIDTH : 2;
    gschem_cairo_set_source_color (w_current,
                                   o_drawing_color (w_current, o_current));
    gschem_cairo_box (w_current, line_width,
                      o_current->picture->lower_x, o_current->picture->lower_y,
                      o_current->picture->upper_x, o_current->picture->upper_y);
    gschem_cairo_line (w_current, END_ROUND, line_width,
                      o_current->picture->lower_x, o_current->picture->lower_y,
                      o_current->picture->upper_x, o_current->picture->upper_y);
    gschem_cairo_line (w_current, END_ROUND, line_width,
                      o_current->picture->lower_x, o_current->picture->upper_y,
                      o_current->picture->upper_x, o_current->picture->lower_y);
    gschem_cairo_stroke (w_current, TYPE_SOLID, END_ROUND, line_width, -1, -1);
    return;
  }

  g_assert (GDK_IS_PIXBUF (pixbuf));

  WORLDtoSCREEN (w_current, o_current->picture->upper_x,
                            o_current->picture->upper_y, &s_upper_x, &s_upper_y);
  WORLDtoSCREEN (w_current, o_current->picture->lower_x,
                            o_current->picture->lower_y, &s_lower_x, &s_lower_y);

  cairo_save (w_current->cr);

  int swap_wh = (o_current->picture->angle == 90 || o_current->picture->angle == 270);
  float orig_width  = swap_wh ? gdk_pixbuf_get_height (pixbuf) :
                                gdk_pixbuf_get_width  (pixbuf);
  float orig_height = swap_wh ? gdk_pixbuf_get_width  (pixbuf) :
                                gdk_pixbuf_get_height (pixbuf);

  cairo_translate (w_current->cr, s_upper_x, s_upper_y);
  cairo_scale (w_current->cr,
    (float)SCREENabs (w_current, abs (o_current->picture->upper_x -
                                      o_current->picture->lower_x)) / orig_width,
    (float)SCREENabs (w_current, abs (o_current->picture->upper_y -
                                      o_current->picture->lower_y)) / orig_height);

  /* Evil magic translates picture origin to the right position for a given rotation */
  switch (o_current->picture->angle) {
    case 0:                                                               break;
    case 90:   cairo_translate (w_current->cr, 0,          orig_height);  break;
    case 180:  cairo_translate (w_current->cr, orig_width, orig_height);  break;
    case 270:  cairo_translate (w_current->cr, orig_width, 0          );  break;
  }
  cairo_rotate (w_current->cr, -o_current->picture->angle * M_PI / 180.);
  if (o_current->picture->mirrored) {
    cairo_translate (w_current->cr, gdk_pixbuf_get_width (pixbuf), 0);
    cairo_scale (w_current->cr, -1, 1);
  }

  gdk_cairo_set_source_pixbuf (w_current->cr,
                               pixbuf, 0,0);
  cairo_rectangle (w_current->cr, 0, 0,
                   gdk_pixbuf_get_width (pixbuf),
                   gdk_pixbuf_get_height (pixbuf));

  cairo_clip (w_current->cr);
  cairo_paint (w_current->cr);
  cairo_restore (w_current->cr);

  /* Grip specific stuff */
  if (o_current->selected && w_current->draw_grips) {
    o_picture_draw_grips (w_current, o_current);
  }

  g_object_unref (pixbuf);
}

void o_picture_draw_grips(GSCHEM_TOPLEVEL *w_current, OBJECT *o_current)
{
  if (w_current->draw_grips == FALSE)
    return;

  /* grip on upper left corner (whichone = PICTURE_UPPER_LEFT) */
  o_grips_draw (w_current, o_current->picture->upper_x,
                           o_current->picture->upper_y);

  /* grip on upper right corner (whichone = PICTURE_UPPER_RIGHT) */
  o_grips_draw (w_current, o_current->picture->lower_x,
                           o_current->picture->upper_y);

  /* grip on lower left corner (whichone = PICTURE_LOWER_LEFT) */
  o_grips_draw (w_current, o_current->picture->upper_x,
                           o_current->picture->lower_y);

  /* grip on lower right corner (whichone = PICTURE_LOWER_RIGHT) */
  o_grips_draw (w_current, o_current->picture->lower_x,
                           o_current->picture->lower_y);

  /* Box surrounding the picture */
  gschem_cairo_box (w_current, 0,
                    o_current->picture->upper_x, o_current->picture->upper_y,
                    o_current->picture->lower_x, o_current->picture->lower_y);

  gschem_cairo_set_source_color (w_current,
                                 x_color_lookup_dark (SELECT_COLOR));
  gschem_cairo_stroke (w_current, TYPE_SOLID, END_NONE, 0, -1, -1);
}


void o_picture_draw_place (GSCHEM_TOPLEVEL *w_current, int dx, int dy, OBJECT *o_current)
{
  if (o_current->picture == NULL) {
    return;
  }

  gschem_cairo_box (w_current, 0, o_current->picture->upper_x + dx,
                                  o_current->picture->upper_y + dy,
                                  o_current->picture->lower_x + dx,
                                  o_current->picture->lower_y + dy);

  gschem_cairo_set_source_color (w_current,
                                 x_color_lookup_dark (o_current->color));
  gschem_cairo_stroke (w_current, TYPE_SOLID, END_NONE, 0, -1, -1);
}

gboolean
o_picture_exchange (GSCHEM_TOPLEVEL *w_current,
                    const gchar *filename, GError **error)
{
  TOPLEVEL *toplevel = w_current->toplevel;
  GList *iter;

  for (iter = geda_list_get_glist (toplevel->page_current->selection_list);
       iter != NULL;
       iter = g_list_next (iter)) {

    OBJECT *object = (OBJECT *) iter->data;
    g_assert (object != NULL);

    if (object->type == OBJ_PICTURE) {
      gboolean status;

      /* Erase previous picture */
      o_invalidate (w_current, object);

      status = o_picture_set_from_file (toplevel, object, filename, error);
      if (!status) return FALSE;

      /* Draw new picture */
      o_invalidate (w_current, object);
    }
  }
  return TRUE;
}

void picture_change_filename_dialog (GSCHEM_TOPLEVEL *w_current)
{
  TOPLEVEL *toplevel = w_current->toplevel;
  gchar *filename;
  gboolean result;
  GError *error = NULL;
  
  w_current->pfswindow = gtk_file_chooser_dialog_new ("Select a picture file...",
                              GTK_WINDOW(w_current->main_window),
                              GTK_FILE_CHOOSER_ACTION_OPEN,
                              GTK_STOCK_CANCEL, 
                              GTK_RESPONSE_CANCEL,
                              GTK_STOCK_OPEN, 
                              GTK_RESPONSE_ACCEPT,
                              NULL);

  /* Set the alternative button order (ok, cancel, help) for other systems */
  gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->pfswindow),
                      GTK_RESPONSE_ACCEPT,
                      GTK_RESPONSE_CANCEL,
                      -1);

  if (w_current->pixbuf_filename)
    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(w_current->pfswindow), 
                  w_current->pixbuf_filename);
    
  if (gtk_dialog_run (GTK_DIALOG (w_current->pfswindow)) == GTK_RESPONSE_ACCEPT) {

    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->pfswindow));
    gtk_widget_destroy(w_current->pfswindow);
    w_current->pfswindow=NULL;

    /* Actually update the pictures */
    result = o_picture_exchange (w_current, filename, &error);

    if (!result) {
      GtkWidget *dialog;

      dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),
                       GTK_DIALOG_DESTROY_WITH_PARENT,
                       GTK_MESSAGE_ERROR,
                       GTK_BUTTONS_CLOSE,
                       _("Failed to replace pictures: %s"),
                       error->message);
      /* Wait for any user response */
      gtk_dialog_run (GTK_DIALOG (dialog));

      g_error_free (error);
      gtk_widget_destroy(dialog);
    } else {
      toplevel->page_current->CHANGED=1;
    }
    g_free (filename);
  }

  i_update_toolbar(w_current);
  if (w_current->pfswindow) {
    gtk_widget_destroy(w_current->pfswindow);
    w_current->pfswindow=NULL;
  }
}

void o_picture_set_pixbuf(GSCHEM_TOPLEVEL *w_current,
                          GdkPixbuf *pixbuf, char *filename)
{

  /* need to put an error messages here */
  if (pixbuf == NULL)  {
    fprintf(stderr, "error! picture in set pixbuf was NULL\n");
    return;
  }

  if (w_current->current_pixbuf != NULL) {
    g_object_unref(w_current->current_pixbuf);
    w_current->current_pixbuf=NULL;
  }

  if (w_current->pixbuf_filename != NULL) {
    g_free(w_current->pixbuf_filename);
    w_current->pixbuf_filename=NULL;
  }

  w_current->current_pixbuf = pixbuf;
  w_current->pixbuf_filename = (char *) g_strdup(filename);

  w_current->pixbuf_wh_ratio = (double) gdk_pixbuf_get_width(pixbuf) /
                                        gdk_pixbuf_get_height(pixbuf);

  /* be sure to free this pixbuf somewhere */
}