80 2004-04-30 02:40:10 +0200 redraw after reshape, swapBuffer() gives Exception 2010-03-24 07:46:32 +0100 0 0 3 JogAmp Jogl core 1 All windows VERIFIED DUPLICATE 78 P3 normal --- 1 sgothel sgothel DEFECT --- oldest_to_newest 96 0 sgothel 2010-03-24 07:46:32 +0100 ---- Reported by andreas_k 2004-04-30 02:40:10 ---- Issue in forum: http://www.JavaGaming.org/cgi-bin/JGNetForums/YaBB.cgi? board=jogl;action=display;num=1083234418 I've found out that the redraw problem after resizing the frame only appears: - if you make the frame size greater - if hardware acceleration mode is used I modified the DefaultCapabilitiesChooser NOT to use the windowsPreferedMode, because it doesn't select a Hardware Accelerated mode... I modified the NeHe Lesson03 code to reproduce the problems: - swapBuffer() in display function throws Exception but works - resizing the frame sometimes gives a grey background Here is the code /* * Lesson03.java * * Created on July 14, 2003, 12:35 PM */ import java.awt.*; import java.awt.event.*; import javax.swing.*; import net.java.games.jogl.*; /** Port of the NeHe OpenGL Tutorial (Lesson 3: Colors) * to Java using the Jogl interface to OpenGL. Jogl can be obtained * at http://jogl.dev.java.net/ * * @author Kevin Duling (jattier@hotmail.com) */ public class Lesson03 { static class Renderer implements GLEventListener, KeyListener { /** Called by the drawable to initiate OpenGL rendering by the client. * After all GLEventListeners have been notified of a display event, the * drawable will swap its buffers if necessary. * @param gLDrawable The GLDrawable object. */ public void display(GLDrawable gLDrawable) { final GL gl = gLDrawable.getGL(); gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); gl.glLoadIdentity(); gl.glTranslatef(-1.5f, 0.0f, -6.0f); gl.glBegin(GL.GL_TRIANGLES); // Drawing Using Triangles gl.glColor3f(1.0f, 0.0f, 0.0f); // Set the current drawing color to red gl.glVertex3f( 0.0f, 1.0f, 0.0f); // Top gl.glColor3f(0.0f, 1.0f, 0.0f); // Set the current drawing color to green gl.glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left gl.glColor3f(0.0f, 0.0f, 1.0f); // Set the current drawing color to blue gl.glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right gl.glEnd(); // Finished Drawing The Triangle gl.glTranslatef(3.0f, 0.0f, 0.0f); gl.glBegin(GL.GL_QUADS); // Draw A Quad gl.glColor3f(0.5f, 0.5f, 1.0f); // Set the current drawing color to light blue gl.glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left gl.glVertex3f( 1.0f, 1.0f, 0.0f); // Top Right gl.glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right gl.glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left gl.glEnd(); // Done Drawing The Quad gl.glFlush(); gLDrawable.swapBuffers(); } /** Called when the display mode has been changed. <B>!! CURRENTLY UNIMPLEMENTED IN JOGL !!</B> * @param gLDrawable The GLDrawable object. * @param modeChanged Indicates if the video mode has changed. * @param deviceChanged Indicates if the video device has changed. */ public void displayChanged(GLDrawable gLDrawable, boolean modeChanged, boolean deviceChanged) { } /** Called by the drawable immediately after the OpenGL context is * initialized for the first time. Can be used to perform one-time OpenGL * initialization such as setup of lights and display lists. * @param gLDrawable The GLDrawable object. */ public void init(GLDrawable gLDrawable) { final GL gl = gLDrawable.getGL(); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens. gLDrawable.addKeyListener(this); } /** Called by the drawable during the first repaint after the component has * been resized. The client can update the viewport and view volume of the * window appropriately, for example by a call to * GL.glViewport(int, int, int, int); note that for convenience the component * has already called GL.glViewport(int, int, int, int)(x, y, width, height) * when this method is called, so the client may not have to do anything in * this method. * @param gLDrawable The GLDrawable object. * @param x The X Coordinate of the viewport rectangle. * @param y The Y coordinate of the viewport rectanble. * @param width The new width of the window. * @param height The new height of the window. */ public void reshape(GLDrawable gLDrawable, int x, int y, int width, int height) { final GL gl = gLDrawable.getGL(); final GLU glu = gLDrawable.getGLU(); if (height <= 0) // avoid a divide by zero error! height = 1; final float h = (float)width / (float)height; gl.glViewport(0, 0, width, height); gl.glMatrixMode(GL.GL_PROJECTION); gl.glLoadIdentity(); glu.gluPerspective(45.0f, h, 1.0, 20.0); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glLoadIdentity(); } /** Invoked when a key has been pressed. * See the class description for {@link KeyEvent} for a definition of * a key pressed event. * @param e The KeyEvent. */ public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_ESCAPE) System.exit(0); } /** Invoked when a key has been released. * See the class description for {@link KeyEvent} for a definition of * a key released event. * @param e The KeyEvent. */ public void keyReleased(KeyEvent e) {} /** Invoked when a key has been typed. * See the class description for {@link KeyEvent} for a definition of * a key typed event. * @param e The KeyEvent. */ public void keyTyped(KeyEvent e) {} } /** * CapsChosser is the 'old' Default chooser of jogl, because * on my system the Windows prefered mode is not Hardware accelerated.... */ static class CapsChooser implements GLCapabilitiesChooser { public CapsChooser() { } private static final boolean DEBUG = false; public int chooseCapabilities(GLCapabilities desired, GLCapabilities[] available) { return chooseCapabilities(desired, available, -1); } public int chooseCapabilities(GLCapabilities desired, GLCapabilities[] available, int windowSystemRecommendedChoice) { if (DEBUG) { for (int i = 0; i < available.length; i++) { System.err.println("Available " + i + ": " + available[i]); } } /* if (windowSystemRecommendedChoice >= 0 && windowSystemRecommendedChoice < available.length && available[windowSystemRecommendedChoice] != null) { if (DEBUG) { System.err.println("Choosing window system's recommended choice of " + windowSystemRecommendedChoice); System.err.println(available[windowSystemRecommendedChoice]); } return windowSystemRecommendedChoice; } */ // Create score array int[] scores = new int[available.length]; int NO_SCORE = -9999999; int DOUBLE_BUFFER_MISMATCH_PENALTY = 1000; int STENCIL_MISMATCH_PENALTY = 500; // Pseudo attempt to keep equal rank penalties scale-equivalent // (e.g., stencil mismatch is 3 * accum because there are 3 accum // components) int COLOR_MISMATCH_PENALTY_SCALE = 36; int DEPTH_MISMATCH_PENALTY_SCALE = 6; int ACCUM_MISMATCH_PENALTY_SCALE = 1; int STENCIL_MISMATCH_PENALTY_SCALE = 3; for (int i = 0; i < scores.length; i++) { scores[i] = NO_SCORE; } // Compute score for each for (int i = 0; i < scores.length; i++) { GLCapabilities cur = available[i]; if (cur == null) { continue; } if (desired.getStereo() != cur.getStereo()) { continue; } int score = 0; // Compute difference in color depth // (Note that this decides the direction of all other penalties) score += (COLOR_MISMATCH_PENALTY_SCALE * ((cur.getRedBits() + cur.getGreenBits() + cur.getBlueBits() + cur.getAlphaBits()) - (desired.getRedBits() + desired.getGreenBits() + desired.getBlueBits() + desired.getAlphaBits()))); // Compute difference in depth buffer depth score += (DEPTH_MISMATCH_PENALTY_SCALE * sign(score) * Math.abs(cur.getDepthBits() - desired.getDepthBits())); // Compute difference in accumulation buffer depth score += (ACCUM_MISMATCH_PENALTY_SCALE * sign(score) * Math.abs((cur.getAccumRedBits() + cur.getAccumGreenBits() + cur.getAccumBlueBits() + cur.getAccumAlphaBits()) - (desired.getAccumRedBits() + desired.getAccumGreenBits () + desired.getAccumBlueBits() + desired.getAccumAlphaBits()))); // Compute difference in stencil bits score += STENCIL_MISMATCH_PENALTY_SCALE * sign(score) * (cur.getStencilBits() - desired.getStencilBits()); if (cur.getDoubleBuffered() != desired.getDoubleBuffered()) { score += sign(score) * DOUBLE_BUFFER_MISMATCH_PENALTY; } if ((desired.getStencilBits() > 0) && (cur.getStencilBits() == 0)) { score += sign(score) * STENCIL_MISMATCH_PENALTY; } scores[i] = score; } // Now prefer hardware-accelerated visuals by pushing scores of // non-hardware-accelerated visuals out boolean gotHW = false; int maxAbsoluteHWScore = 0; for (int i = 0; i < scores.length; i++) { int score = scores[i]; if (score == NO_SCORE) { continue; } GLCapabilities cur = available[i]; if (cur.getHardwareAccelerated()) { int absScore = Math.abs(score); if (!gotHW || (absScore > maxAbsoluteHWScore)) { gotHW = true; maxAbsoluteHWScore = absScore; } } } if (gotHW) { for (int i = 0; i < scores.length; i++) { int score = scores[i]; if (score == NO_SCORE) { continue; } GLCapabilities cur = available[i]; if (!cur.getHardwareAccelerated()) { if (score <= 0) { score -= maxAbsoluteHWScore; } else if (score > 0) { score += maxAbsoluteHWScore; } scores[i] = score; } } } if (DEBUG) { System.err.print("Scores: ["); for (int i = 0; i < available.length; i++) { if (i > 0) { System.err.print(","); } System.err.print(" " + scores[i]); } System.err.println(" ]"); } // Ready to select. Choose score closest to 0. int scoreClosestToZero = NO_SCORE; int chosenIndex = -1; for (int i = 0; i < scores.length; i++) { int score = scores[i]; if (score == NO_SCORE) { continue; } // Don't substitute a positive score for a smaller negative score if ((scoreClosestToZero == NO_SCORE) || (Math.abs(score) < Math.abs(scoreClosestToZero) && ((sign(scoreClosestToZero) < 0) || (sign(score) > 0)))) { scoreClosestToZero = score; chosenIndex = i; } } if (chosenIndex < 0) { throw new GLException("Unable to select one of the provided GLCapabilities"); } if (DEBUG) { System.err.println("Chosen index: " + chosenIndex); System.err.println("Chosen capabilities:"); System.err.println(available[chosenIndex]); } return chosenIndex; } private static int sign(int score) { if (score < 0) { return -1; } return 1; } } /** Program's main entry point * @param args command line arguments. */ public static void main(String[] args) { Frame frame = new Frame("Lesson 3: Colors"); GLCanvas canvas = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities(), new CapsChooser()); canvas.addGLEventListener(new Renderer()); System.out.println("Version of jogl: " + Version.getVersion()); // switch off auto swap canvas.setAutoSwapBufferMode(false); frame.add(canvas); // frame.getContentPane().add(canvas); frame.setSize(640, 480); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); frame.show(); canvas.requestFocus(); } } ---- Additional Comments From andreas_k 2004-04-30 02:41:18 ---- Created an attachment Modified Lesson03.java to show redraw and swapBuffers() problem ---- Additional Comments From kbr 2004-04-30 15:03:21 ---- The context handling and optimization code in GLContext.invokeGL() was buggy. A restructuring and simplification has fixed this problem. Am waiting for confirmation that this fix also fixes issue 78. If it does, this issue will be closed as a duplicate of that one. Thanks for the self-contained test case. ---- Additional Comments From kbr 2004-05-05 23:51:22 ---- Thanks again for the self-contained test case. The submitter of issue 78 has confirmed that the fix fixes that issue as well so I'm closing this one as a duplicate of that. *** This issue has been marked as a duplicate of 78 *** --- Bug imported by sgothel@jausoft.com 2010-03-24 07:46 EDT --- This bug was previously known as _bug_ 80 at https://jogl.dev.java.net/bugs/show_bug.cgi?id=80 Imported an attachment (id=21) The original submitter of attachment 21 is unknown. Reassigning to the person who moved it here: sgothel@jausoft.com. 21 2004-04-30 02:41:00 +0200 2004-04-30 02:41:00 +0200 Modified Lesson03.java to show redraw and swapBuffers() problem Lesson03.java text/plain 11971 sgothel LyoNCiAqIExlc3NvbjAzLmphdmENCiAqDQogKiBDcmVhdGVkIG9uIEp1bHkgMTQsIDIwMDMsIDEy OjM1IFBNDQogKi8NCg0KaW1wb3J0IGphdmEuYXd0Lio7DQppbXBvcnQgamF2YS5hd3QuZXZlbnQu KjsNCmltcG9ydCBqYXZheC5zd2luZy4qOw0KDQppbXBvcnQgbmV0LmphdmEuZ2FtZXMuam9nbC4q Ow0KDQovKiogUG9ydCBvZiB0aGUgTmVIZSBPcGVuR0wgVHV0b3JpYWwgKExlc3NvbiAzOiBDb2xv cnMpDQogKiB0byBKYXZhIHVzaW5nIHRoZSBKb2dsIGludGVyZmFjZSB0byBPcGVuR0wuICBKb2ds IGNhbiBiZSBvYnRhaW5lZA0KICogYXQgaHR0cDovL2pvZ2wuZGV2LmphdmEubmV0Lw0KICoNCiAq IEBhdXRob3IgS2V2aW4gRHVsaW5nIChqYXR0aWVyQGhvdG1haWwuY29tKQ0KICovDQpwdWJsaWMg Y2xhc3MgTGVzc29uMDMNCnsNCiAgc3RhdGljIGNsYXNzIFJlbmRlcmVyDQogICAgaW1wbGVtZW50 cyBHTEV2ZW50TGlzdGVuZXIsDQogICAgICAgICAgICAgICBLZXlMaXN0ZW5lcg0KICB7DQogICAg LyoqIENhbGxlZCBieSB0aGUgZHJhd2FibGUgdG8gaW5pdGlhdGUgT3BlbkdMIHJlbmRlcmluZyBi eSB0aGUgY2xpZW50Lg0KICAgICAqIEFmdGVyIGFsbCBHTEV2ZW50TGlzdGVuZXJzIGhhdmUgYmVl biBub3RpZmllZCBvZiBhIGRpc3BsYXkgZXZlbnQsIHRoZSANCiAgICAgKiBkcmF3YWJsZSB3aWxs IHN3YXAgaXRzIGJ1ZmZlcnMgaWYgbmVjZXNzYXJ5Lg0KICAgICAqIEBwYXJhbSBnTERyYXdhYmxl IFRoZSBHTERyYXdhYmxlIG9iamVjdC4NCiAgICAgKi8gICAgDQogICAgcHVibGljIHZvaWQgZGlz cGxheShHTERyYXdhYmxlIGdMRHJhd2FibGUpDQogICAgew0KICAgICAgZmluYWwgR0wgZ2wgPSBn TERyYXdhYmxlLmdldEdMKCk7DQogICAgICBnbC5nbENsZWFyKEdMLkdMX0NPTE9SX0JVRkZFUl9C SVQgfCBHTC5HTF9ERVBUSF9CVUZGRVJfQklUKTsNCiAgICAgIGdsLmdsTG9hZElkZW50aXR5KCk7 DQogICAgICBnbC5nbFRyYW5zbGF0ZWYoLTEuNWYsIDAuMGYsIC02LjBmKTsNCiAgICAgIGdsLmds QmVnaW4oR0wuR0xfVFJJQU5HTEVTKTsJCSAgICAvLyBEcmF3aW5nIFVzaW5nIFRyaWFuZ2xlcw0K ICAgICAgICBnbC5nbENvbG9yM2YoMS4wZiwgMC4wZiwgMC4wZik7ICAgLy8gU2V0IHRoZSBjdXJy ZW50IGRyYXdpbmcgY29sb3IgdG8gcmVkDQogICAgICAgIGdsLmdsVmVydGV4M2YoIDAuMGYsIDEu MGYsIDAuMGYpOwkvLyBUb3ANCiAgICAgICAgZ2wuZ2xDb2xvcjNmKDAuMGYsIDEuMGYsIDAuMGYp OyAgIC8vIFNldCB0aGUgY3VycmVudCBkcmF3aW5nIGNvbG9yIHRvIGdyZWVuDQogICAgICAgIGds LmdsVmVydGV4M2YoLTEuMGYsLTEuMGYsIDAuMGYpOwkvLyBCb3R0b20gTGVmdA0KICAgICAgICBn bC5nbENvbG9yM2YoMC4wZiwgMC4wZiwgMS4wZik7ICAgLy8gU2V0IHRoZSBjdXJyZW50IGRyYXdp bmcgY29sb3IgdG8gYmx1ZQ0KICAgICAgICBnbC5nbFZlcnRleDNmKCAxLjBmLC0xLjBmLCAwLjBm KTsJLy8gQm90dG9tIFJpZ2h0DQogICAgICBnbC5nbEVuZCgpOwkJCQkvLyBGaW5pc2hlZCBEcmF3 aW5nIFRoZSBUcmlhbmdsZQ0KICAgICAgZ2wuZ2xUcmFuc2xhdGVmKDMuMGYsIDAuMGYsIDAuMGYp Ow0KICAgICAgZ2wuZ2xCZWdpbihHTC5HTF9RVUFEUyk7ICAgICAgICAgICAJLy8gRHJhdyBBIFF1 YWQNCiAgICAgICAgZ2wuZ2xDb2xvcjNmKDAuNWYsIDAuNWYsIDEuMGYpOyAgIC8vIFNldCB0aGUg Y3VycmVudCBkcmF3aW5nIGNvbG9yIHRvIGxpZ2h0IGJsdWUNCiAgICAgICAgZ2wuZ2xWZXJ0ZXgz ZigtMS4wZiwgMS4wZiwgMC4wZik7CS8vIFRvcCBMZWZ0DQogICAgICAgIGdsLmdsVmVydGV4M2Yo IDEuMGYsIDEuMGYsIDAuMGYpOwkvLyBUb3AgUmlnaHQNCiAgICAgICAgZ2wuZ2xWZXJ0ZXgzZigg MS4wZiwtMS4wZiwgMC4wZik7CS8vIEJvdHRvbSBSaWdodA0KICAgICAgICBnbC5nbFZlcnRleDNm KC0xLjBmLC0xLjBmLCAwLjBmKTsJLy8gQm90dG9tIExlZnQNCiAgICAgIGdsLmdsRW5kKCk7CQkJ CS8vIERvbmUgRHJhd2luZyBUaGUgUXVhZA0KICAgICAgZ2wuZ2xGbHVzaCgpOw0KICAgICAgDQog ICAgICBnTERyYXdhYmxlLnN3YXBCdWZmZXJzKCk7DQogICAgfQ0KICAgIA0KICAgIA0KCSAvKiog Q2FsbGVkIHdoZW4gdGhlIGRpc3BsYXkgbW9kZSBoYXMgYmVlbiBjaGFuZ2VkLiAgPEI+ISEgQ1VS UkVOVExZIFVOSU1QTEVNRU5URUQgSU4gSk9HTCAhITwvQj4NCiAgICAqIEBwYXJhbSBnTERyYXdh YmxlIFRoZSBHTERyYXdhYmxlIG9iamVjdC4NCiAgICAqIEBwYXJhbSBtb2RlQ2hhbmdlZCBJbmRp Y2F0ZXMgaWYgdGhlIHZpZGVvIG1vZGUgaGFzIGNoYW5nZWQuDQogICAgKiBAcGFyYW0gZGV2aWNl Q2hhbmdlZCBJbmRpY2F0ZXMgaWYgdGhlIHZpZGVvIGRldmljZSBoYXMgY2hhbmdlZC4NCiAgICAq Lw0KCSBwdWJsaWMgdm9pZCBkaXNwbGF5Q2hhbmdlZChHTERyYXdhYmxlIGdMRHJhd2FibGUsIGJv b2xlYW4gbW9kZUNoYW5nZWQsIGJvb2xlYW4gZGV2aWNlQ2hhbmdlZCkNCiAgICB7DQogICAgfQ0K ICAgIA0KCSAvKiogQ2FsbGVkIGJ5IHRoZSBkcmF3YWJsZSBpbW1lZGlhdGVseSBhZnRlciB0aGUg T3BlbkdMIGNvbnRleHQgaXMgDQogICAgKiBpbml0aWFsaXplZCBmb3IgdGhlIGZpcnN0IHRpbWUu IENhbiBiZSB1c2VkIHRvIHBlcmZvcm0gb25lLXRpbWUgT3BlbkdMIA0KICAgICogaW5pdGlhbGl6 YXRpb24gc3VjaCBhcyBzZXR1cCBvZiBsaWdodHMgYW5kIGRpc3BsYXkgbGlzdHMuDQogICAgKiBA cGFyYW0gZ0xEcmF3YWJsZSBUaGUgR0xEcmF3YWJsZSBvYmplY3QuDQogICAgKi8NCiAgIHB1Ymxp YyB2b2lkIGluaXQoR0xEcmF3YWJsZSBnTERyYXdhYmxlKQ0KICAgIHsNCiAgICAgIGZpbmFsIEdM IGdsID0gZ0xEcmF3YWJsZS5nZXRHTCgpOw0KICAgICAgZ2wuZ2xDbGVhckNvbG9yKDAuMGYsIDAu MGYsIDAuMGYsIDAuMGYpOw0KICAgICAgZ2wuZ2xTaGFkZU1vZGVsKEdMLkdMX1NNT09USCk7IC8v IHRyeSBzZXR0aW5nIHRoaXMgdG8gR0xfRkxBVCBhbmQgc2VlIHdoYXQgaGFwcGVucy4NCiAgICAg IGdMRHJhd2FibGUuYWRkS2V5TGlzdGVuZXIodGhpcyk7DQogICAgfQ0KICAgIA0KICANCgkgLyoq IENhbGxlZCBieSB0aGUgZHJhd2FibGUgZHVyaW5nIHRoZSBmaXJzdCByZXBhaW50IGFmdGVyIHRo ZSBjb21wb25lbnQgaGFzIA0KICAgICogYmVlbiByZXNpemVkLiBUaGUgY2xpZW50IGNhbiB1cGRh dGUgdGhlIHZpZXdwb3J0IGFuZCB2aWV3IHZvbHVtZSBvZiB0aGUgDQogICAgKiB3aW5kb3cgYXBw cm9wcmlhdGVseSwgZm9yIGV4YW1wbGUgYnkgYSBjYWxsIHRvIA0KICAgICogR0wuZ2xWaWV3cG9y dChpbnQsIGludCwgaW50LCBpbnQpOyBub3RlIHRoYXQgZm9yIGNvbnZlbmllbmNlIHRoZSBjb21w b25lbnQNCiAgICAqIGhhcyBhbHJlYWR5IGNhbGxlZCBHTC5nbFZpZXdwb3J0KGludCwgaW50LCBp bnQsIGludCkoeCwgeSwgd2lkdGgsIGhlaWdodCkNCiAgICAqIHdoZW4gdGhpcyBtZXRob2QgaXMg Y2FsbGVkLCBzbyB0aGUgY2xpZW50IG1heSBub3QgaGF2ZSB0byBkbyBhbnl0aGluZyBpbg0KICAg ICogdGhpcyBtZXRob2QuDQogICAgKiBAcGFyYW0gZ0xEcmF3YWJsZSBUaGUgR0xEcmF3YWJsZSBv YmplY3QuDQogICAgKiBAcGFyYW0geCBUaGUgWCBDb29yZGluYXRlIG9mIHRoZSB2aWV3cG9ydCBy ZWN0YW5nbGUuDQogICAgKiBAcGFyYW0geSBUaGUgWSBjb29yZGluYXRlIG9mIHRoZSB2aWV3cG9y dCByZWN0YW5ibGUuDQogICAgKiBAcGFyYW0gd2lkdGggVGhlIG5ldyB3aWR0aCBvZiB0aGUgd2lu ZG93Lg0KICAgICogQHBhcmFtIGhlaWdodCBUaGUgbmV3IGhlaWdodCBvZiB0aGUgd2luZG93Lg0K ICAgICovDQoJIHB1YmxpYyB2b2lkIHJlc2hhcGUoR0xEcmF3YWJsZSBnTERyYXdhYmxlLCBpbnQg eCwgaW50IHksIGludCB3aWR0aCwgaW50IGhlaWdodCkNCiAgICB7DQogICAgICBmaW5hbCBHTCBn bCA9IGdMRHJhd2FibGUuZ2V0R0woKTsNCiAgICAgIGZpbmFsIEdMVSBnbHUgPSBnTERyYXdhYmxl LmdldEdMVSgpOw0KDQogICAgICBpZiAoaGVpZ2h0IDw9IDApIC8vIGF2b2lkIGEgZGl2aWRlIGJ5 IHplcm8gZXJyb3IhDQogICAgICAgIGhlaWdodCA9IDE7DQogICAgICBmaW5hbCBmbG9hdCBoID0g KGZsb2F0KXdpZHRoIC8gKGZsb2F0KWhlaWdodDsNCiAgICAgIGdsLmdsVmlld3BvcnQoMCwgMCwg d2lkdGgsIGhlaWdodCk7DQogICAgICBnbC5nbE1hdHJpeE1vZGUoR0wuR0xfUFJPSkVDVElPTik7 DQogICAgICBnbC5nbExvYWRJZGVudGl0eSgpOw0KICAgICAgZ2x1LmdsdVBlcnNwZWN0aXZlKDQ1 LjBmLCBoLCAxLjAsIDIwLjApOw0KICAgICAgZ2wuZ2xNYXRyaXhNb2RlKEdMLkdMX01PREVMVklF Vyk7DQogICAgICBnbC5nbExvYWRJZGVudGl0eSgpOw0KICAgIH0NCg0KICAgIC8qKiBJbnZva2Vk IHdoZW4gYSBrZXkgaGFzIGJlZW4gcHJlc3NlZC4NCiAgICAgKiBTZWUgdGhlIGNsYXNzIGRlc2Ny aXB0aW9uIGZvciB7QGxpbmsgS2V5RXZlbnR9IGZvciBhIGRlZmluaXRpb24gb2YNCiAgICAgKiBh IGtleSBwcmVzc2VkIGV2ZW50Lg0KICAgICAqIEBwYXJhbSBlIFRoZSBLZXlFdmVudC4NCiAgICAg Ki8NCiAgICBwdWJsaWMgdm9pZCBrZXlQcmVzc2VkKEtleUV2ZW50IGUpDQogICAgew0KICAgICAg aWYgKGUuZ2V0S2V5Q29kZSgpID09IEtleUV2ZW50LlZLX0VTQ0FQRSkNCiAgICAgICAgU3lzdGVt LmV4aXQoMCk7DQogICAgfQ0KICAgIA0KICAgIC8qKiBJbnZva2VkIHdoZW4gYSBrZXkgaGFzIGJl ZW4gcmVsZWFzZWQuDQogICAgICogU2VlIHRoZSBjbGFzcyBkZXNjcmlwdGlvbiBmb3Ige0BsaW5r IEtleUV2ZW50fSBmb3IgYSBkZWZpbml0aW9uIG9mDQogICAgICogYSBrZXkgcmVsZWFzZWQgZXZl bnQuDQogICAgICogQHBhcmFtIGUgVGhlIEtleUV2ZW50Lg0KICAgICAqLw0KICAgIHB1YmxpYyB2 b2lkIGtleVJlbGVhc2VkKEtleUV2ZW50IGUpIHt9DQogICAgDQogICAgLyoqIEludm9rZWQgd2hl biBhIGtleSBoYXMgYmVlbiB0eXBlZC4NCiAgICAgKiBTZWUgdGhlIGNsYXNzIGRlc2NyaXB0aW9u IGZvciB7QGxpbmsgS2V5RXZlbnR9IGZvciBhIGRlZmluaXRpb24gb2YNCiAgICAgKiBhIGtleSB0 eXBlZCBldmVudC4NCiAgICAgKiBAcGFyYW0gZSBUaGUgS2V5RXZlbnQuDQogICAgICovDQogICAg cHVibGljIHZvaWQga2V5VHlwZWQoS2V5RXZlbnQgZSkge30NCiAgfQ0KLyoqDQogICogQ2Fwc0No b3NzZXIgaXMgdGhlICdvbGQnIERlZmF1bHQgY2hvb3NlciBvZiBqb2dsLCBiZWNhdXNlDQogICog b24gbXkgc3lzdGVtIHRoZSBXaW5kb3dzIHByZWZlcmVkIG1vZGUgaXMgbm90IEhhcmR3YXJlIGFj Y2VsZXJhdGVkLi4uLg0KICAqLw0KICANCnN0YXRpYyBjbGFzcyBDYXBzQ2hvb3NlciBpbXBsZW1l bnRzIEdMQ2FwYWJpbGl0aWVzQ2hvb3NlciB7DQogIHB1YmxpYyBDYXBzQ2hvb3NlcigpIHsNCiAg fQ0KICBwcml2YXRlIHN0YXRpYyBmaW5hbCBib29sZWFuIERFQlVHID0gZmFsc2U7DQoNCiAgcHVi bGljIGludCBjaG9vc2VDYXBhYmlsaXRpZXMoR0xDYXBhYmlsaXRpZXMgZGVzaXJlZCwNCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xDYXBhYmlsaXRpZXNbXSBhdmFpbGFibGUpIHsN CiAgICByZXR1cm4gY2hvb3NlQ2FwYWJpbGl0aWVzKGRlc2lyZWQsIGF2YWlsYWJsZSwgLTEpOw0K ICB9DQoNCiAgcHVibGljIGludCBjaG9vc2VDYXBhYmlsaXRpZXMoR0xDYXBhYmlsaXRpZXMgZGVz aXJlZCwNCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0xDYXBhYmlsaXRpZXNbXSBh dmFpbGFibGUsDQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCB3aW5kb3dTeXN0 ZW1SZWNvbW1lbmRlZENob2ljZSkgew0KDQogICAgaWYgKERFQlVHKSB7DQogICAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGF2YWlsYWJsZS5sZW5ndGg7IGkrKykgew0KICAgICAgICBTeXN0ZW0uZXJy LnByaW50bG4oIkF2YWlsYWJsZSAiICsgaSArICI6ICIgKyBhdmFpbGFibGVbaV0pOw0KICAgICAg fQ0KICAgIH0NCg0KICAgIC8qDQogICAgaWYgKHdpbmRvd1N5c3RlbVJlY29tbWVuZGVkQ2hvaWNl ID49IDAgJiYNCiAgICAgICAgd2luZG93U3lzdGVtUmVjb21tZW5kZWRDaG9pY2UgPCBhdmFpbGFi bGUubGVuZ3RoICYmDQogICAgICAgIGF2YWlsYWJsZVt3aW5kb3dTeXN0ZW1SZWNvbW1lbmRlZENo b2ljZV0gIT0gbnVsbCkgew0KICAgICAgaWYgKERFQlVHKSB7DQogICAgICAgIFN5c3RlbS5lcnIu cHJpbnRsbigiQ2hvb3Npbmcgd2luZG93IHN5c3RlbSdzIHJlY29tbWVuZGVkIGNob2ljZSBvZiAi ICsgd2luZG93U3lzdGVtUmVjb21tZW5kZWRDaG9pY2UpOw0KICAgICAgICBTeXN0ZW0uZXJyLnBy aW50bG4oYXZhaWxhYmxlW3dpbmRvd1N5c3RlbVJlY29tbWVuZGVkQ2hvaWNlXSk7DQogICAgICB9 DQogICAgICByZXR1cm4gd2luZG93U3lzdGVtUmVjb21tZW5kZWRDaG9pY2U7DQogICAgfQ0KICAg ICovDQogICAgLy8gQ3JlYXRlIHNjb3JlIGFycmF5DQogICAgaW50W10gc2NvcmVzID0gbmV3IGlu dFthdmFpbGFibGUubGVuZ3RoXTsNCiAgICBpbnQgTk9fU0NPUkUgPSAtOTk5OTk5OTsNCiAgICBp bnQgRE9VQkxFX0JVRkZFUl9NSVNNQVRDSF9QRU5BTFRZID0gMTAwMDsNCiAgICBpbnQgU1RFTkNJ TF9NSVNNQVRDSF9QRU5BTFRZID0gNTAwOw0KICAgIC8vIFBzZXVkbyBhdHRlbXB0IHRvIGtlZXAg ZXF1YWwgcmFuayBwZW5hbHRpZXMgc2NhbGUtZXF1aXZhbGVudA0KICAgIC8vIChlLmcuLCBzdGVu Y2lsIG1pc21hdGNoIGlzIDMgKiBhY2N1bSBiZWNhdXNlIHRoZXJlIGFyZSAzIGFjY3VtDQogICAg Ly8gY29tcG9uZW50cykNCiAgICBpbnQgQ09MT1JfTUlTTUFUQ0hfUEVOQUxUWV9TQ0FMRSAgICAg PSAzNjsNCiAgICBpbnQgREVQVEhfTUlTTUFUQ0hfUEVOQUxUWV9TQ0FMRSAgICAgPSA2Ow0KICAg IGludCBBQ0NVTV9NSVNNQVRDSF9QRU5BTFRZX1NDQUxFICAgICA9IDE7DQogICAgaW50IFNURU5D SUxfTUlTTUFUQ0hfUEVOQUxUWV9TQ0FMRSAgID0gMzsNCiAgICBmb3IgKGludCBpID0gMDsgaSA8 IHNjb3Jlcy5sZW5ndGg7IGkrKykgew0KICAgICAgc2NvcmVzW2ldID0gTk9fU0NPUkU7DQogICAg fQ0KICAgIC8vIENvbXB1dGUgc2NvcmUgZm9yIGVhY2gNCiAgICBmb3IgKGludCBpID0gMDsgaSA8 IHNjb3Jlcy5sZW5ndGg7IGkrKykgew0KICAgICAgR0xDYXBhYmlsaXRpZXMgY3VyID0gYXZhaWxh YmxlW2ldOw0KICAgICAgaWYgKGN1ciA9PSBudWxsKSB7DQogICAgICAgIGNvbnRpbnVlOw0KICAg ICAgfQ0KICAgICAgaWYgKGRlc2lyZWQuZ2V0U3RlcmVvKCkgIT0gY3VyLmdldFN0ZXJlbygpKSB7 DQogICAgICAgIGNvbnRpbnVlOw0KICAgICAgfQ0KICAgICAgaW50IHNjb3JlID0gMDsNCiAgICAg IC8vIENvbXB1dGUgZGlmZmVyZW5jZSBpbiBjb2xvciBkZXB0aA0KICAgICAgLy8gKE5vdGUgdGhh dCB0aGlzIGRlY2lkZXMgdGhlIGRpcmVjdGlvbiBvZiBhbGwgb3RoZXIgcGVuYWx0aWVzKQ0KICAg ICAgc2NvcmUgKz0gKENPTE9SX01JU01BVENIX1BFTkFMVFlfU0NBTEUgKg0KICAgICAgICAgICAg ICAgICgoY3VyLmdldFJlZEJpdHMoKSArIGN1ci5nZXRHcmVlbkJpdHMoKSArIGN1ci5nZXRCbHVl Qml0cygpICsgY3VyLmdldEFscGhhQml0cygpKSAtDQogICAgICAgICAgICAgICAgIChkZXNpcmVk LmdldFJlZEJpdHMoKSArIGRlc2lyZWQuZ2V0R3JlZW5CaXRzKCkgKyBkZXNpcmVkLmdldEJsdWVC aXRzKCkgKyBkZXNpcmVkLmdldEFscGhhQml0cygpKSkpOw0KICAgICAgLy8gQ29tcHV0ZSBkaWZm ZXJlbmNlIGluIGRlcHRoIGJ1ZmZlciBkZXB0aA0KICAgICAgc2NvcmUgKz0gKERFUFRIX01JU01B VENIX1BFTkFMVFlfU0NBTEUgKiBzaWduKHNjb3JlKSAqDQogICAgICAgICAgICAgICAgTWF0aC5h YnMoY3VyLmdldERlcHRoQml0cygpIC0gZGVzaXJlZC5nZXREZXB0aEJpdHMoKSkpOw0KICAgICAg Ly8gQ29tcHV0ZSBkaWZmZXJlbmNlIGluIGFjY3VtdWxhdGlvbiBidWZmZXIgZGVwdGgNCiAgICAg IHNjb3JlICs9IChBQ0NVTV9NSVNNQVRDSF9QRU5BTFRZX1NDQUxFICogc2lnbihzY29yZSkgKg0K ICAgICAgICAgICAgICAgIE1hdGguYWJzKChjdXIuZ2V0QWNjdW1SZWRCaXRzKCkgKyBjdXIuZ2V0 QWNjdW1HcmVlbkJpdHMoKSArIGN1ci5nZXRBY2N1bUJsdWVCaXRzKCkgKyBjdXIuZ2V0QWNjdW1B bHBoYUJpdHMoKSkgLQ0KICAgICAgICAgICAgICAgICAgICAgICAgIChkZXNpcmVkLmdldEFjY3Vt UmVkQml0cygpICsgZGVzaXJlZC5nZXRBY2N1bUdyZWVuQml0cygpICsgZGVzaXJlZC5nZXRBY2N1 bUJsdWVCaXRzKCkgKyBkZXNpcmVkLmdldEFjY3VtQWxwaGFCaXRzKCkpKSk7DQogICAgICAvLyBD b21wdXRlIGRpZmZlcmVuY2UgaW4gc3RlbmNpbCBiaXRzDQogICAgICBzY29yZSArPSBTVEVOQ0lM X01JU01BVENIX1BFTkFMVFlfU0NBTEUgKiBzaWduKHNjb3JlKSAqIChjdXIuZ2V0U3RlbmNpbEJp dHMoKSAtIGRlc2lyZWQuZ2V0U3RlbmNpbEJpdHMoKSk7DQogICAgICBpZiAoY3VyLmdldERvdWJs ZUJ1ZmZlcmVkKCkgIT0gZGVzaXJlZC5nZXREb3VibGVCdWZmZXJlZCgpKSB7DQogICAgICAgIHNj b3JlICs9IHNpZ24oc2NvcmUpICogRE9VQkxFX0JVRkZFUl9NSVNNQVRDSF9QRU5BTFRZOw0KICAg ICAgfQ0KICAgICAgaWYgKChkZXNpcmVkLmdldFN0ZW5jaWxCaXRzKCkgPiAwKSAmJiAoY3VyLmdl dFN0ZW5jaWxCaXRzKCkgPT0gMCkpIHsNCiAgICAgICAgc2NvcmUgKz0gc2lnbihzY29yZSkgKiBT VEVOQ0lMX01JU01BVENIX1BFTkFMVFk7DQogICAgICB9DQogICAgICBzY29yZXNbaV0gPSBzY29y ZTsNCiAgICB9DQogICAgLy8gTm93IHByZWZlciBoYXJkd2FyZS1hY2NlbGVyYXRlZCB2aXN1YWxz IGJ5IHB1c2hpbmcgc2NvcmVzIG9mDQogICAgLy8gbm9uLWhhcmR3YXJlLWFjY2VsZXJhdGVkIHZp c3VhbHMgb3V0DQogICAgYm9vbGVhbiBnb3RIVyA9IGZhbHNlOw0KICAgIGludCBtYXhBYnNvbHV0 ZUhXU2NvcmUgPSAwOw0KICAgIGZvciAoaW50IGkgPSAwOyBpIDwgc2NvcmVzLmxlbmd0aDsgaSsr KSB7DQogICAgICBpbnQgc2NvcmUgPSBzY29yZXNbaV07DQogICAgICBpZiAoc2NvcmUgPT0gTk9f U0NPUkUpIHsNCiAgICAgICAgY29udGludWU7DQogICAgICB9DQogICAgICBHTENhcGFiaWxpdGll cyBjdXIgPSBhdmFpbGFibGVbaV07DQogICAgICBpZiAoY3VyLmdldEhhcmR3YXJlQWNjZWxlcmF0 ZWQoKSkgew0KICAgICAgICBpbnQgYWJzU2NvcmUgPSBNYXRoLmFicyhzY29yZSk7DQogICAgICAg IGlmICghZ290SFcgfHwNCiAgICAgICAgICAgIChhYnNTY29yZSA+IG1heEFic29sdXRlSFdTY29y ZSkpIHsNCiAgICAgICAgICBnb3RIVyA9IHRydWU7DQogICAgICAgICAgbWF4QWJzb2x1dGVIV1Nj b3JlID0gYWJzU2NvcmU7DQogICAgICAgIH0NCiAgICAgIH0NCiAgICB9DQogICAgaWYgKGdvdEhX KSB7DQogICAgICBmb3IgKGludCBpID0gMDsgaSA8IHNjb3Jlcy5sZW5ndGg7IGkrKykgew0KICAg ICAgICBpbnQgc2NvcmUgPSBzY29yZXNbaV07DQogICAgICAgIGlmIChzY29yZSA9PSBOT19TQ09S RSkgew0KICAgICAgICAgIGNvbnRpbnVlOw0KICAgICAgICB9DQogICAgICAgIEdMQ2FwYWJpbGl0 aWVzIGN1ciA9IGF2YWlsYWJsZVtpXTsNCiAgICAgICAgaWYgKCFjdXIuZ2V0SGFyZHdhcmVBY2Nl bGVyYXRlZCgpKSB7DQogICAgICAgICAgaWYgKHNjb3JlIDw9IDApIHsNCiAgICAgICAgICAgIHNj b3JlIC09IG1heEFic29sdXRlSFdTY29yZTsNCiAgICAgICAgICB9IGVsc2UgaWYgKHNjb3JlID4g MCkgew0KICAgICAgICAgICAgc2NvcmUgKz0gbWF4QWJzb2x1dGVIV1Njb3JlOw0KICAgICAgICAg IH0NCiAgICAgICAgICBzY29yZXNbaV0gPSBzY29yZTsNCiAgICAgICAgfQ0KICAgICAgfQ0KICAg IH0NCg0KICAgIGlmIChERUJVRykgew0KICAgICAgU3lzdGVtLmVyci5wcmludCgiU2NvcmVzOiBb Iik7DQogICAgICBmb3IgKGludCBpID0gMDsgaSA8IGF2YWlsYWJsZS5sZW5ndGg7IGkrKykgew0K ICAgICAgICBpZiAoaSA+IDApIHsNCiAgICAgICAgICBTeXN0ZW0uZXJyLnByaW50KCIsIik7DQog ICAgICAgIH0NCiAgICAgICAgU3lzdGVtLmVyci5wcmludCgiICIgKyBzY29yZXNbaV0pOw0KICAg ICAgfQ0KICAgICAgU3lzdGVtLmVyci5wcmludGxuKCIgXSIpOw0KICAgIH0NCg0KICAgIC8vIFJl YWR5IHRvIHNlbGVjdC4gQ2hvb3NlIHNjb3JlIGNsb3Nlc3QgdG8gMC4NCiAgICBpbnQgc2NvcmVD bG9zZXN0VG9aZXJvID0gTk9fU0NPUkU7DQogICAgaW50IGNob3NlbkluZGV4ID0gLTE7DQogICAg Zm9yIChpbnQgaSA9IDA7IGkgPCBzY29yZXMubGVuZ3RoOyBpKyspIHsNCiAgICAgIGludCBzY29y ZSA9IHNjb3Jlc1tpXTsNCiAgICAgIGlmIChzY29yZSA9PSBOT19TQ09SRSkgew0KICAgICAgICBj b250aW51ZTsNCiAgICAgIH0NCiAgICAgIC8vIERvbid0IHN1YnN0aXR1dGUgYSBwb3NpdGl2ZSBz Y29yZSBmb3IgYSBzbWFsbGVyIG5lZ2F0aXZlIHNjb3JlDQogICAgICBpZiAoKHNjb3JlQ2xvc2Vz dFRvWmVybyA9PSBOT19TQ09SRSkgfHwNCiAgICAgICAgICAoTWF0aC5hYnMoc2NvcmUpIDwgTWF0 aC5hYnMoc2NvcmVDbG9zZXN0VG9aZXJvKSAmJg0KICAgICAgICAgICAoKHNpZ24oc2NvcmVDbG9z ZXN0VG9aZXJvKSA8IDApIHx8IChzaWduKHNjb3JlKSA+IDApKSkpIHsNCiAgICAgICAgc2NvcmVD bG9zZXN0VG9aZXJvID0gc2NvcmU7DQogICAgICAgIGNob3NlbkluZGV4ID0gaTsNCiAgICAgIH0N CiAgICB9DQogICAgaWYgKGNob3NlbkluZGV4IDwgMCkgew0KICAgICAgdGhyb3cgbmV3IEdMRXhj ZXB0aW9uKCJVbmFibGUgdG8gc2VsZWN0IG9uZSBvZiB0aGUgcHJvdmlkZWQgR0xDYXBhYmlsaXRp ZXMiKTsNCiAgICB9DQogICAgaWYgKERFQlVHKSB7DQogICAgICBTeXN0ZW0uZXJyLnByaW50bG4o IkNob3NlbiBpbmRleDogIiArIGNob3NlbkluZGV4KTsNCiAgICAgIFN5c3RlbS5lcnIucHJpbnRs bigiQ2hvc2VuIGNhcGFiaWxpdGllczoiKTsNCiAgICAgIFN5c3RlbS5lcnIucHJpbnRsbihhdmFp bGFibGVbY2hvc2VuSW5kZXhdKTsNCiAgICB9DQoNCiAgICByZXR1cm4gY2hvc2VuSW5kZXg7DQog IH0NCg0KICBwcml2YXRlIHN0YXRpYyBpbnQgc2lnbihpbnQgc2NvcmUpIHsNCiAgICBpZiAoc2Nv cmUgPCAwKSB7DQogICAgICByZXR1cm4gLTE7DQogICAgfQ0KICAgIHJldHVybiAxOw0KICB9DQoN Cn0NCg0KICAvKiogUHJvZ3JhbSdzIG1haW4gZW50cnkgcG9pbnQNCiAgICogQHBhcmFtIGFyZ3Mg Y29tbWFuZCBsaW5lIGFyZ3VtZW50cy4NCiAgICovDQogIHB1YmxpYyBzdGF0aWMgdm9pZCBtYWlu KFN0cmluZ1tdIGFyZ3MpDQogIHsNCiAgICBGcmFtZSBmcmFtZSA9IG5ldyBGcmFtZSgiTGVzc29u IDM6IENvbG9ycyIpOw0KICAgIEdMQ2FudmFzIGNhbnZhcyA9IEdMRHJhd2FibGVGYWN0b3J5Lmdl dEZhY3RvcnkoKS5jcmVhdGVHTENhbnZhcyhuZXcgR0xDYXBhYmlsaXRpZXMoKSwgbmV3IENhcHND aG9vc2VyKCkpOw0KICAgIGNhbnZhcy5hZGRHTEV2ZW50TGlzdGVuZXIobmV3IFJlbmRlcmVyKCkp Ow0KICAgIFN5c3RlbS5vdXQucHJpbnRsbigiVmVyc2lvbiBvZiBqb2dsOiAiICsgVmVyc2lvbi5n ZXRWZXJzaW9uKCkpOw0KICAgIA0KICAgIC8vIHN3aXRjaCBvZmYgYXV0byBzd2FwDQogICAgY2Fu dmFzLnNldEF1dG9Td2FwQnVmZmVyTW9kZShmYWxzZSk7DQogICAgZnJhbWUuYWRkKGNhbnZhcyk7 DQovLyAgICBmcmFtZS5nZXRDb250ZW50UGFuZSgpLmFkZChjYW52YXMpOw0KICAgIGZyYW1lLnNl dFNpemUoNjQwLCA0ODApOw0KICAgIGZyYW1lLmFkZFdpbmRvd0xpc3RlbmVyKG5ldyBXaW5kb3dB ZGFwdGVyKCkNCiAgICB7DQogICAgICBwdWJsaWMgdm9pZCB3aW5kb3dDbG9zaW5nKFdpbmRvd0V2 ZW50IGUpDQogICAgICB7DQogICAgICAgIFN5c3RlbS5leGl0KDApOw0KICAgICAgfQ0KICAgIH0p Ow0KICAgIGZyYW1lLnNob3coKTsNCiAgICBjYW52YXMucmVxdWVzdEZvY3VzKCk7DQogIH0NCn0N Cg==