move size hint code to FbWinFrame

1 files changed, 132 insertions, 0 deletions

diff --git a/src/FbWinFrame.cc b/src/FbWinFrame.cc
index afd5fb5..4734b2b 100644
--- a/src/FbWinFrame.cc
+++ b/src/FbWinFrame.cc
@@ -1459,6 +1459,138 @@ void FbWinFrame::applyDecorations() {
         frameExtentSig().notify();
 }
 
+/* For aspect ratios
+   Note that its slightly simplified in that only the
+   line gradient is given - this is because for aspect
+   ratios, we always have the line going through the origin
+
+   * Based on this formula:
+   http://astronomy.swin.edu.au/~pbourke/geometry/pointline/
+
+   Note that a gradient from origin goes through ( grad , 1 )
+ */
+
+void closestPointToLine(double &ret_x, double &ret_y,
+                        double point_x, double point_y,
+                        double gradient) {
+    double u = (point_x * gradient + point_y) /
+        (gradient*gradient + 1);
+
+    ret_x = u*gradient;
+    ret_y = u;
+}
+
+/**
+ * Changes width and height to the nearest (lower) value
+ * that conforms to it's size hints.
+ *
+ * display_* give the values that would be displayed
+ * to the user when resizing.
+ * We use pointers for display_* since they are optional.
+ *
+ * See ICCCM section 4.1.2.3
+ */
+void FbWinFrame::applySizeHints(int &width, int &height,
+                                int *display_width, int *display_height,
+                                bool maximizing) {
+
+    int i = width, j = height;
+
+    // Check minimum size
+    if (width < 0 || width < static_cast<signed>(m_size_hints.min_width))
+        width = m_size_hints.min_width;
+
+    if (height < 0 || height < static_cast<signed>(m_size_hints.min_height))
+        height = m_size_hints.min_height;
+
+    // Check maximum size
+    if (m_size_hints.max_width > 0 && width > static_cast<signed>(m_size_hints.max_width))
+        width = m_size_hints.max_width;
+
+    if (m_size_hints.max_height > 0 && height > static_cast<signed>(m_size_hints.max_height))
+        height = m_size_hints.max_height;
+
+    // we apply aspect ratios before incrementals
+    // Too difficult to exactly satisfy both incremental+aspect
+    // in most situations
+    // (they really shouldn't happen at the same time anyway).
+
+    /* aspect ratios are applied exclusive to the m_size_hints.base_width
+     *
+     * m_size_hints.min_aspect_x      width      m_size_hints.max_aspect_x
+     * ------------  <  -------  <  ------------
+     * m_size_hints.min_aspect_y      height     m_size_hints.max_aspect_y
+     *
+     * beware of integer maximum (so I'll use doubles instead and divide)
+     *
+     * The trick is how to get back to the aspect ratio with minimal
+     * change - do we modify x, y or both?
+     * A: we minimise the distance between the current point, and
+     *    the target aspect ratio (consider them as x,y coordinates)
+     *  Consider that the aspect ratio is a line, and the current
+     *  w/h is a point, so we're just using the formula for
+     *  shortest distance from a point to a line!
+     *
+     * When maximizing, we must not increase any of the sizes, because we
+     * would end up with the window partly off a screen, so a simpler formula
+     * is used in that case.
+     */
+
+    if (m_size_hints.min_aspect_y > 0 && m_size_hints.max_aspect_y > 0 &&
+        (height - m_size_hints.base_height) > 0) {
+        double widthd = static_cast<double>(width - m_size_hints.base_width);
+        double heightd = static_cast<double>(height - m_size_hints.base_height);
+
+        double min = static_cast<double>(m_size_hints.min_aspect_x) /
+            static_cast<double>(m_size_hints.min_aspect_y);
+
+        double max = static_cast<double>(m_size_hints.max_aspect_x) /
+            static_cast<double>(m_size_hints.max_aspect_y);
+
+        double actual = widthd / heightd;
+
+        if (max > 0 && min > 0 && actual > 0) { // don't even try otherwise
+            bool changed = false;
+            if (actual < min) {
+                changed = true;
+                if (maximizing)
+                    heightd = widthd / min;
+                else
+                    closestPointToLine(widthd, heightd, widthd, heightd, min);
+            } else if (actual > max) {
+                changed = true;
+                if (maximizing)
+                    widthd = heightd * max;
+                else
+                    closestPointToLine(widthd, heightd, widthd, heightd, max);
+            }
+
+            if (changed) {
+                width = static_cast<int>(widthd) + m_size_hints.base_width;
+                height = static_cast<int>(heightd) + m_size_hints.base_height;
+            }
+        }
+    }
+
+    // enforce incremental size limits, wrt base size
+    // only calculate this if we really need to
+    i = (width - static_cast<signed>(m_size_hints.base_width)) /
+        static_cast<signed>(m_size_hints.width_inc);
+    width = i*static_cast<signed>(m_size_hints.width_inc) +
+        static_cast<signed>(m_size_hints.base_width);
+
+    j = (height - static_cast<signed>(m_size_hints.base_height)) /
+        static_cast<signed>(m_size_hints.height_inc);
+    height = j*static_cast<signed>(m_size_hints.height_inc) +
+        static_cast<signed>(m_size_hints.base_height);
+
+    if (display_width)
+        *display_width = i;
+
+    if (display_height)
+        *display_height = j;
+}
+
 bool FbWinFrame::setBorderWidth(bool do_move) {
     unsigned int border_width = theme()->border().width();
     unsigned int win_bw = m_decoration_mask & DECORM_BORDER ? border_width : 0;