Jogamp
4586812e1405df553e4ee6f7888b1ca50d85d6eb
[jogl.git] / src / nativewindow / classes / jogamp / nativewindow / SurfaceScaleUtils.java
1 /**
2  * Copyright 2014 JogAmp Community. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without modification, are
5  * permitted provided that the following conditions are met:
6  *
7  *    1. Redistributions of source code must retain the above copyright notice, this list of
8  *       conditions and the following disclaimer.
9  *
10  *    2. Redistributions in binary form must reproduce the above copyright notice, this list
11  *       of conditions and the following disclaimer in the documentation and/or other materials
12  *       provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
15  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
16  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
21  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
22  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  *
24  * The views and conclusions contained in the software and documentation are those of the
25  * authors and should not be interpreted as representing official policies, either expressed
26  * or implied, of JogAmp Community.
27  */
28 package jogamp.nativewindow;
29
30 import javax.media.nativewindow.NativeWindowFactory;
31 import javax.media.nativewindow.ScalableSurface;
32
33 /**
34  * Basic {@link ScalableSurface} utility to validate and compute pixel-scale values.
35  */
36 public class SurfaceScaleUtils {
37
38     private static final int[] PlatformMaxPixelScale;
39     private static final boolean PlatformUniformPixelScale;
40     private static final boolean PlatformPixelScaleSupported;
41
42     static {
43       if( NativeWindowFactory.TYPE_MACOSX == NativeWindowFactory.getNativeWindowType(true) ) {
44           PlatformMaxPixelScale = new int[] { jogamp.nativewindow.macosx.OSXUtil.MAX_PIXELSCALE, jogamp.nativewindow.macosx.OSXUtil.MAX_PIXELSCALE };
45           PlatformUniformPixelScale = true;
46           PlatformPixelScaleSupported = true;
47       } else {
48           PlatformMaxPixelScale = new int[] { ScalableSurface.IDENTITY_PIXELSCALE, ScalableSurface.IDENTITY_PIXELSCALE };
49           PlatformUniformPixelScale = false;
50           PlatformPixelScaleSupported = false;
51       }
52     }
53
54     /**
55      * Compute a new valid pixelScale to be used by {@link NativeSurface} implementations,
56      * based on the given request and surface's pixelScale
57      *
58      * @param result int[2] storage for result, maybe same as <code>prePixelScale</code> for in-place
59      * @param prePixelScale previous pixelScale
60      * @param reqPixelScale requested pixelScale, validated via {@link #validateReqPixelScale(int[], int, String)}.
61      * @param surfPixelScaleRaw raw surface pixelScale
62      * @param DEBUG_PREFIX if set, dumps debug info on stderr using this prefix
63      * @return true if pixelScale has changed, otherwise false
64      */
65     public static boolean computePixelScale(int[] result, final int[] prePixelScale, final int[] reqPixelScale, final int[] surfPixelScaleRaw, final String DEBUG_PREFIX) {
66         final int surfPixelScaleSafeX = 0 < surfPixelScaleRaw[0] ? surfPixelScaleRaw[0] : ScalableSurface.IDENTITY_PIXELSCALE;
67         final int surfPixelScaleSafeY = 0 < surfPixelScaleRaw[1] ? surfPixelScaleRaw[1] : ScalableSurface.IDENTITY_PIXELSCALE;
68         final boolean useHiDPI = ScalableSurface.IDENTITY_PIXELSCALE != reqPixelScale[0] || ScalableSurface.IDENTITY_PIXELSCALE != reqPixelScale[1];
69         final int prePixelScaleX = prePixelScale[0];
70         final int prePixelScaleY = prePixelScale[1];
71
72         if( useHiDPI ) {
73             result[0] = surfPixelScaleSafeX;
74             result[1] = surfPixelScaleSafeY;
75         } else {
76             result[0] = ScalableSurface.IDENTITY_PIXELSCALE;
77             result[1] = ScalableSurface.IDENTITY_PIXELSCALE;
78         }
79
80         if( result[0] != prePixelScaleX || result[1] != prePixelScaleY ) {
81             if( null != DEBUG_PREFIX ) {
82                 System.err.println(DEBUG_PREFIX+".computePixelScale: useHiDPI "+useHiDPI+", ["+prePixelScaleX+"x"+prePixelScaleY+" (pre), "+
83                         reqPixelScale[0]+"x"+reqPixelScale[1]+" (req)] -> "+
84                         surfPixelScaleRaw[0]+"x"+surfPixelScaleRaw[1]+" (raw) -> "+
85                         surfPixelScaleSafeX+"x"+surfPixelScaleSafeY+" (safe) -> "+
86                         result[0]+"x"+result[1]+" (use)");
87             }
88             return true;
89         } else {
90             return false;
91         }
92     }
93
94     /**
95      * Validate the given requested pixelScale value pair, i.e. clip it to the
96      * limits of {@link ScalableSurface#AUTOMAX_PIXELSCALE} and {@link #getPlatformMaxPixelScale(int[])}
97      * <p>
98      * To be used by {@link ScalableSurface#setSurfaceScale(int[], int[])} implementations.
99      * </p>
100      *
101      * @param result int[2] storage for result
102      * @param reqPixelScale requested pixelScale
103      * @param DEBUG_PREFIX if set, dumps debug info on stderr using this prefix
104      */
105     public static void validateReqPixelScale(final int[] result, final int[] reqPixelScale, final String DEBUG_PREFIX) {
106         final int minPS = Math.min(reqPixelScale[0], reqPixelScale[1]);
107         if( ScalableSurface.AUTOMAX_PIXELSCALE >= minPS ) {
108             result[0] = ScalableSurface.AUTOMAX_PIXELSCALE;
109             result[1] = ScalableSurface.AUTOMAX_PIXELSCALE;
110         } else if( PlatformUniformPixelScale ) {
111             final int maxPS = Math.max(reqPixelScale[0], reqPixelScale[1]);
112             if( maxPS >= PlatformMaxPixelScale[0] ) {
113                 result[0] = PlatformMaxPixelScale[0];
114                 result[1] = PlatformMaxPixelScale[1];
115             } else {
116                 result[0] = maxPS;
117                 result[1] = maxPS;
118             }
119         } else {
120             if( reqPixelScale[0] >= PlatformMaxPixelScale[0] ) {
121                 result[0] = PlatformMaxPixelScale[0];
122             } else {
123                 result[0] = reqPixelScale[0];
124             }
125             if( reqPixelScale[1] >= PlatformMaxPixelScale[1] ) {
126                 result[1] = PlatformMaxPixelScale[1];
127             } else {
128                 result[1] = reqPixelScale[1];
129             }
130         }
131         if( null != DEBUG_PREFIX ) {
132             System.err.println(DEBUG_PREFIX+".validateReqPixelScale: ["+reqPixelScale[0]+"x"+reqPixelScale[1]+" (req), "+
133                     PlatformMaxPixelScale[0]+"x"+PlatformMaxPixelScale[1]+" (max)] -> "+
134                     result[0]+"x"+result[1]+" (valid)");
135         }
136     }
137
138     /**
139      * Replaces {@link ScalableSurface#AUTOMAX_PIXELSCALE} with {@link #getPlatformMaxPixelScale(int[])},
140      * for each component.
141      *
142      * @param pixelScale int[2] value array to be tested and replaced
143      */
144     public static void replaceAutoMaxWithPlatformMax(final int[] pixelScale) {
145         if( ScalableSurface.AUTOMAX_PIXELSCALE == pixelScale[0] ) {
146             pixelScale[0] = PlatformMaxPixelScale[0];
147         }
148         if( ScalableSurface.AUTOMAX_PIXELSCALE == pixelScale[1] ) {
149             pixelScale[1] = PlatformMaxPixelScale[1];
150         }
151     }
152
153     /**
154      * Returns the maximum platform pixelScale
155      */
156     public static int[] getPlatformMaxPixelScale(final int[] result) {
157         System.arraycopy(PlatformMaxPixelScale, 0, result, 0, 2);
158         return result;
159     }
160
161     /**
162      * Returns true if platform pixelScale is uniform, i.e. same scale factor for x- and y-direction, otherwise false.
163      */
164     public static boolean isPlatformPixelScaleUniform() {
165         return PlatformUniformPixelScale;
166     }
167
168     /**
169      * Returns whether the platform supports pixelScale
170      */
171     public static boolean isPlatformPixelScaleSupported() {
172         return PlatformPixelScaleSupported;
173     }
174
175 }
http://JogAmp.org git info: FAQ, tutorial and man pages.