home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / plug-ins / common / rotate.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-01  |  19.2 KB  |  652 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  *  Rotate plug-in v1.0
  5.  *  Copyright 1997-2000 by Sven Neumann <sven@gimp.org> 
  6.  *                       & Adam D. Moss <adam@gimp.org>
  7.  * 
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21.  */
  22.  
  23. /* Revision history
  24.  *  (09/28/97)  v0.1   first development release 
  25.  *  (09/29/97)  v0.2   nicer dialog,
  26.  *                     changed the menu-location to Filters/Transforms
  27.  *  (10/01/97)  v0.3   now handles layered images and undo
  28.  *  (10/13/97)  v0.3a  small bugfix, no real changes
  29.  *  (10/17/97)  v0.4   now handles selections
  30.  *  (01/09/98)  v0.5   a few fixes to support portability
  31.  *  (01/15/98)  v0.6   fixed a line that caused rotate to crash on some 
  32.  *                     systems               
  33.  *  (05/28/98)  v0.7   use the new gimp_message function for error output
  34.  *  (10/09/99)  v0.8   rotate guides too
  35.  *  (11/13/99)  v0.9   merge rotators and rotate plug-ins 
  36.  *                     -> drop the dialog, register directly into menus instead
  37.  *  (06/18/00)  v1.0   speed up 180░ rotations, 
  38.  *                     declare version 1.0 for gimp-1.2 release
  39.  */
  40.  
  41. /* TODO List
  42.  *  - handle channels and masks
  43.  *  - rewrite the main function to make it work on tiles rather than
  44.  *    process the image row by row. This should result in a significant
  45.  *    speedup (thanks to quartic for this suggestion). 
  46.  *  - do something magical so that only one rotate can be occuring at a time!
  47.  */  
  48.  
  49. #include "config.h"
  50.  
  51. #include <stdlib.h>
  52. #include <string.h>
  53.  
  54. #include <libgimp/gimp.h>
  55.  
  56. #include "libgimp/stdplugins-intl.h"
  57.  
  58.  
  59. /* Defines */
  60. #define PLUG_IN_VERSION     "v1.0 (2000/06/18)"
  61. #define PLUG_IN_IMAGE_TYPES "RGB*, INDEXED*, GRAY*"
  62. #define PLUG_IN_AUTHOR      "Sven Neumann <sven@gimp.org>, Adam D. Moss <adam@gimp.org>"
  63. #define PLUG_IN_COPYRIGHT   "Sven Neumann, Adam D. Moss"
  64.  
  65.  
  66. typedef struct 
  67. {
  68.   gint angle;
  69.   gint everything;
  70. } RotateValues;
  71.  
  72. typedef struct 
  73. {
  74.   gint32 ID;
  75.   gint32 orientation;
  76.   gint32 position;
  77. } GuideInfo;
  78.  
  79. static RotateValues rotvals = 
  80. { 
  81.   1,        /* default to 90 degrees */
  82.   1         /* default to whole image */
  83. };
  84.  
  85.  
  86. static void  query   (void);
  87. static void  run     (gchar      *name,
  88.               gint        nparams,    
  89.               GimpParam  *param,    
  90.               gint       *nreturn_vals,  
  91.               GimpParam **return_vals);
  92.  
  93. static void  rotate                 (void);
  94. static void  rotate_drawable        (GimpDrawable *drawable);
  95. static void  rotate_compute_offsets (gint         *offsetx, 
  96.                      gint         *offsety, 
  97.                      gint          image_width, 
  98.                      gint          image_height,
  99.                      gint          width, 
  100.                      gint          height);
  101.  
  102. /* Global Variables */
  103. GimpPlugInInfo PLUG_IN_INFO =
  104. {
  105.   NULL,  /* init_proc  */
  106.   NULL,     /* quit_proc  */
  107.   query, /* query_proc */
  108.   run    /* run_proc   */
  109. };
  110.  
  111. /* the image and drawable that will be used later */
  112. static GimpDrawable *active_drawable = NULL;
  113. static gint32        image_ID = -1;
  114.  
  115. /* Functions */
  116.  
  117. MAIN ()
  118.  
  119. static void
  120. query (void)
  121. {
  122.   static GimpParamDef args[] =
  123.   {
  124.     { GIMP_PDB_INT32,    "run_mode",   "Interactive, non-interactive"},
  125.     { GIMP_PDB_IMAGE,    "image",      "Input image" },
  126.     { GIMP_PDB_DRAWABLE, "drawable",   "Input drawable" },
  127.     { GIMP_PDB_INT32,    "angle",      "Angle { 90 (1), 180 (2), 270 (3) } degrees" },
  128.     { GIMP_PDB_INT32,    "everything", "Rotate the whole image? { TRUE, FALSE }" }
  129.   };
  130.   static gint nargs = sizeof (args) / sizeof (args[0]);
  131.  
  132.   static GimpParamDef menuargs[] =
  133.   {
  134.     { GIMP_PDB_INT32,    "run_mode",   "Interactive, non-interactive" },
  135.     { GIMP_PDB_IMAGE,    "image",      "Input image" },
  136.     { GIMP_PDB_DRAWABLE, "drawable",   "Input drawable"}
  137.   };
  138.   static gint nmenuargs = sizeof (menuargs) / sizeof (menuargs[0]);
  139.  
  140.   gimp_install_procedure ("plug_in_rotate",
  141.               "Rotates a layer or the whole image by 90, 180 or 270 degrees",
  142.               "This plug-in does rotate the active layer or the "
  143.               "whole image clockwise by multiples of 90 degrees. "
  144.               "When the whole image is choosen, the image is "
  145.               "resized if necessary.",
  146.               PLUG_IN_AUTHOR,
  147.               PLUG_IN_COPYRIGHT,
  148.               PLUG_IN_VERSION,
  149.               NULL,
  150.               PLUG_IN_IMAGE_TYPES,
  151.               GIMP_PLUGIN,        
  152.               nargs, 0,
  153.               args, NULL);
  154.  
  155.   gimp_install_procedure ("plug_in_layer_rot90",
  156.               "Rotates the given layer 90 degrees clockwise.",
  157.               "Rotates the given layer 90 degrees clockwise.",
  158.               PLUG_IN_AUTHOR,
  159.               PLUG_IN_COPYRIGHT,
  160.               PLUG_IN_VERSION,
  161.               N_("<Image>/Layers/Rotate/90 degrees"),
  162.               PLUG_IN_IMAGE_TYPES,
  163.               GIMP_PLUGIN,
  164.               nmenuargs, 0,
  165.               menuargs, NULL);
  166.   gimp_install_procedure ("plug_in_layer_rot180",
  167.               "Rotates the given layer 180 degrees.",
  168.               "Rotates the given layer 180 degrees.",
  169.               PLUG_IN_AUTHOR,
  170.               PLUG_IN_COPYRIGHT,
  171.               PLUG_IN_VERSION,
  172.               N_("<Image>/Layers/Rotate/180 degrees"),
  173.               PLUG_IN_IMAGE_TYPES,
  174.               GIMP_PLUGIN,
  175.               nmenuargs, 0,
  176.               menuargs, NULL);
  177.   gimp_install_procedure ("plug_in_layer_rot270",
  178.               "Rotates the given layer 270 degrees clockwise.",
  179.               "Rotates the given layer 270 degrees clockwise.",
  180.               PLUG_IN_AUTHOR,
  181.               PLUG_IN_COPYRIGHT,
  182.               PLUG_IN_VERSION,
  183.               N_("<Image>/Layers/Rotate/270 degrees"),
  184.               PLUG_IN_IMAGE_TYPES,
  185.               GIMP_PLUGIN,
  186.               nmenuargs, 0,
  187.               menuargs, NULL);
  188.  
  189.   gimp_install_procedure ("plug_in_image_rot90",
  190.               "Rotates the given image 90 degrees clockwise.",
  191.               "Rotates the given image 90 degrees clockwise.",
  192.               PLUG_IN_AUTHOR,
  193.               PLUG_IN_COPYRIGHT,
  194.               PLUG_IN_VERSION,
  195.               N_("<Image>/Image/Transforms/Rotate/90 degrees"),
  196.               PLUG_IN_IMAGE_TYPES,
  197.               GIMP_PLUGIN,
  198.               nmenuargs, 0,
  199.               menuargs, NULL);
  200.   gimp_install_procedure ("plug_in_image_rot180",
  201.               "Rotates the given image 180 degrees.",
  202.               "Rotates the given image 180 degrees.",
  203.               PLUG_IN_AUTHOR,
  204.               PLUG_IN_COPYRIGHT,
  205.               PLUG_IN_VERSION,
  206.               N_("<Image>/Image/Transforms/Rotate/180 degrees"),
  207.               PLUG_IN_IMAGE_TYPES,
  208.               GIMP_PLUGIN,
  209.               nmenuargs, 0,
  210.               menuargs, NULL);
  211.   gimp_install_procedure ("plug_in_image_rot270",
  212.               "Rotates the given image 270 degrees clockwise.",
  213.               "Rotates the given image 270 degrees clockwise.",
  214.               PLUG_IN_AUTHOR,
  215.               PLUG_IN_COPYRIGHT,
  216.               PLUG_IN_VERSION,
  217.               N_("<Image>/Image/Transforms/Rotate/270 degrees"),
  218.               PLUG_IN_IMAGE_TYPES,
  219.               GIMP_PLUGIN,
  220.               nmenuargs, 0,
  221.               menuargs, NULL);
  222. }
  223.  
  224. static void 
  225. run (gchar      *name,
  226.      gint        nparams,
  227.      GimpParam  *param,
  228.      gint       *nreturn_vals,
  229.      GimpParam **return_vals)
  230. {
  231.   /* Get the runmode from the in-parameters */
  232.   GimpRunModeType run_mode = param[0].data.d_int32;    
  233.   
  234.   /* status variable, use it to check for errors in invocation usualy only 
  235.      during non-interactive calling */    
  236.   GimpPDBStatusType status = GIMP_PDB_SUCCESS;     
  237.   
  238.   /*always return at least the status to the caller. */
  239.   static GimpParam values[1];
  240.   
  241.   /* initialize the return of the status */     
  242.   values[0].type = GIMP_PDB_STATUS;
  243.   values[0].data.d_status = status;
  244.   *nreturn_vals = 1;
  245.   *return_vals = values;
  246.  
  247.   INIT_I18N (); 
  248.  
  249.   /* get image and drawable */
  250.   image_ID = param[1].data.d_int32;
  251.   active_drawable = gimp_drawable_get (param[2].data.d_drawable);
  252.   
  253.   /* Check the procedure name we were called with, to decide
  254.      what needs to be done. */
  255.   if (strcmp (name, "plug_in_rotate") == 0)
  256.     {
  257.       switch (run_mode)
  258.     {
  259.     case GIMP_RUN_INTERACTIVE:
  260.     case GIMP_RUN_NONINTERACTIVE:
  261.       /* check to see if invoked with the correct number of parameters */
  262.       if (nparams == 5)
  263.         {
  264.           rotvals.angle = (gint) param[3].data.d_int32;
  265.           rotvals.angle = rotvals.angle % 4;
  266.           rotvals.everything = (gint) param[4].data.d_int32;
  267.           /* Store variable states for next run */
  268.           gimp_set_data ("plug_in_rotate", &rotvals, sizeof (RotateValues));
  269.         }
  270.       else
  271.         status = GIMP_PDB_CALLING_ERROR;
  272.       break;
  273.     case GIMP_RUN_WITH_LAST_VALS:
  274.       /* Possibly retrieve data from a previous run */
  275.       gimp_get_data ("plug_in_rotate", &rotvals);
  276.       rotvals.angle = rotvals.angle % 4;
  277.       break;
  278.     default:
  279.       break;
  280.     }
  281.     }
  282.   else if (strcmp (name, "plug_in_layer_rot90") == 0)
  283.     {
  284.       rotvals.angle      = 1;
  285.       rotvals.everything = FALSE;
  286.     }
  287.   else if (strcmp (name, "plug_in_layer_rot180") == 0)
  288.     {
  289.       rotvals.angle      = 2;
  290.       rotvals.everything = FALSE;
  291.     }
  292.   else if (strcmp (name, "plug_in_layer_rot270") == 0)
  293.     {
  294.       rotvals.angle      = 3;
  295.       rotvals.everything = FALSE;
  296.     }
  297.   else if (strcmp (name, "plug_in_image_rot90") == 0)
  298.     {
  299.       rotvals.angle      = 1;
  300.       rotvals.everything = TRUE;
  301.     }
  302.   else if (strcmp (name, "plug_in_image_rot180") == 0)
  303.     {
  304.       rotvals.angle      = 2;
  305.       rotvals.everything = TRUE;
  306.     }
  307.   else if (strcmp (name, "plug_in_image_rot270") == 0)
  308.     {
  309.       rotvals.angle      = 3;
  310.       rotvals.everything = TRUE;
  311.     }
  312.   else 
  313.     status = GIMP_PDB_CALLING_ERROR;
  314.  
  315.   if (status == GIMP_PDB_SUCCESS)
  316.     {
  317.       /* Run the main function */
  318.       rotate ();
  319.       
  320.       /* If run mode is interactive, flush displays, else (script) don't 
  321.      do it, as the screen updates would make the scripts slow */
  322.       if (run_mode != GIMP_RUN_NONINTERACTIVE)
  323.     gimp_displays_flush ();
  324.     }
  325.  
  326.   values[0].data.d_status = status; 
  327. }
  328.  
  329. static void
  330. rotate_compute_offsets (gint *offsetx,
  331.             gint *offsety,
  332.             gint  image_width, 
  333.             gint  image_height,
  334.             gint  width, 
  335.             gint  height)
  336. {
  337.   gint buffer;
  338.  
  339.   if (rotvals.everything)  /* rotate around the image center */
  340.     {
  341.       switch ( rotvals.angle )
  342.     {
  343.     case 1:   /* 90░ */
  344.       buffer   = *offsetx;
  345.       *offsetx = image_height - *offsety - height;
  346.       *offsety = buffer;
  347.       break;
  348.     case 2:   /* 180░ */
  349.       *offsetx = image_width - *offsetx - width;
  350.       *offsety = image_height - *offsety - height;
  351.       break;
  352.     case 3:   /* 270░ */
  353.       buffer   = *offsetx;
  354.       *offsetx = *offsety;
  355.       *offsety = image_width - buffer - width;
  356.     }
  357.     }
  358.   else  /* rotate around the drawable center */
  359.     {
  360.       if (rotvals.angle != 2)
  361.     {
  362.       *offsetx = *offsetx + (width-height)/2 ;
  363.       *offsety = *offsety + (height-width)/2 ;
  364.     }
  365.     }
  366.   return;
  367. }
  368.  
  369.  
  370. static void
  371. rotate_drawable (GimpDrawable *drawable)
  372. {
  373.   GimpPixelRgn  srcPR, destPR;
  374.   gint          width, height;
  375.   gint          longside;
  376.   gint          bytes;
  377.   gint          row, col;
  378.   gint          offsetx, offsety;
  379.   gboolean      was_preserve_transparency = FALSE;
  380.   guchar       *buffer;
  381.   guchar       *src_row, *dest_row;
  382.  
  383.   /* initialize */
  384.  
  385.   row = 0;
  386.  
  387.   /* Get the size of the input drawable. */
  388.   width = drawable->width;
  389.   height = drawable->height;
  390.   bytes = drawable->bpp;
  391.  
  392.   if (gimp_layer_get_preserve_transparency (drawable->id))
  393.     {
  394.     was_preserve_transparency = TRUE;
  395.     gimp_layer_set_preserve_transparency (drawable->id, FALSE);
  396.     }
  397.  
  398.   if (rotvals.angle == 2)  /* we're rotating by 180░ */
  399.     {
  400.       gimp_tile_cache_ntiles (2 * (width / gimp_tile_width() + 1));
  401.  
  402.       gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, 
  403.                FALSE, FALSE);
  404.       gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height,
  405.                TRUE, TRUE);
  406.       
  407.       src_row  = (guchar *) g_malloc (width * bytes);
  408.       dest_row = (guchar *) g_malloc (width * bytes);
  409.       
  410.       for (row = 0; row < height; row++)
  411.     {
  412.       gimp_pixel_rgn_get_row (&srcPR, src_row, 0, row, width); 
  413.       for (col = 0; col < width; col++) 
  414.         { 
  415.           memcpy (dest_row + col * bytes, 
  416.               src_row + (width - 1 - col) * bytes,
  417.               bytes);
  418.         }         
  419.       gimp_pixel_rgn_set_row (&destPR, dest_row, 0, (height - row - 1), 
  420.                   width);
  421.       
  422.       if ((row % 5) == 0)
  423.         gimp_progress_update ((double) row / (double) height);
  424.     }
  425.  
  426.       g_free (src_row);
  427.       g_free (dest_row);
  428.  
  429.       gimp_drawable_flush (drawable); 
  430.       gimp_drawable_merge_shadow (drawable->id, TRUE); 
  431.       gimp_drawable_update (drawable->id, 0, 0, width, height); 
  432.  
  433.     }
  434.   else                     /* we're rotating by 90░ or 270░ */
  435.     {  
  436.       (width > height) ? (longside = width) : (longside = height);
  437.  
  438.       gimp_layer_resize (drawable->id, longside, longside, 0, 0);
  439.       drawable = gimp_drawable_get (drawable->id);
  440.       gimp_drawable_flush (drawable);
  441.       
  442.       gimp_tile_cache_ntiles ( (longside / gimp_tile_width () + 1) + 
  443.                    (longside / gimp_tile_height () + 1) );
  444.  
  445.       gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, longside, longside, 
  446.                FALSE, FALSE);
  447.       gimp_pixel_rgn_init (&destPR, drawable, 0, 0, longside, longside,
  448.                TRUE, TRUE);
  449.       
  450.       buffer = g_malloc (longside * bytes);
  451.       
  452.       if (rotvals.angle == 1)     /* we're rotating by 90░ */
  453.     {
  454.       for (row = 0; row < height; row++)
  455.         {
  456.           gimp_pixel_rgn_get_row (&srcPR, buffer, 0, row, width); 
  457.           gimp_pixel_rgn_set_col (&destPR, buffer, (height - row - 1), 0,
  458.                       width);
  459.  
  460.           if ((row % 5) == 0)
  461.         gimp_progress_update ((double) row / (double) height);
  462.         }
  463.     }
  464.       else                        /* we're rotating by 270░ */
  465.     {
  466.       for (col = 0; col < width; col++)
  467.         {
  468.           gimp_pixel_rgn_get_col (&srcPR, buffer, col, 0, height); 
  469.           gimp_pixel_rgn_set_row (&destPR, buffer, 0, (width - col - 1), 
  470.                       height);
  471.  
  472.           if ((col % 5) == 0)
  473.         gimp_progress_update ((double) col / (double) width);
  474.         }
  475.     }
  476.  
  477.       g_free (buffer);
  478.  
  479.       gimp_progress_update ( 1.0 );
  480.  
  481.       gimp_drawable_flush (drawable); 
  482.       gimp_drawable_merge_shadow (drawable->id, TRUE);
  483.       gimp_drawable_update (drawable->id, 0, 0, height, width); 
  484.  
  485.       gimp_layer_resize (drawable->id, height, width, 0, 0);
  486.       drawable = gimp_drawable_get (drawable->id);
  487.       gimp_drawable_flush (drawable);
  488.       gimp_drawable_update (drawable->id, 0, 0, height, width);
  489.     }
  490.  
  491.   gimp_drawable_offsets (drawable->id, &offsetx, &offsety);
  492.   rotate_compute_offsets (&offsetx, &offsety, 
  493.               gimp_image_width (image_ID),
  494.               gimp_image_height (image_ID), 
  495.               width, height); 
  496.   gimp_layer_set_offsets (drawable->id, offsetx, offsety);
  497.  
  498.   if (was_preserve_transparency)
  499.     gimp_layer_set_preserve_transparency ( drawable->id, TRUE );
  500.  
  501.   return;
  502. }
  503.  
  504.  
  505. /* The main rotate function */
  506. static void 
  507. rotate (void)
  508. {
  509.   GimpDrawable *drawable;
  510.   gint32       *layers;
  511.   gint          i;
  512.   gint          nlayers;
  513.   gint32        guide_ID;
  514.   GuideInfo    *guide;
  515.   GList        *guides = NULL;
  516.   GList        *list;
  517.  
  518.   if (rotvals.angle == 0) return;  
  519.  
  520.   /* if there's a selection and we try to rotate the whole image */
  521.   /* create an error message and exit                            */     
  522.   if ( rotvals.everything )
  523.     {
  524.       if ( !gimp_selection_is_empty (image_ID) ) 
  525.     {
  526.       gimp_message (_("You can not rotate the whole image if there's a selection."));
  527.       gimp_drawable_detach (active_drawable);
  528.       return;
  529.     }
  530.       if ( gimp_layer_is_floating_selection (active_drawable->id) ) 
  531.     {
  532.       gimp_message (_("You can not rotate the whole image if there's a floating selection."));
  533.       gimp_drawable_detach (active_drawable);
  534.       return;
  535.     }
  536.     }
  537.   else
  538.     /* if we are trying to rotate a chennel or a mask, create an error message and exit */
  539.     {
  540.       if ( !gimp_drawable_is_layer (active_drawable->id) )
  541.     {
  542.       gimp_message (_("Sorry, channels and masks can not be rotated."));
  543.       gimp_drawable_detach (active_drawable);
  544.       return;
  545.     }
  546.     } 
  547.   
  548.   gimp_progress_init (_("Rotating..."));
  549.  
  550.   gimp_undo_push_group_start (image_ID);
  551.  
  552.   if (rotvals.everything)  /* rotate the whole image */ 
  553.     {
  554.       gint32 width = gimp_image_width (image_ID);
  555.       gint32 height = gimp_image_height (image_ID);
  556.  
  557.       gimp_drawable_detach (active_drawable);
  558.       layers = gimp_image_get_layers (image_ID, &nlayers);
  559.       for ( i=0; i<nlayers; i++ )
  560.     {
  561.       drawable = gimp_drawable_get (layers[i]);
  562.       rotate_drawable (drawable);
  563.       gimp_drawable_detach (drawable);
  564.     }
  565.       g_free(layers);      
  566.  
  567.       /* build a list of all guides and remove them */
  568.       guide_ID = 0;
  569.       while ((guide_ID = gimp_image_find_next_guide (image_ID, guide_ID)) != 0)
  570.     {
  571.       guide = g_new (GuideInfo, 1);
  572.       guide->ID = guide_ID;
  573.       guide->orientation = gimp_image_get_guide_orientation (image_ID, guide_ID);
  574.       guide->position = gimp_image_get_guide_position (image_ID, guide_ID);
  575.       guides = g_list_prepend (guides, guide);
  576.     }
  577.       for (list = guides; list; list = list->next)  
  578.     {
  579.       guide = (GuideInfo *)list->data;
  580.       gimp_image_delete_guide (image_ID, guide->ID);
  581.     }
  582.  
  583.       /* if rotation is not 180 degrees, resize the image */
  584.       /*    Do it now after the guides are removed, since */ 
  585.       /*    gimp_image_resize() moves the guides.         */ 
  586.       if (rotvals.angle != 2)
  587.     gimp_image_resize (image_ID, height, width, 0, 0);
  588.  
  589.       /* add the guides back to the image */
  590.       if (guides)
  591.     {
  592.       switch (rotvals.angle)
  593.         {
  594.         case 1:
  595.           for (list = guides; list; list = list->next)  
  596.         {
  597.           guide = (GuideInfo *)list->data;
  598.           if (guide->orientation == GIMP_HORIZONTAL)
  599.             gimp_image_add_vguide (image_ID, height - guide->position);
  600.           else
  601.             gimp_image_add_hguide (image_ID, guide->position);
  602.           g_free (guide);
  603.         }     
  604.           break;
  605.         case 2:
  606.           for (list = guides; list; list = list->next)  
  607.         {
  608.           guide = (GuideInfo *)list->data;
  609.           if (guide->orientation == GIMP_HORIZONTAL)
  610.             gimp_image_add_hguide (image_ID, height - guide->position);
  611.           else
  612.             gimp_image_add_vguide (image_ID, width - guide->position);
  613.           g_free (guide);
  614.         }     
  615.           break;
  616.         case 3:
  617.           for (list = guides; list; list = list->next)  
  618.         {
  619.           guide = (GuideInfo *)list->data;
  620.           if (guide->orientation == GIMP_HORIZONTAL)
  621.             gimp_image_add_vguide (image_ID, guide->position);
  622.           else
  623.             gimp_image_add_hguide (image_ID, width - guide->position);
  624.           g_free (guide);
  625.         }     
  626.           break;
  627.         default: 
  628.           break;
  629.         }
  630.       g_list_free (guides);
  631.     }
  632.     }
  633.   else  /* rotate only the active layer */
  634.     {
  635.  
  636.       /* check for active selection and float it */
  637.       if ( !gimp_selection_is_empty (image_ID) &&
  638.        !gimp_layer_is_floating_selection (active_drawable->id) )
  639.     active_drawable = 
  640.       gimp_drawable_get (gimp_selection_float (image_ID, 
  641.                            active_drawable->id,  
  642.                            0, 0));
  643.                 
  644.       rotate_drawable (active_drawable);
  645.       gimp_drawable_detach (active_drawable);
  646.     }
  647.  
  648.   gimp_undo_push_group_end (image_ID);
  649.  
  650.   return;
  651. }
  652.