home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / clients / xmag / Scale.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-26  |  26.7 KB  |  1,022 lines
  1. /*
  2.  * $XConsortium: Scale.c,v 1.15 91/08/26 11:00:15 gildea Exp $
  3.  *
  4.  * Copyright 1989 Massachusetts Institute of Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of M.I.T. not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  M.I.T. makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  *
  23.  * Author:  Davor Matic, MIT X Consortium
  24.  */
  25.  
  26.  
  27. #include <stdio.h>
  28. #include <ctype.h>
  29. #include <string.h> 
  30. #include <math.h>
  31. #include <X11/IntrinsicP.h>
  32. #include <X11/StringDefs.h>
  33. #include <X11/Xaw/XawInit.h>
  34. #include "ScaleP.h"
  35. #include <X11/Xosdefs.h>
  36.  
  37. #define myrint(x) floor(x + 0.5)
  38.  
  39. #ifndef X_NOT_STDC_ENV
  40. #include <stdlib.h>
  41. #endif
  42.  
  43. #if defined(ISC) && defined(SYSV) && defined(SYSV386) && __STDC__
  44. extern double atof(char *);
  45. #endif
  46.  
  47. #define streq(a,b) (strcmp( (a), (b) ) == 0)
  48. #define min(x, y) (x > y ? y : x)
  49. #define max(x, y) (x < y ? y : x)
  50.  
  51. #define DefaultBufferSize 1024
  52. #define DefaultScaleFactor NULL
  53.  
  54. #define Offset(field) XtOffsetOf(ScaleRec, scale.field)
  55.  
  56. static XtResource resources[] = {
  57. {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  58.      Offset(foreground_pixel), XtRString, (XtPointer) XtDefaultForeground},
  59. {XtNgravity, XtCGravity, XtRGravity, sizeof(XtGravity),
  60.      Offset(gravity), XtRImmediate, (XtPointer) "ForgetGravity"},
  61. {XtNinternalWidth, XtCWidth, XtRDimension,  sizeof(Dimension),
  62.      Offset(internal_width), XtRImmediate, (XtPointer) 2},
  63. {XtNinternalHeight, XtCHeight, XtRDimension, sizeof(Dimension),
  64.      Offset(internal_height), XtRImmediate, (XtPointer) 2},
  65. {XtNresize, XtCResize, XtRBoolean, sizeof(Boolean),
  66.      Offset(resize), XtRImmediate, (XtPointer) True},
  67. {XtNautoscale, XtCAutoscale, XtRBoolean, sizeof(Boolean),
  68.      Offset(autoscale), XtRImmediate, (XtPointer) True},
  69. {XtNproportional, XtCProportional, XtRBoolean, sizeof(Boolean),
  70.      Offset(proportional), XtRImmediate, (XtPointer) True},
  71. {XtNscaleX, XtCScaleFactor, XtRString, sizeof(String),
  72.      Offset(scale_x_str), XtRImmediate, (XtPointer) DefaultScaleFactor},
  73. {XtNscaleY, XtCScaleFactor, XtRString, sizeof(String),
  74.      Offset(scale_y_str), XtRImmediate, (XtPointer) DefaultScaleFactor},
  75. {XtNaspectRatio, XtCAspectRatio, XtRString, sizeof(String),
  76.      Offset(aspect_ratio_str), XtRImmediate, (XtPointer) "1.0"},
  77. {XtNprecision, XtCPrecision, XtRString, sizeof(String),
  78.      Offset(precision_str), XtRImmediate, (XtPointer) "0.001"},
  79. {XtNimage, XtCImage, XtRImage, sizeof(XImage*),
  80.      Offset(image), XtRImmediate, (XtPointer) NULL},
  81. {XtNpasteBuffer, XtCPasteBuffer, XtRBoolean, sizeof(Boolean),
  82.      Offset(paste_buffer), XtRImmediate, (XtPointer) False},
  83. {XtNbufferSize, XtCBufferSize, XtRCardinal, sizeof(Cardinal),
  84.      Offset(buffer_size), XtRImmediate, (XtPointer) DefaultBufferSize},
  85. {XtNuserData, XtCuserData, XtRuserData, sizeof(XtPointer),
  86.      Offset(userData), XtRImmediate, (XtPointer) NULL},
  87. { XtNvisual, XtCvisual, XtRVisual, sizeof(Visual*),
  88.      Offset(visual), XtRImmediate, CopyFromParent}
  89. };
  90.  
  91. #undef Offset
  92.  
  93. static void ClassInitialize();
  94. static void Initialize();
  95. static void Realize();
  96. static void Redisplay();
  97. static void Resize();
  98. static void Destroy();
  99. static Boolean SetValues();
  100.  
  101. void SWUnscale();
  102. void SWAutoscale();
  103. void SWInitialSize();
  104. void RequestSelection();
  105. void GrabSelection();
  106.  
  107. static XtActionsRec actions[] =
  108. {
  109. {"unscale", SWUnscale},
  110. {"autoscale", SWAutoscale},
  111. {"initial-size", SWInitialSize},
  112. {"paste", RequestSelection},
  113. {"cut", GrabSelection}
  114. };
  115.  
  116. static char translations[] =
  117. "\
  118.  <Key>u:           unscale()\n\
  119.  <Key>a:           autoscale()\n\
  120.  <Key>i:           initial-size()\n\
  121. ";
  122.  
  123. ScaleClassRec scaleClassRec = {
  124. {   /* core fields */
  125.     /* superclass        */    (WidgetClass) &simpleClassRec,
  126.     /* class_name        */    "Scale",
  127.     /* widget_size        */    sizeof(ScaleRec),
  128.     /* class_initialize        */    ClassInitialize,
  129.     /* class_part_initialize    */    NULL,
  130.     /* class_inited        */    FALSE,
  131.     /* initialize        */    Initialize,
  132.     /* initialize_hook        */    NULL,
  133.     /* realize            */    Realize,
  134.     /* actions            */    actions,
  135.     /* num_actions        */    XtNumber(actions),
  136.     /* resources        */    resources,
  137.     /* num_resources        */    XtNumber(resources),
  138.     /* xrm_class        */    NULLQUARK,
  139.     /* compress_motion        */    TRUE,
  140.     /* compress_exposure    */      XtExposeCompressMaximal|
  141.                                         XtExposeGraphicsExposeMerged,
  142.     /* compress_enterleave    */    TRUE,
  143.     /* visible_interest        */    TRUE,
  144.     /* destroy            */    Destroy,
  145.     /* resize            */    Resize,
  146.     /* expose            */    Redisplay,
  147.     /* set_values        */    SetValues,
  148.     /* set_values_hook        */    NULL,
  149.     /* set_values_almost    */    XtInheritSetValuesAlmost,
  150.     /* get_values_hook        */    NULL,
  151.     /* accept_focus        */    NULL,
  152.     /* version            */    XtVersion,
  153.     /* callback_private        */    NULL,
  154.     /* tm_table            */      translations,
  155.     /* query_geometry        */    XtInheritQueryGeometry,
  156.     /* display_accelerator    */    XtInheritDisplayAccelerator,
  157.     /* extension        */    NULL
  158.   },
  159.   { 
  160.     /* change_sensitive        */    XtInheritChangeSensitive,
  161.   }
  162. };
  163.  
  164. WidgetClass scaleWidgetClass = (WidgetClass) &scaleClassRec;
  165.     
  166.  
  167.  
  168. /*
  169.  * Private Procedures
  170.  */
  171.  
  172.  
  173. static void ClassInitialize()
  174. {
  175. } 
  176.  
  177.  
  178.  
  179. void GetGC(sw)
  180.     ScaleWidget sw;
  181. {
  182.     XGCValues values;
  183.     
  184.     values.foreground = sw->scale.foreground_pixel;
  185.     values.background = sw->core.background_pixel;
  186.     values.function = GXcopy;
  187.     
  188.     sw->scale.gc = XtGetGC((Widget) sw,
  189.                GCForeground | 
  190.                GCBackground | 
  191.                GCFunction,
  192.                &values);
  193. }
  194.  
  195.  
  196.  
  197. void Proportional();
  198.  
  199. void GetInitialScaleValues(sw)
  200.     ScaleWidget sw;
  201. {
  202.     if (sw->scale.proportional) {
  203.     sw->scale.scale_x = sw->scale.scale_y =
  204.         ((sw->scale.aspect_ratio > 1.0) ?
  205.          sw->scale.aspect_ratio : 1.0 / sw->scale.aspect_ratio) *
  206.          (sw->scale.precision > 1.0 ?
  207.           sw->scale.precision : 1.0);
  208.     Proportional(sw); /* need to cut them down to proper values */
  209.     }
  210.     else
  211.     sw->scale.scale_x = sw->scale.scale_y = 1.0;
  212. }
  213.  
  214.  
  215.  
  216. void GetRectangleBuffer(sw, buffer_size)
  217.     ScaleWidget sw;
  218.     Cardinal buffer_size;
  219.     /*
  220.      * This procedure will realloc a new rectangles buffer.
  221.      * If the new buffer size is less than nrectangles, some
  222.      * information will be lost.
  223.      */
  224. {
  225.     if (buffer_size == 0) {
  226.     buffer_size = DefaultBufferSize;
  227.     XtWarning("buffer size has to be a positive number greater than zero");
  228.     }
  229.     sw->scale.rectangles = (XRectangle *)
  230.     XtRealloc((char *) sw->scale.rectangles, 
  231.           buffer_size * sizeof(XRectangle));
  232.     sw->scale.buffer_size = buffer_size;
  233. }
  234.  
  235.  
  236.  
  237. /* ARGSUSED */
  238. static void Initialize(request, new)
  239.     Widget request, new;
  240. {
  241.     ScaleWidget new_sw = (ScaleWidget) new;
  242.     
  243.     new_sw->scale.table.x = (Position *) NULL;
  244.     new_sw->scale.table.y = (Position *) NULL;
  245.     new_sw->scale.table.width = (Dimension *) NULL;
  246.     new_sw->scale.table.height = (Dimension *) NULL;
  247.     
  248.     new_sw->scale.nrectangles = 0;
  249.     new_sw->scale.rectangles = (XRectangle *) NULL;
  250.     
  251.     GetRectangleBuffer(new_sw, new_sw->scale.buffer_size);
  252.     
  253.     GetGC(new_sw);
  254.     
  255.     if (new_sw->scale.image != NULL) {
  256.     if (new_sw->core.width == 0)
  257.         new_sw->core.width = 
  258.         new_sw->scale.image->width + 2 * new_sw->scale.internal_width;
  259.     if (new_sw->core.height == 0)
  260.         new_sw->core.height = 
  261.         new_sw->scale.image->height + 2 *new_sw->scale.internal_height;
  262.     }
  263.     else {
  264.     if (new_sw->core.width == 0)
  265.         new_sw->core.width = 1 + 2 * new_sw->scale.internal_width;
  266.     if (new_sw->core.height == 0)
  267.         new_sw->core.height = 1 + 2 * new_sw->scale.internal_height;
  268.     new_sw->scale.image = XCreateImage(XtDisplay(new),
  269.                        DefaultVisual(XtDisplay(new), 
  270.                             DefaultScreen(XtDisplay(new))),
  271.                        1, XYBitmap, 0, 
  272.                        XtCalloc(1, sizeof(char)),
  273.                        1, 1, 8, 0);
  274.     }
  275.  
  276.     if ((new_sw->scale.aspect_ratio = 
  277.      atof(new_sw->scale.aspect_ratio_str)) < 0.0) {
  278.     new_sw->scale.aspect_ratio = 1.0;
  279.     XtWarning("AspectRatio has to be a positive number. (forced to 1.0)");
  280.     }
  281.  
  282.     if ((new_sw->scale.precision =
  283.          atof(new_sw->scale.precision_str)) < 0.0) {
  284.     new_sw->scale.precision = 0.001;
  285.     XtWarning("Precision has to be a positive number. (forced to 0.001)");
  286.     }
  287.     
  288.     if (new_sw->scale.scale_x_str == DefaultScaleFactor
  289.     || 
  290.     new_sw->scale.scale_y_str == DefaultScaleFactor)
  291.     GetInitialScaleValues(new_sw);
  292.     else {
  293.     if ((new_sw->scale.scale_x = 
  294.          atof(new_sw->scale.scale_x_str)) < 0.0) {
  295.         new_sw->scale.scale_x = 1.0;
  296.         XtWarning("ScaleValue has to be a positive number. (forced to 1.0)");
  297.     }
  298.     if ((new_sw->scale.scale_y = 
  299.          atof(new_sw->scale.scale_y_str)) < 0.0) {
  300.         new_sw->scale.scale_y = 1.0;
  301.         XtWarning("ScaleValue has to be a positive number. (forced to 1.0)");
  302.     }
  303.     }
  304. }
  305.  
  306.  
  307.  
  308. void BuildTable(sw)
  309.     ScaleWidget sw;
  310.     /* 
  311.      * This procedure builds scaling table for image in the scale struct
  312.      * Requires image, scale_x and scale_y to be set properly
  313.      */
  314. {
  315.     Position x, y;
  316.     
  317.     XtFree((char *) sw->scale.table.x);
  318.     XtFree((char *) sw->scale.table.y);
  319.     XtFree((char *) sw->scale.table.width);
  320.     XtFree((char *) sw->scale.table.height);
  321.     sw->scale.table.x = 
  322.     (Position *) XtMalloc(sizeof(Position) * sw->scale.image->width);
  323.     sw->scale.table.y = 
  324.     (Position *) XtMalloc(sizeof(Position) * sw->scale.image->height);
  325.     sw->scale.table.width = 
  326.     (Dimension *) XtMalloc(sizeof(Dimension) * sw->scale.image->width);
  327.     sw->scale.table.height = 
  328.     (Dimension *) XtMalloc(sizeof(Dimension) * sw->scale.image->height);
  329.     
  330.     /* Build the scaling table */    
  331.     for (x = 0; x < sw->scale.image->width; x++) {
  332.     sw->scale.table.x[(int) x] = (Position) myrint(sw->scale.scale_x * x);
  333.     sw->scale.table.width[(int) x] = (Dimension)
  334.         myrint(sw->scale.scale_x *(x + 1)) - myrint(sw->scale.scale_x * x);
  335.     }
  336.     for (y = 0; y < sw->scale.image->height; y++) {
  337.     sw->scale.table.y[(int) y] = (Position) myrint(sw->scale.scale_y * y);
  338.     sw->scale.table.height[(int) y] = (Dimension)
  339.         myrint(sw->scale.scale_y *(y + 1)) - myrint(sw->scale.scale_y * y);
  340.     }
  341. }
  342.  
  343.  
  344.  
  345. void FlushRectangles(sw, drawable, gc)
  346.     ScaleWidget sw;
  347.     Drawable drawable;
  348.     GC gc;
  349. {
  350.     XFillRectangles(XtDisplay(sw), drawable, gc, 
  351.             sw->scale.rectangles, sw->scale.nrectangles);
  352.     
  353.     sw->scale.nrectangles = 0;
  354. }
  355.  
  356.  
  357.  
  358. void FillRectangle(sw, drawable, gc, x, y, width, height)
  359.     ScaleWidget sw;
  360.     Drawable drawable;
  361.     GC gc;
  362.     Position x, y;
  363.     Dimension width, height;
  364. {
  365.     
  366.     if (sw->scale.nrectangles == sw->scale.buffer_size)
  367.     FlushRectangles(sw, drawable, gc);
  368.  
  369.     sw->scale.rectangles[(int) sw->scale.nrectangles].x = x;
  370.     sw->scale.rectangles[(int) sw->scale.nrectangles].y = y;
  371.     sw->scale.rectangles[(int) sw->scale.nrectangles].width = width;
  372.     sw->scale.rectangles[(int) sw->scale.nrectangles].height = height;
  373.  
  374.     ++sw->scale.nrectangles;
  375. }
  376.  
  377.  
  378.  
  379. void ScaleImage(sw, drawable, img_x, img_y, dst_x, dst_y, img_width,img_height)
  380.     ScaleWidget sw;
  381.     Drawable drawable;
  382.     Position img_x, img_y;
  383.     Position dst_x, dst_y;
  384.     Dimension img_width, img_height;
  385.     /* 
  386.      * This procedure scales image into the specified drawable
  387.      * It assumes scaling table was already built
  388.      */
  389. {
  390.     GC gc;
  391.     XGCValues gcv;
  392.     Position x, y;
  393.     Pixel pixel;
  394.     
  395.     /* Clip the img coordinates */
  396.     img_x = min(max(img_x, 0), (Position) sw->scale.image->width - 1);
  397.     img_y = min(max(img_y, 0), (Position) sw->scale.image->height - 1);
  398.     img_width = 
  399.       min(img_width, (Dimension)(sw->scale.image->width - (Dimension)img_x));
  400.     img_height = 
  401.       min(img_height, (Dimension)(sw->scale.image->height - (Dimension)img_y));
  402.  
  403.     if (sw->scale.scale_x == 1.0 && sw->scale.scale_y == 1.0) 
  404.     XPutImage(XtDisplay(sw), drawable, sw->scale.gc, sw->scale.image, 
  405.           img_x, img_y, dst_x, dst_y, 
  406.           img_width, img_height);
  407.     else {
  408.     dst_x = dst_x - sw->scale.table.x[(int) img_x];
  409.     dst_y = dst_y - sw->scale.table.y[(int) img_y];
  410.  
  411.     gc = XCreateGC(XtDisplay(sw), drawable, 0, NULL);
  412.  
  413.     gcv.function = GXcopy;
  414.     XChangeGC(XtDisplay(sw), gc, GCFunction, &gcv);
  415.  
  416.     /* make sure gc knows the right background */
  417.     gcv.background = sw->core.background_pixel;
  418.     XChangeGC(XtDisplay(sw), gc, GCBackground, &gcv);    
  419.  
  420.     /* Set the background of drawable.  If the most frequent color
  421.        is the background color it can speed up scaling process. */
  422.     gcv.foreground = gcv.background;
  423.     XChangeGC(XtDisplay(sw), gc, GCForeground, &gcv);
  424.     XFillRectangle(XtDisplay(sw), drawable, gc, 
  425.                sw->scale.table.x[(int) img_x] + dst_x, 
  426.                sw->scale.table.y[(int) img_y] + dst_y, 
  427.                sw->scale.table.x[(int) img_x + img_width - 1] - 
  428.                sw->scale.table.x[(int) img_x], 
  429.                sw->scale.table.y[(int) img_y + img_height - 1] - 
  430.                sw->scale.table.y[(int) img_y]);
  431.     
  432.     if (sw->scale.image->format == XYBitmap) {
  433.         for (x = img_x; x < img_x + (Position)img_width; x++)
  434.         for (y = img_y; y < img_y + (Position)img_height; y++) {
  435.             pixel = XGetPixel(sw->scale.image, x, y);
  436.             if (pixel) /* Do not draw background */
  437.             FillRectangle(sw, drawable, sw->scale.gc, 
  438.                       sw->scale.table.x[(int) x] + dst_x, 
  439.                       sw->scale.table.y[(int) y] + dst_y, 
  440.                       sw->scale.table.width[(int) x], 
  441.                       sw->scale.table.height[(int) y]);
  442.         }
  443.         FlushRectangles(sw, drawable, sw->scale.gc);
  444.     }
  445.     else {
  446.         for (x = img_x; x < img_x + (Position)img_width; x++)
  447.         for (y = img_y; y < img_y + (Position)img_height; y++) {
  448.             pixel = XGetPixel(sw->scale.image, x, y);
  449.             if (pixel != gcv.background) { /* Do not draw background */
  450.             if (gcv.foreground != pixel) { /* Change fg to pixel */
  451.                 gcv.foreground = pixel;
  452.                 XChangeGC(XtDisplay(sw), gc, GCForeground, &gcv);
  453.             }
  454.             XFillRectangle(XtDisplay(sw), drawable, gc,
  455.                        sw->scale.table.x[(int) x] + dst_x, 
  456.                        sw->scale.table.y[(int) y] + dst_y, 
  457.                        sw->scale.table.width[(int) x], 
  458.                        sw->scale.table.height[(int) y]);
  459.             }
  460.         }
  461.     }
  462.     XFreeGC(XtDisplay(sw), gc);
  463.     }
  464. }
  465.  
  466.  
  467.  
  468. int FindPixel(sw, x, y, img_x, img_y, img_pixel)
  469.     ScaleWidget sw;
  470.     Position x, y; /* (x,y) == (0,0) where image starts in sw window*/
  471.     Position *img_x, *img_y;
  472.     Pixel    *img_pixel;
  473. {
  474.     if (*img_x < 0 || *img_x >= sw->scale.image->width 
  475.     ||
  476.     *img_y < 0 || *img_y >= sw->scale.image->height)
  477.     return (-1);
  478.     
  479.     if (sw->scale.table.x[(int) *img_x] >= x) {
  480.     --*img_x;
  481.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  482.     }
  483.     if (sw->scale.table.x[(int) *img_x] + 
  484.     (Position)sw->scale.table.width[(int) *img_x] < x) {
  485.     ++*img_x;
  486.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  487.     }
  488.     if (sw->scale.table.y[(int) *img_y] >= y) {
  489.     --*img_y;
  490.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  491.     }
  492.     if (sw->scale.table.y[(int) *img_y] + 
  493.     (Position)sw->scale.table.height[(int) *img_y] < y) {
  494.     ++*img_y;
  495.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  496.     }
  497.     
  498.     *img_pixel = XGetPixel(sw->scale.image, *img_x, *img_y);
  499.     
  500.     return (0);
  501. }
  502.  
  503.  
  504.  
  505. int SWGetImagePixel(w, x, y, img_x, img_y, img_pixel)
  506.     Widget w;
  507.     Position x, y;
  508.     Position *img_x, *img_y;
  509.     Pixel    *img_pixel;
  510. {
  511.     ScaleWidget sw = (ScaleWidget) w;
  512.     
  513.     x -= sw->scale.x;
  514.     y -= sw->scale.y;
  515.     
  516.     *img_x = (Position) floor(x / sw->scale.scale_x);
  517.     *img_y = (Position) floor(y / sw->scale.scale_y);
  518.     
  519.     return FindPixel(sw, x, y, img_x, img_y, img_pixel);
  520. }
  521.  
  522.  
  523.  
  524. /* ARGSUSED */
  525. static void Redisplay(w, event, region)
  526.     Widget w;
  527.     XEvent *event;
  528.     Region region;
  529. {
  530.     ScaleWidget sw = (ScaleWidget) w;
  531.     Position  x, y, img_x, img_y;
  532.     Dimension width, height;
  533.  
  534.     if (event->type == Expose) {
  535.  
  536.     if (event->xexpose.x < sw->scale.x) {
  537.         x = 0;
  538.         width = event->xexpose.width -
  539.         (sw->scale.x - event->xexpose.x);
  540.     }
  541.     else {
  542.         x = event->xexpose.x - sw->scale.x;
  543.         width = event->xexpose.width;
  544.     }
  545.     
  546.     if (event->xexpose.y < sw->scale.y) {
  547.         y = 0;
  548.         height = event->xexpose.height -
  549.         (sw->scale.y - event->xexpose.y);
  550.     }
  551.     else {
  552.         y = event->xexpose.y - sw->scale.y;
  553.         height = event->xexpose.height;
  554.     }
  555.     
  556.     img_x = min(max((Position) floor((float) x 
  557.                      / (float) sw->scale.scale_x), 0),
  558.             (Position) sw->scale.image->width - 1);
  559.  
  560.     img_y = min(max((Position) floor((float) y
  561.                      / (float) sw->scale.scale_y), 0),
  562.             (Position) sw->scale.image->height - 1);
  563.     
  564.     if (sw->core.visible) {  
  565.         ScaleImage(sw, XtWindow(w),
  566.                img_x, img_y,
  567.                sw->scale.x + sw->scale.table.x[(int) img_x],
  568.                sw->scale.y + sw->scale.table.y[(int) img_y],
  569.                (Dimension) ceil((float) width
  570.                     / sw->scale.scale_x) + 1, 
  571.                (Dimension) ceil((float) height
  572.                     / sw->scale.scale_y) + 1);
  573.     }
  574.     }
  575. }
  576.  
  577.  
  578.  
  579. void TryResize(sw)
  580.     ScaleWidget sw;
  581. {
  582.     Dimension width, height;
  583.     XtGeometryResult result;
  584.  
  585.     width = (Dimension) 
  586.     floor(sw->scale.image->width * sw->scale.scale_x)
  587.         + 2 * sw->scale.internal_width;
  588.     height = (Dimension) 
  589.     floor(sw->scale.image->height * sw->scale.scale_y)
  590.         + 2 * sw->scale.internal_height;
  591.     
  592.     while ((result =   
  593. /* SUPPRESS 530 */XtMakeResizeRequest((Widget)sw,width,height,&width,&height))
  594.        == XtGeometryAlmost);  
  595.     
  596.     if (result != XtGeometryNo) {
  597.     sw->core.width = width;
  598.     sw->core.height = height;
  599.     }
  600. }
  601.  
  602.  
  603.  
  604. void Precision(sw)
  605.     ScaleWidget sw;
  606. {
  607.     if (sw->scale.scale_x != 1.0)
  608.     sw->scale.scale_x = floor(sw->scale.scale_x / sw->scale.precision)
  609.                     * sw->scale.precision;
  610.  
  611.     if (sw->scale.scale_y != 1.0)
  612.     sw->scale.scale_y = floor(sw->scale.scale_y / sw->scale.precision)
  613.                 * sw->scale.precision;
  614. }
  615.  
  616.  
  617.  
  618. void Proportional(sw)
  619.     ScaleWidget sw;
  620. {
  621.     float scale_x, scale_y;
  622.  
  623.     scale_x = sw->scale.scale_y / sw->scale.aspect_ratio;
  624.     scale_y = sw->scale.scale_x * sw->scale.aspect_ratio;
  625.     
  626.     if (scale_x <= sw->scale.scale_x && scale_y <= sw->scale.scale_y) {
  627.     if (scale_x > scale_y)
  628.         sw->scale.scale_x = scale_x;
  629.     else
  630.         sw->scale.scale_y = scale_y;
  631.     }
  632.     else if (scale_x <= sw->scale.scale_x)
  633.     sw->scale.scale_x = scale_x;
  634.     else if (scale_y <= sw->scale.scale_y)
  635.     sw->scale.scale_y = scale_y;
  636.     else {
  637.     float x_ratio, y_ratio;
  638.     
  639.     x_ratio = scale_x / sw->scale.scale_x;
  640.     y_ratio = scale_y / sw->scale.scale_y;
  641.     
  642.     if (x_ratio < y_ratio)
  643.         sw->scale.scale_y /= x_ratio;
  644.     else
  645.         sw->scale.scale_x /= y_ratio;
  646.     }
  647.  
  648.     if (fabs(sw->scale.scale_x / sw->scale.scale_y * sw->scale.aspect_ratio 
  649.         - 1.0) > sw->scale.precision)
  650.     XtWarning("can not preserve aspect ratio");
  651. }
  652.  
  653.  
  654.  
  655. void GetScaledSize(sw)
  656.     ScaleWidget sw;
  657. {
  658.     sw->scale.width = (Dimension)
  659.     max(myrint(sw->scale.scale_x * sw->scale.image->width), 1);
  660.     sw->scale.height = (Dimension)
  661.     max(myrint(sw->scale.scale_y * sw->scale.image->height), 1);
  662. }
  663.  
  664.  
  665.  
  666. void GetScaleValues(sw)
  667.     ScaleWidget sw;
  668. {
  669.     /*
  670.      * Make sure to subtract internal width and height.
  671.      */
  672.     
  673.     sw->scale.scale_x = 
  674.     (float) max((int)(sw->core.width - 2 * sw->scale.internal_width), 1)
  675.         / (float) sw->scale.image->width;
  676.  
  677.     sw->scale.scale_y =
  678.     (float) max((int)(sw->core.height - 2 * sw->scale.internal_height), 1)
  679.         / (float) sw->scale.image->height;
  680. }
  681.  
  682.  
  683.  
  684. void Unscale(sw)
  685.     ScaleWidget sw;
  686. {
  687.     sw->scale.scale_x = sw->scale.scale_y = 1.0;
  688.  
  689.     GetScaledSize(sw);        
  690.     
  691.     BuildTable(sw);
  692. }
  693.  
  694.  
  695.  
  696. void Autoscale(sw)
  697.     ScaleWidget sw;
  698. {
  699.     GetScaleValues(sw);
  700.  
  701.     if (sw->scale.proportional) Proportional(sw);
  702.  
  703.     Precision(sw);
  704.  
  705.     GetScaledSize(sw);
  706.     
  707.     BuildTable(sw);
  708. }
  709.  
  710.  
  711.  
  712. void PositionImage(sw)
  713.     ScaleWidget sw;
  714. {
  715.     /*
  716.      * Set as if for ForgegGravity (that is center the image)
  717.      */
  718.     sw->scale.x = (Position) 
  719.     (sw->core.width - sw->scale.width) / 2;
  720.     sw->scale.y = (Position)
  721.     (sw->core.height - sw->scale.height) / 2;
  722.     
  723. /*****
  724.     if (sw->scale.gravity & WestGravity) { 
  725.     }
  726.     if (sw->scale.gravity & EastGravity) { 
  727.     }
  728.     if (sw->scale.gravity & NorthGravity) {
  729.     }
  730.     if (sw->scale.gravity & SouthGravity) {
  731.     }
  732. *****/
  733. }
  734.  
  735.  
  736.  
  737. static void Resize(w)
  738.     Widget w;
  739. {
  740.     ScaleWidget sw = (ScaleWidget) w;
  741.     
  742.     if (sw->scale.autoscale) Autoscale(sw);
  743.     
  744.     PositionImage(sw);
  745. }
  746.  
  747.  
  748.  
  749. static void Realize(wid, vmask, attr)
  750.         Widget wid;
  751.         Mask *vmask;
  752.         XSetWindowAttributes *attr;
  753. {
  754.   ScaleWidget sw = (ScaleWidget) wid;
  755.   XtCreateWindow(wid, (unsigned int) InputOutput,
  756.          (Visual *) sw->scale.visual, *vmask, attr);
  757. }
  758.  
  759.  
  760.  
  761. static void Destroy(w)
  762.     Widget w;
  763. {
  764.     ScaleWidget sw = (ScaleWidget) w; 
  765.  
  766.     XtFree((char *) sw->scale.table.x);
  767.     XtFree((char *) sw->scale.table.y);
  768.     XtFree((char *) sw->scale.table.width);
  769.     XtFree((char *) sw->scale.table.height);
  770.     
  771.     XtFree((char *) sw->scale.rectangles);
  772.  
  773.     XtReleaseGC(w, sw->scale.gc);
  774.  
  775.     XDestroyImage(sw->scale.image);
  776. }
  777.  
  778.  
  779.  
  780. /* ARGSUSED */
  781. static Boolean SetValues(current, request, new, args, num_args)
  782.     Widget current, request, new;
  783.     ArgList args;
  784.     Cardinal *num_args;
  785. {
  786.     ScaleWidget cur_sw = (ScaleWidget) current;
  787.     /* ScaleWidget req_sw = (ScaleWidget) request; */
  788.     ScaleWidget new_sw = (ScaleWidget) new;
  789.     Boolean redisplay = False;
  790.     int i;
  791.     
  792.     for (i = 0; i < *num_args; i++) {
  793.     if (streq(XtNbackground, args[i].name)) {
  794.         XSetBackground(XtDisplay(new), new_sw->scale.gc, 
  795.                new_sw->core.background_pixel);
  796.     }
  797.     if (streq(XtNforeground, args[i].name)) {
  798.         XSetForeground(XtDisplay(new), new_sw->scale.gc, 
  799.                new_sw->scale.foreground_pixel);
  800.     }
  801.     if (streq(XtNimage, args[i].name)) {
  802.         XDestroyImage(cur_sw->scale.image);
  803.         if (new_sw->scale.image == NULL)
  804.         new_sw->scale.image = XCreateImage(XtDisplay(new),
  805.                         DefaultVisual(XtDisplay(new), 
  806.                         DefaultScreen(XtDisplay(new))),
  807.                            1, XYBitmap, 0, 
  808.                            XtCalloc(1, sizeof(char)),
  809.                            1, 1, 8, 0);
  810.         else
  811.         new_sw->scale.image = 
  812.             XSubImage(new_sw->scale.image, 
  813.                   0, 0, 
  814.                   new_sw->scale.image->width, 
  815.                   new_sw->scale.image->height);
  816.  
  817.         if (new_sw->scale.resize)
  818.         TryResize(new_sw);
  819.         if (new_sw->scale.autoscale)
  820.         Autoscale(new_sw);
  821.         else {
  822.         GetScaledSize(new_sw);
  823.         BuildTable(new_sw);
  824.         }
  825.         PositionImage(new_sw);
  826.         redisplay = True;
  827.     }
  828.  
  829.     if (streq(XtNuserData, args[i].name)) 
  830.       new_sw->scale.userData = (XtPointer)args[i].value;
  831.  
  832.     if (streq(XtNbufferSize, args[i].name)) {
  833.         if (new_sw->scale.buffer_size != cur_sw->scale.buffer_size) {
  834.         GetRectangleBuffer(new_sw, new_sw->scale.buffer_size);
  835.         }
  836.     }
  837.  
  838.     if (streq(XtNaspectRatio, args[i].name)) {
  839.         if ((new_sw->scale.aspect_ratio = 
  840.          atof(new_sw->scale.aspect_ratio_str)) < 0.0) {
  841.         new_sw->scale.aspect_ratio = cur_sw->scale.aspect_ratio;
  842.         XtWarning("AspectRatio has to be a positive number.");
  843.         }
  844.         else if (new_sw->scale.aspect_ratio != cur_sw->scale.aspect_ratio){
  845.         if (new_sw->scale.proportional) {
  846.             Proportional(new_sw);
  847.             Precision(new_sw);
  848.             GetScaledSize(new_sw);
  849.             BuildTable(new_sw);
  850.             PositionImage(new_sw);
  851.             redisplay = True;
  852.         }
  853.         }
  854.     }
  855.     
  856.     if (streq(XtNproportional, args[i].name)) {
  857.         if (new_sw->scale.proportional != cur_sw->scale.proportional) {
  858.         if (new_sw->scale.proportional) Proportional(new_sw);
  859.         Precision(new_sw);
  860.         GetScaledSize(new_sw);
  861.         BuildTable(new_sw);
  862.         PositionImage(new_sw);
  863.         redisplay = True;
  864.         }
  865.     }
  866.     
  867.     if (streq(XtNscaleX, args[i].name)
  868.         || 
  869.         streq(XtNscaleY, args[i].name)) {
  870.         if (new_sw->scale.scale_x_str == DefaultScaleFactor
  871.         || 
  872.         new_sw->scale.scale_y_str == DefaultScaleFactor)
  873.         GetInitialScaleValues(new_sw);
  874.         else {
  875.         if ((new_sw->scale.scale_x = 
  876.              atof(new_sw->scale.scale_x_str)) < 0.0) {
  877.             new_sw->scale.scale_x = cur_sw->scale.scale_x;
  878.             XtWarning("ScaleValue has to be a positive number.");
  879.         }
  880.         if ((new_sw->scale.scale_y = 
  881.              atof(new_sw->scale.scale_y_str)) < 0.0) {
  882.             new_sw->scale.scale_y = cur_sw->scale.scale_y;
  883.             XtWarning("ScaleValue has to be a positive number.");
  884.         }
  885.         }
  886.         if (new_sw->scale.scale_x != cur_sw->scale.scale_x
  887.         ||
  888.         new_sw->scale.scale_y != cur_sw->scale.scale_y) {
  889.         
  890.         /*?*?*?*?*?*?*?*?*?*?*?*?*?*?**?*?*?*?*?*?*?*?*?***?*/
  891.         fprintf(stderr, "================>>%f %f\n",
  892.             new_sw->scale.scale_x, new_sw->scale.scale_y);
  893.         
  894.         if (new_sw->scale.proportional) Proportional(new_sw);
  895.         Precision(new_sw);
  896.         if (new_sw->scale.resize)
  897.             TryResize(new_sw);
  898.         GetScaledSize(new_sw);        
  899.         BuildTable(new_sw);
  900.         PositionImage(new_sw);
  901.         redisplay = True;
  902.         }
  903.     }
  904.     
  905.     if (streq(XtNprecision, args[i].name)) {
  906.         if ((new_sw->scale.precision = 
  907.          atof(new_sw->scale.precision_str)) < 0.0) {
  908.         new_sw->scale.precision = cur_sw->scale.precision;
  909.         XtWarning("Precision has to be a positive number.");
  910.         }
  911.         if (new_sw->scale.precision != cur_sw->scale.precision) {
  912.         if (new_sw->scale.proportional) Proportional(new_sw);
  913.         Precision(new_sw);
  914.         GetScaledSize(new_sw);        
  915.         BuildTable(new_sw);
  916.         PositionImage(new_sw);
  917.         redisplay = True;
  918.         }
  919.     }
  920.     }            
  921.     return(redisplay);
  922. }
  923.  
  924.  
  925.  
  926. void SWUnscale(w)
  927.     Widget w;
  928. {
  929.     ScaleWidget sw = (ScaleWidget) w;
  930.  
  931.     Unscale(sw);
  932.     PositionImage(sw);
  933.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  934. }
  935.  
  936.  
  937.  
  938. void SWAutoscale(w)
  939.     Widget w;
  940. {
  941.     ScaleWidget sw = (ScaleWidget) w;
  942.  
  943.     Autoscale(sw);
  944.     PositionImage(sw);
  945.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  946. }
  947.  
  948.  
  949.  
  950. void SWInitialSize(w)
  951.     Widget w;
  952. {
  953.     ScaleWidget sw = (ScaleWidget) w;
  954.     
  955.     GetInitialScaleValues(sw);
  956.  
  957.     if (sw->scale.proportional) Proportional(sw);
  958.     Precision(sw);
  959.     if (sw->scale.resize)
  960.     TryResize(sw);
  961.     GetScaledSize(sw);        
  962.     BuildTable(sw);
  963.     PositionImage(sw);
  964.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, True);
  965. }
  966.  
  967.  
  968.  
  969. void SWSetImage(w, image)
  970.     Widget w;
  971.     XImage *image;
  972. {
  973.     int n;
  974.     Arg wargs[2];
  975.     
  976.     n = 0;
  977.     XtSetArg(wargs[n], XtNimage, (XtArgVal) image); n++;
  978.     XtSetValues(w, wargs, n);
  979. }
  980.  
  981.  
  982.  
  983. extern void SWRequestSelection();
  984.  
  985. void RequestSelection(w, event)
  986.     Widget w;
  987.     XEvent *event;
  988. {
  989.     SWRequestSelection(w, event->xbutton.time);
  990. }
  991.  
  992.  
  993.  
  994. extern void SWGrabSelection();
  995.  
  996. void GrabSelection(w, event)
  997.     Widget w;
  998.     XEvent *event;
  999. {
  1000.     SWGrabSelection(w, event->xbutton.time);
  1001. }
  1002.  
  1003.  
  1004.  
  1005. Pixmap SWGetPixmap(w)
  1006.     Widget w;
  1007. {
  1008.     ScaleWidget sw = (ScaleWidget) w;
  1009.     Pixmap pixmap;
  1010.  
  1011.     pixmap = XCreatePixmap(XtDisplay(w), XtWindow(w), 
  1012.                sw->scale.width, 
  1013.                sw->scale.height, 
  1014.                sw->scale.image->depth);
  1015.     ScaleImage(sw, pixmap, 
  1016.            0, 0, 0, 0, 
  1017.            (Dimension) sw->scale.image->width, 
  1018.            (Dimension) sw->scale.image->height);
  1019.     
  1020.     return(pixmap);
  1021. }
  1022.