Esempio n. 1
0
static void
gimp_align_tool_draw (GimpDrawTool *draw_tool)
{
    GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (draw_tool);
    GList         *list;
    gint           x, y, w, h;

    /* draw rubber-band rectangle */
    x = MIN (align_tool->x2, align_tool->x1);
    y = MIN (align_tool->y2, align_tool->y1);
    w = MAX (align_tool->x2, align_tool->x1) - x;
    h = MAX (align_tool->y2, align_tool->y1) - y;

    gimp_draw_tool_add_rectangle (draw_tool, FALSE, x, y, w, h);

    for (list = align_tool->selected_objects;
            list;
            list = g_list_next (list))
    {
        if (GIMP_IS_ITEM (list->data))
        {
            GimpItem *item = list->data;

            if (GIMP_IS_VECTORS (item))
            {
                gdouble x1_f, y1_f, x2_f, y2_f;

                gimp_vectors_bounds (GIMP_VECTORS (item),
                                     &x1_f, &y1_f,
                                     &x2_f, &y2_f);
                x = ROUND (x1_f);
                y = ROUND (y1_f);
                w = ROUND (x2_f - x1_f);
                h = ROUND (y2_f - y1_f);
            }
            else
            {
                gimp_item_get_offset (item, &x, &y);

                w = gimp_item_get_width  (item);
                h = gimp_item_get_height (item);
            }

            gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                       x, y,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_HANDLE_ANCHOR_NORTH_WEST);
            gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                       x + w, y,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_HANDLE_ANCHOR_NORTH_EAST);
            gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                       x, y + h,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_HANDLE_ANCHOR_SOUTH_WEST);
            gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                       x + w, y + h,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_TOOL_HANDLE_SIZE_SMALL,
                                       GIMP_HANDLE_ANCHOR_SOUTH_EAST);
        }
        else if (GIMP_IS_GUIDE (list->data))
        {
            GimpGuide *guide = list->data;
            GimpImage *image = gimp_display_get_image (GIMP_TOOL (draw_tool)->display);
            gint       x, y;
            gint       w, h;

            switch (gimp_guide_get_orientation (guide))
            {
            case GIMP_ORIENTATION_VERTICAL:
                x = gimp_guide_get_position (guide);
                h = gimp_image_get_height (image);
                gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                           x, h,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_HANDLE_ANCHOR_SOUTH);
                gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                           x, 0,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_HANDLE_ANCHOR_NORTH);
                break;

            case GIMP_ORIENTATION_HORIZONTAL:
                y = gimp_guide_get_position (guide);
                w = gimp_image_get_width (image);
                gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                           w, y,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_HANDLE_ANCHOR_EAST);
                gimp_draw_tool_add_handle (draw_tool, GIMP_HANDLE_FILLED_SQUARE,
                                           0, y,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_TOOL_HANDLE_SIZE_SMALL,
                                           GIMP_HANDLE_ANCHOR_WEST);
                break;

            default:
                break;
            }
        }
    }
}
Esempio n. 2
0
static void
compute_offset (GObject *object,
                GimpAlignmentType  alignment)
{
  gint object_offset_x = 0;
  gint object_offset_y = 0;
  gint object_height   = 0;
  gint object_width    = 0;
  gint offset          = 0;

  if (GIMP_IS_IMAGE (object))
    {
      GimpImage *image = GIMP_IMAGE (object);

      object_offset_x = 0;
      object_offset_y = 0;
      object_height   = gimp_image_get_height (image);
      object_width    = gimp_image_get_width (image);
    }
  else if (GIMP_IS_CHANNEL (object))
    {
      /* for channels, we use the bounds of the visible area, not
         the layer bounds.  This includes the selection channel */

      GimpChannel *channel = GIMP_CHANNEL (object);

      if (gimp_channel_is_empty (channel))
        {
          /* fall back on using the offsets instead */
          GimpItem *item = GIMP_ITEM (object);

          gimp_item_get_offset (item, &object_offset_x, &object_offset_y);
          object_width  = gimp_item_get_width  (item);
          object_height = gimp_item_get_height (item);
        }
      else
        {
          gint x1, x2, y1, y2;

          gimp_channel_bounds (channel, &x1, &y1, &x2, &y2);
          object_offset_x = x1;
          object_offset_y = y1;
          object_width    = x2 - x1;
          object_height   = y2 - y1;
        }
    }
  else if (GIMP_IS_ITEM (object))
    {
      GimpItem *item = GIMP_ITEM (object);

      if (GIMP_IS_VECTORS (object))
        {
          gdouble x1_f, y1_f, x2_f, y2_f;

          gimp_vectors_bounds (GIMP_VECTORS (item),
                               &x1_f, &y1_f,
                               &x2_f, &y2_f);

          object_offset_x = ROUND (x1_f);
          object_offset_y = ROUND (y1_f);
          object_height   = ROUND (y2_f - y1_f);
          object_width    = ROUND (x2_f - x1_f);
        }
      else
        {
          gimp_item_get_offset (item, &object_offset_x, &object_offset_y);
          object_width  = gimp_item_get_width  (item);
          object_height = gimp_item_get_height (item);
        }
    }
  else if (GIMP_IS_GUIDE (object))
    {
      GimpGuide *guide = GIMP_GUIDE (object);

      switch (gimp_guide_get_orientation (guide))
        {
        case GIMP_ORIENTATION_VERTICAL:
          object_offset_x = gimp_guide_get_position (guide);
          object_width = 0;
          break;

        case GIMP_ORIENTATION_HORIZONTAL:
          object_offset_y = gimp_guide_get_position (guide);
          object_height = 0;
          break;

        default:
          break;
        }
    }
  else
    {
      g_printerr ("Alignment object is not an image, item or guide.\n");
    }

  switch (alignment)
    {
    case GIMP_ALIGN_LEFT:
    case GIMP_ARRANGE_LEFT:
      offset = object_offset_x;
      break;
    case GIMP_ALIGN_HCENTER:
    case GIMP_ARRANGE_HCENTER:
      offset = object_offset_x + object_width/2;
      break;
    case GIMP_ALIGN_RIGHT:
    case GIMP_ARRANGE_RIGHT:
      offset = object_offset_x + object_width;
      break;
    case GIMP_ALIGN_TOP:
    case GIMP_ARRANGE_TOP:
      offset = object_offset_y;
      break;
    case GIMP_ALIGN_VCENTER:
    case GIMP_ARRANGE_VCENTER:
      offset = object_offset_y + object_height/2;
      break;
    case GIMP_ALIGN_BOTTOM:
    case GIMP_ARRANGE_BOTTOM:
      offset = object_offset_y + object_height;
      break;
    default:
      g_assert_not_reached ();
    }

  g_object_set_data (object, "align-offset",
                     GINT_TO_POINTER (offset));
}