Refine search
public void setLocationAndPosition() { if (this.settings.loadWindowPos(this)) { return; } GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); DisplayMode mode = gd.getDisplayMode(); int w = mode.getWidth(); int h = mode.getHeight(); setLocation((int) (w * BORDER_RATIO), (int) (h * BORDER_RATIO)); setSize((int) (w * WINDOW_RATIO), (int) (h * WINDOW_RATIO)); }
public static DisplayMode getDesktopDisplayMode () { GraphicsEnvironment genv = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice device = genv.getDefaultScreenDevice(); java.awt.DisplayMode mode = device.getDisplayMode(); return new LwjglApplicationConfigurationDisplayMode(mode.getWidth(), mode.getHeight(), mode.getRefreshRate(), mode.getBitDepth()); }
/** * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(DisplayMode a, DisplayMode b) { // Width if (a.getWidth() != b.getWidth()) { return (a.getWidth() > b.getWidth()) ? 1 : -1; } // Height if (a.getHeight() != b.getHeight()) { return (a.getHeight() > b.getHeight()) ? 1 : -1; } // Bit depth if (a.getBitDepth() != b.getBitDepth()) { return (a.getBitDepth() > b.getBitDepth()) ? 1 : -1; } // Refresh rate if (a.getRefreshRate() != b.getRefreshRate()) { return (a.getRefreshRate() > b.getRefreshRate()) ? 1 : -1; } // All fields are equal return 0; } }
DisplayMode dm = new DisplayMode(800, 600, 16, DisplayMode.REFRESH_RATE_UNKNOWN); s.setFullScreen(dm, frame); GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment(); vc = env.getDefaultScreenDevice(); window.setUndecorated(true); window.setResizable(false); vc.setFullScreenWindow(window); if (dm != null && vc.isDisplayChangeSupported()) { try { vc.setDisplayMode(dm); } catch (Exception e) {
frame.setSize(800, 600); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); GraphicsDevice device = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); device.setFullScreenWindow(frame); device.setDisplayMode(new DisplayMode(800, 600, 32, 60)); frame.setVisible(true);
Color.magenta, Color.orange, Color.darkGray }; private static DisplayMode[] BEST_DISPLAY_MODES = new DisplayMode[] { new DisplayMode(640, 480, 32, 0), new DisplayMode(640, 480, 16, 0), new DisplayMode(640, 480, 8, 0) }; GraphicsConfiguration gc = device.getDefaultConfiguration(); mainFrame = new Frame(gc); mainFrame.setUndecorated(true); mainFrame.setIgnoreRepaint(true); device.setFullScreenWindow(mainFrame); if (device.isDisplayChangeSupported()) { chooseBestDisplayMode(device); DisplayMode[] modes = device.getDisplayModes(); for (int i = 0; i < modes.length; i++) { if (modes[i].getWidth() == BEST_DISPLAY_MODES[x].getWidth() && modes[i].getHeight() == BEST_DISPLAY_MODES[x].getHeight() && modes[i].getBitDepth() == BEST_DISPLAY_MODES[x].getBitDepth() ) { return BEST_DISPLAY_MODES[x]; getLocalGraphicsEnvironment(); GraphicsDevice device = env.getDefaultScreenDevice(); MultiBufferTest test = new MultiBufferTest(numBuffers, device); } catch (Exception e) {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); defDev = ge.getDefaultScreenDevice(); } catch (Throwable e1) { logger.log(Level.SEVERE, "Cannot access default screen device: "+e1.getMessage(), e1); GraphicsDevice[] devs = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices(); java.awt.DisplayMode useDM = null; int max = 0; for(java.awt.DisplayMode dm : VRdev.getDisplayModes()) { int check = dm.getHeight() + dm.getWidth() + dm.getRefreshRate() + dm.getBitDepth(); if( check > max ) { max = check; settings.setWidth(useDM.getWidth()); settings.setHeight(useDM.getHeight()); settings.setBitsPerPixel(useDM.getBitDepth()); settings.setFrequency(useDM.getRefreshRate()); settings.setSwapBuffers(true); settings.setVSync(true); // allow vsync on this display if( VRdev.getDisplayMode().equals(useDM) == false ) { VRdev.setDisplayMode(useDM); settings.setFrequency(defDev.getDisplayMode().getRefreshRate()); settings.setDepthBits(24); settings.setVSync(true);
protected void applySettings(AppSettings settings){ final boolean isDisplayModeModified; final GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); final DisplayMode previousDisplayMode = gd.getDisplayMode(); if (gd.isDisplayChangeSupported()) { if (currentDisplayMode.getWidth() == settings.getWidth() && currentDisplayMode.getHeight() == settings.getHeight()) { if (currentDisplayMode.getBitDepth() == settings.getBitsPerPixel()) { if (currentDisplayMode.getRefreshRate() == settings.getFrequency()) { matchingDisplayMode = currentDisplayMode; } else if (currentDisplayMode.getRefreshRate() == DisplayMode.REFRESH_RATE_UNKNOWN) { refreshRateUnknownDisplayMode = currentDisplayMode; } else if (currentDisplayMode.getBitDepth() == DisplayMode.BIT_DEPTH_MULTI) { if (currentDisplayMode.getRefreshRate() == settings.getFrequency()) { multiBitsDepthSupportedDisplayMode = currentDisplayMode; } else if (currentDisplayMode.getRefreshRate() == DisplayMode.REFRESH_RATE_UNKNOWN) { multiBitsDepthSupportedAndRefreshRateUnknownDisplayMode = currentDisplayMode; new Object[]{gd.getDisplayMode().getWidth(), gd.getDisplayMode().getHeight(), gd.getDisplayMode().getBitDepth(), gd.getDisplayMode().getRefreshRate()});
int width = 0; int height = 0; GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] gs = ge.getScreenDevices(); for (GraphicsDevice curGs : gs) { DisplayMode mode = curGs.getDisplayMode(); width += mode.getWidth(); height = mode.getHeight(); }
@Override public DefaultRequest discoverParameters(GoogleAnalyticsConfig config, DefaultRequest request) { super.discoverParameters(config, request); Toolkit toolkit = Toolkit.getDefaultToolkit(); if (isEmpty(request.screenResolution())) { Dimension screenSize = toolkit.getScreenSize(); request.screenResolution(((int) screenSize.getWidth()) + "x" + ((int) screenSize.getHeight()) + ", " + toolkit.getScreenResolution() + " dpi"); } if (isEmpty(request.screenColors())) { GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] graphicsDevices = graphicsEnvironment.getScreenDevices(); StringBuilder sb = new StringBuilder(); for (GraphicsDevice graphicsDevice : graphicsDevices) { if (sb.length() != 0) { sb.append(", "); } sb.append(graphicsDevice.getDisplayMode().getBitDepth()); } request.screenColors(sb.toString()); } return request; } }
private void changeScreenResolution(DisplayMode displayMode) { GraphicsDevice localDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice(); if (localDevice.isFullScreenSupported()) { this.displayMode = displayMode; localDevice.setFullScreenWindow(this); setDisplayMode(); if (useFullscreen) { setSize(getFullScreenDimension()); setPreferredSize(getFullScreenDimension()); setLocation(); } if (log.isInfoEnabled()) { log.info(String.format("Changing resolution to %dx%d, %d bits, %d Hz", displayMode.getWidth(), displayMode.getHeight(), displayMode.getBitDepth(), displayMode.getRefreshRate())); } } }
DisplayMode dm = new DisplayMode(800, 600, 32, 60); device.setDisplayMode(dm); setSize(new Dimension(dm.getWidth(), dm.getHeight())); validate(); isFullScreenSupported = device.isFullScreenSupported(); setUndecorated(isFullScreenSupported); setResizable(!isFullScreenSupported); if (isFullScreenSupported) { device.setFullScreenWindow(this); validate(); } else { GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice defaultScreen = env.getDefaultScreenDevice(); DisplayModeChanger changer = new DisplayModeChanger(defaultScreen); changer.getContentPane().add(changeDM);
private void getDisplayInfo() { GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] gs = ge.getScreenDevices(); appendInfo("==== Display Information ===="); appendInfo("Number of Displays: " + gs.length); // XXX Is there any way to report on the actual hardware? nVidia and // ATI/AMD cards sometimes have bugs in their proprietary drivers that // cause headache for Java. It would be nice to have that information. // For Windows it would be good to see DirectX module names and version // numbers, but can we obtain that from the JRE...? int i = 0; for (GraphicsDevice gd : gs) { i++; DisplayMode dm = gd.getDisplayMode(); int bits = dm.getBitDepth(); String depth = "(" + bits + ")"; appendInfo("Display " + i + ": " + dm.getWidth() + "x" + dm.getHeight() + depth); } }
@Override boolean validGraphicsMode() { if (VERBOSE) System.err.println("JoglPipeline.validGraphicsMode()"); // FIXME: believe this should do exactly what the native code // used to, but not 100% sure (also in theory should only run // this code on the Windows platform? What about Mac OS X?) DisplayMode currentMode = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDisplayMode(); // Note: on X11 platforms, a bit depth < 0 simply indicates that // multiple visuals are supported on the current display mode if (VERBOSE) System.err.println(" Returning " + (currentMode.getBitDepth() < 0 || currentMode.getBitDepth() > 8)); return (currentMode.getBitDepth() < 0 || currentMode.getBitDepth() > 8); }
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice gd = ge.getDefaultScreenDevice(); for (DisplayMode dm : gd.getDisplayModes()) { System.out.println(dm.getWidth() + "x" + dm.getHeight() + "@" + dm.getRefreshRate()); }
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] gs = ge.getScreenDevices(); // Get size of each screen for (int i=0; i<gs.length; i++) { DisplayMode dm = gs[i].getDisplayMode(); int screenWidth = dm.getWidth(); int screenHeight = dm.getHeight(); }
public ScreenCaptureDevice(final GraphicsDevice device) { this.device = device; this.mode = device.getDisplayMode(); this.resolution = new Dimension(mode.getWidth(), mode.getHeight()); this.resolutions = new Dimension[] { this.resolution }; try { this.robot = new Robot(device); } catch (AWTException e) { throw new WebcamException("Unable to create robot", e); } LOG.trace("Screen device {} with resolution {} has been created", getName(), getResolution()); }
DisplayMode d = gd.getDisplayMode(), d2 = null; if (displayMode != null && d != null) { int w = displayMode.getWidth(); int h = displayMode.getHeight(); int b = displayMode.getBitDepth(); int r = displayMode.getRefreshRate(); d2 = new DisplayMode(w > 0 ? w : d.getWidth(), h > 0 ? h : d.getHeight(), b > 0 ? b : d.getBitDepth(), r > 0 ? r : d.getRefreshRate()); getRootPane().setWindowDecorationStyle(JRootPane.NONE); setResizable(false); gd.setFullScreenWindow(CanvasFrame.this); } else { setLocationByPlatform(true); if (d2 != null && !d2.equals(d)) { gd.setDisplayMode(d2);
/** * Chooses the closest frequency to 60 Hz. * * @param resolution * @param modes * @return */ private static String getBestFrequency(String resolution, DisplayMode[] modes) { int closest = Integer.MAX_VALUE; int desired = 60; for (int i = 0; i < modes.length; i++) { String res = modes[i].getWidth() + " x " + modes[i].getHeight(); int freq = modes[i].getRefreshRate(); if (freq != DisplayMode.REFRESH_RATE_UNKNOWN && res.equals(resolution)) { if (Math.abs(freq - desired) < Math.abs(closest - desired)) { closest = modes[i].getRefreshRate(); } } } if (closest != Integer.MAX_VALUE) { return closest + " Hz"; } else { return null; } }
/** * Returns every possible bit depth for the given resolution. */ private static String[] getDepths(String resolution, DisplayMode[] modes) { ArrayList<String> depths = new ArrayList<String>(4); for (int i = 0; i < modes.length; i++) { // Filter out all bit depths lower than 16 - Java incorrectly // reports // them as valid depths though the monitor does not support them if (modes[i].getBitDepth() < 16 && modes[i].getBitDepth() > 0) { continue; } String res = modes[i].getWidth() + " x " + modes[i].getHeight(); String depth = modes[i].getBitDepth() + " bpp"; if (res.equals(resolution) && !depths.contains(depth)) { depths.add(depth); } } if (depths.size() == 1 && depths.contains("-1 bpp")) { // add some default depths, possible system is multi-depth supporting depths.clear(); depths.add("24 bpp"); } String[] res = new String[depths.size()]; depths.toArray(res); return res; }