modules/FvwmButtons/misc.c

   1 /* -*-c-*- */
   2 /*
   3  * FvwmButtons, copyright 1996, Jarl Totland
   4  *
   5  * This module, and the entire GoodStuff program, and the concept for
   6  * interfacing this module to the Window Manager, are all original work
   7  * by Robert Nation
   8  *
   9  * Copyright 1993, Robert Nation. No guarantees or warantees or anything
  10  * are provided or implied in any way whatsoever. Use this program at your
  11  * own risk. Permission to use this program for any purpose is given,
  12  * as long as the copyright is kept intact.
  13  *
  14  */
  15
  16 /* This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  */
  30
  31 #include "config.h"
  32
  33 #include "misc.h"
  34 #include <stdio.h>
  35
  36 /**
  37 *** ConstrainSize()
  38 *** Adjust a given width and height to account for the constraints imposed by
  39 *** size hints.
  40 *** The general algorithm, especially the aspect ratio stuff, is borrowed from
  41 *** uwm's CheckConsistency routine.
  42 **/
  43 void ConstrainSize (XSizeHints *hints, int *widthp, int *heightp)
  44 {
  45 #define makemult(a,b) ((b == 1) ? (a) : (((int)((a) / (b))) * (b)))
  46
  47         int minWidth, minHeight, maxWidth, maxHeight, xinc, yinc, delta;
  48         int baseWidth, baseHeight;
  49         int dwidth = *widthp, dheight = *heightp;
  50
  51         if (hints->flags & PMinSize)
  52         {
  53                 minWidth = hints->min_width;
  54                 minHeight = hints->min_height;
  55                 if (hints->flags & PBaseSize)
  56                 {
  57                         baseWidth = hints->base_width;
  58                         baseHeight = hints->base_height;
  59                 }
  60                 else
  61                 {
  62                         baseWidth = hints->min_width;
  63                         baseHeight = hints->min_height;
  64                 }
  65         }
  66         else if (hints->flags & PBaseSize)
  67         {
  68                 minWidth = hints->base_width;
  69                 minHeight = hints->base_height;
  70                 baseWidth = hints->base_width;
  71                 baseHeight = hints->base_height;
  72         }
  73         else
  74         {
  75                 minWidth = 1;
  76                 minHeight = 1;
  77                 baseWidth = 1;
  78                 baseHeight = 1;
  79         }
  80
  81         if (hints->flags & PMaxSize)
  82         {
  83                 maxWidth = hints->max_width;
  84                 maxHeight = hints->max_height;
  85         }
  86         else
  87         {
  88                 maxWidth = 32767;
  89                 maxHeight = 32767;
  90         }
  91         if (hints->flags & PResizeInc)
  92         {
  93                 xinc = hints->width_inc;
  94                 yinc = hints->height_inc;
  95         }
  96         else
  97         {
  98                 xinc = 1;
  99                 yinc = 1;
 100         }
 101
 102         /*
 103          * First, clamp to min and max values
 104          */
 105         if (dwidth < minWidth)
 106         {
 107                 dwidth = minWidth;
 108         }
 109         if (dheight < minHeight)
 110         {
 111                 dheight = minHeight;
 112         }
 113
 114         if (dwidth > maxWidth)
 115         {
 116                 dwidth = maxWidth;
 117         }
 118         if (dheight > maxHeight)
 119         {
 120                 dheight = maxHeight;
 121         }
 122
 123
 124         /*
 125          * Second, fit to base + N * inc
 126          */
 127         dwidth = ((dwidth - baseWidth) / xinc * xinc) + baseWidth;
 128         dheight = ((dheight - baseHeight) / yinc * yinc) + baseHeight;
 129
 130
 131         /*
 132          * Third, adjust for aspect ratio
 133          */
 134 #define maxAspectX hints->max_aspect.x
 135 #define maxAspectY hints->max_aspect.y
 136 #define minAspectX hints->min_aspect.x
 137 #define minAspectY hints->min_aspect.y
 138         /*
 139          * The math looks like this:
 140          *
 141          * minAspectX    dwidth     maxAspectX
 142          * ---------- <= ------- <= ----------
 143          * minAspectY    dheight    maxAspectY
 144          *
 145          * If that is multiplied out, then the width and height are
 146          * invalid in the following situations:
 147          *
 148          * minAspectX * dheight > minAspectY * dwidth
 149          * maxAspectX * dheight < maxAspectY * dwidth
 150          *
 151          */
 152
 153         if (hints->flags & PAspect)
 154         {
 155                 if (minAspectX * dheight > minAspectY * dwidth)
 156                 {
 157                         delta = makemult(
 158                                 minAspectX * dheight / minAspectY - dwidth,
 159                                 xinc);
 160                         if (dwidth + delta <= maxWidth)
 161                         {
 162                                 dwidth += delta;
 163                         }
 164                         else
 165                         {
 166                                 delta = makemult(
 167                                         dheight - minAspectY*dwidth/minAspectX,
 168                                         yinc);
 169                                 if (dheight - delta >= minHeight)
 170                                 {
 171                                         dheight -= delta;
 172                                 }
 173                         }
 174                 }
 175
 176                 if (maxAspectX * dheight < maxAspectY * dwidth)
 177                 {
 178                         delta = makemult(
 179                                 dwidth * maxAspectY / maxAspectX - dheight,
 180                                 yinc);
 181                         if (dheight + delta <= maxHeight)
 182                         {
 183                                 dheight += delta;
 184                         }
 185                         else
 186                         {
 187                                 delta = makemult(
 188                                         dwidth - maxAspectX*dheight/maxAspectY,
 189                                         xinc);
 190                                 if (dwidth - delta >= minWidth)
 191                                 {
 192                                         dwidth -= delta;
 193                                 }
 194                         }
 195                 }
 196         }
 197
 198         *widthp = dwidth;
 199         *heightp = dheight;
 200         return;
 201 #undef makemult
 202 #undef maxAspectX
 203 #undef maxAspectY
 204 #undef minAspectX
 205 #undef minAspectY
 206 }