Add missing @Override annotations (#617)

vtm-web/src/org/oscim/gdx/client/GdxGL.java

@@ -73,38 +73,47 @@ public class GdxGL extends GwtGL20 implements GL {
         }
     }
 
+    @Override
     public void activeTexture(int texture) {
         glActiveTexture(texture);
     }
 
+    @Override
     public void bindTexture(int target, int texture) {
         glBindTexture(target, texture);
     }
 
+    @Override
     public void blendFunc(int sfactor, int dfactor) {
         glBlendFunc(sfactor, dfactor);
     }
 
+    @Override
     public void clear(int mask) {
         glClear(mask);
     }
 
+    @Override
     public void clearColor(float red, float green, float blue, float alpha) {
         glClearColor(red, green, blue, alpha);
     }
 
+    @Override
     public void clearDepthf(float depth) {
         glClearDepthf(depth);
     }
 
+    @Override
     public void clearStencil(int s) {
         glClearStencil(s);
     }
 
+    @Override
     public void colorMask(boolean red, boolean green, boolean blue, boolean alpha) {
         glColorMask(red, green, blue, alpha);
     }
 
+    @Override
     public void compressedTexImage2D(int target, int level, int internalformat, int width,
                                      int height, int border,
                                      int imageSize, Buffer data) {
@@ -119,6 +128,7 @@ public class GdxGL extends GwtGL20 implements GL {
                 data);
     }
 
+    @Override
     public void compressedTexSubImage2D(int target, int level, int xoffset, int yoffset,
                                         int width, int height, int format,
                                         int imageSize, Buffer data) {
@@ -133,117 +143,145 @@ public class GdxGL extends GwtGL20 implements GL {
                 data);
     }
 
+    @Override
     public void copyTexImage2D(int target, int level, int internalformat, int x, int y,
                                int width, int height, int border) {
         glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
     }
 
+    @Override
     public void copyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
                                   int width, int height) {
         glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
     }
 
+    @Override
     public void cullFace(int mode) {
         glCullFace(mode);
     }
 
+    @Override
     public void deleteTextures(int n, IntBuffer textures) {
         glDeleteTextures(n, textures);
     }
 
+    @Override
     public void depthFunc(int func) {
         glDepthFunc(func);
     }
 
+    @Override
     public void depthMask(boolean flag) {
         glDepthMask(flag);
     }
 
+    @Override
     public void depthRangef(float zNear, float zFar) {
         glDepthRangef(zNear, zFar);
     }
 
+    @Override
     public void disable(int cap) {
         glDisable(cap);
     }
 
+    @Override
     public void drawArrays(int mode, int first, int count) {
         glDrawArrays(mode, first, count);
     }
 
+    @Override
     public void drawElements(int mode, int count, int type, Buffer indices) {
         glDrawElements(mode, count, type, indices);
     }
 
+    @Override
     public void enable(int cap) {
         glEnable(cap);
     }
 
+    @Override
     public void finish() {
         glFinish();
     }
 
+    @Override
     public void flush() {
         glFlush();
     }
 
+    @Override
     public void frontFace(int mode) {
         glFrontFace(mode);
     }
 
+    @Override
     public void genTextures(int n, IntBuffer textures) {
         glGenTextures(n, textures);
     }
 
+    @Override
     public int getError() {
         return glGetError();
     }
 
+    @Override
     public void getIntegerv(int pname, IntBuffer params) {
         glGetIntegerv(pname, params);
     }
 
+    @Override
     public String getString(int name) {
         return glGetString(name);
     }
 
+    @Override
     public void hint(int target, int mode) {
         glHint(target, mode);
     }
 
+    @Override
     public void lineWidth(float width) {
         glLineWidth(width);
     }
 
+    @Override
     public void pixelStorei(int pname, int param) {
         glPixelStorei(pname, param);
     }
 
+    @Override
     public void polygonOffset(float factor, float units) {
         glPolygonOffset(factor, units);
     }
 
+    @Override
     public void readPixels(int x, int y, int width, int height, int format, int type,
                            Buffer pixels) {
         glReadPixels(x, y, width, height, format, type, pixels);
     }
 
+    @Override
     public void scissor(int x, int y, int width, int height) {
         glScissor(x, y, width, height);
     }
 
+    @Override
     public void stencilFunc(int func, int ref, int mask) {
         glStencilFunc(func, ref, mask);
     }
 
+    @Override
     public void stencilMask(int mask) {
         glStencilMask(mask);
     }
 
+    @Override
     public void stencilOp(int fail, int zfail, int zpass) {
         glStencilOp(fail, zfail, zpass);
     }
 
+    @Override
     public void texImage2D(int target, int level, int internalFormat, int width, int height,
                            int border, int format, int type,
                            Buffer pixels) {
@@ -258,10 +296,12 @@ public class GdxGL extends GwtGL20 implements GL {
                 pixels);
     }
 
+    @Override
     public void texParameterf(int target, int pname, float param) {
         glTexParameterf(target, pname, param);
     }
 
+    @Override
     public void texSubImage2D(int target, int level, int xoffset, int yoffset, int width,
                               int height, int format, int type,
                               Buffer pixels) {
@@ -276,172 +316,214 @@ public class GdxGL extends GwtGL20 implements GL {
                 pixels);
     }
 
+    @Override
     public void viewport(int x, int y, int width, int height) {
         glViewport(x, y, width, height);
     }
 
+    @Override
     public void getFloatv(int pname, FloatBuffer params) {
         glGetFloatv(pname, params);
     }
 
+    @Override
     public void getTexParameterfv(int target, int pname, FloatBuffer params) {
         glGetTexParameterfv(target, pname, params);
     }
 
+    @Override
     public void texParameterfv(int target, int pname, FloatBuffer params) {
         glTexParameterfv(target, pname, params);
     }
 
+    @Override
     public void bindBuffer(int target, int buffer) {
         glBindBuffer(target, buffer);
     }
 
+    @Override
     public void bufferData(int target, int size, Buffer data, int usage) {
         glBufferData(target, size, data, usage);
     }
 
+    @Override
     public void bufferSubData(int target, int offset, int size, Buffer data) {
         glBufferSubData(target, offset, size, data);
     }
 
+    @Override
     public void deleteBuffers(int n, IntBuffer buffers) {
         glDeleteBuffers(n, buffers);
     }
 
+    @Override
     public void getBufferParameteriv(int target, int pname, IntBuffer params) {
         glGetBufferParameteriv(target, pname, params);
     }
 
+    @Override
     public void genBuffers(int n, IntBuffer buffers) {
         glGenBuffers(n, buffers);
     }
 
+    @Override
     public void getTexParameteriv(int target, int pname, IntBuffer params) {
         glGetTexParameteriv(target, pname, params);
     }
 
+    @Override
     public boolean isBuffer(int buffer) {
         return glIsBuffer(buffer);
     }
 
+    @Override
     public boolean isEnabled(int cap) {
         return glIsEnabled(cap);
     }
 
+    @Override
     public boolean isTexture(int texture) {
         return glIsTexture(texture);
     }
 
+    @Override
     public void texParameteri(int target, int pname, int param) {
         glTexParameteri(target, pname, param);
     }
 
+    @Override
     public void texParameteriv(int target, int pname, IntBuffer params) {
         glTexParameteriv(target, pname, params);
     }
 
+    @Override
     public void drawElements(int mode, int count, int type, int indices) {
         glDrawElements(mode, count, type, indices);
     }
 
+    @Override
     public void attachShader(int program, int shader) {
         glAttachShader(program, shader);
     }
 
+    @Override
     public void bindAttribLocation(int program, int index, String name) {
         glBindAttribLocation(program, index, name);
     }
 
+    @Override
     public void bindFramebuffer(int target, int framebuffer) {
         glBindFramebuffer(target, framebuffer);
     }
 
+    @Override
     public void bindRenderbuffer(int target, int renderbuffer) {
         glBindRenderbuffer(target, renderbuffer);
     }
 
+    @Override
     public void blendColor(float red, float green, float blue, float alpha) {
         glBlendColor(red, green, blue, alpha);
     }
 
+    @Override
     public void blendEquation(int mode) {
         glBlendEquation(mode);
     }
 
+    @Override
     public void blendEquationSeparate(int modeRGB, int modeAlpha) {
         glBlendEquationSeparate(modeRGB, modeAlpha);
     }
 
+    @Override
     public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
         glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     }
 
+    @Override
     public int checkFramebufferStatus(int target) {
         return glCheckFramebufferStatus(target);
     }
 
+    @Override
     public void compileShader(int shader) {
         glCompileShader(shader);
     }
 
+    @Override
     public int createProgram() {
         return glCreateProgram();
     }
 
+    @Override
     public int createShader(int type) {
         return glCreateShader(type);
     }
 
+    @Override
     public void deleteFramebuffers(int n, IntBuffer framebuffers) {
         glDeleteFramebuffers(n, framebuffers);
     }
 
+    @Override
     public void deleteProgram(int program) {
         glDeleteProgram(program);
     }
 
+    @Override
     public void deleteRenderbuffers(int n, IntBuffer renderbuffers) {
         glDeleteRenderbuffers(n, renderbuffers);
     }
 
+    @Override
     public void deleteShader(int shader) {
         glDeleteShader(shader);
     }
 
+    @Override
     public void detachShader(int program, int shader) {
         glDetachShader(program, shader);
     }
 
+    @Override
     public void disableVertexAttribArray(int index) {
         glDisableVertexAttribArray(index);
     }
 
+    @Override
     public void enableVertexAttribArray(int index) {
         glEnableVertexAttribArray(index);
     }
 
+    @Override
     public void framebufferRenderbuffer(int target, int attachment, int renderbuffertarget,
                                         int renderbuffer) {
         glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
     }
 
+    @Override
     public void framebufferTexture2D(int target, int attachment, int textarget, int texture,
                                      int level) {
         glFramebufferTexture2D(target, attachment, textarget, texture, level);
     }
 
+    @Override
     public void generateMipmap(int target) {
         glGenerateMipmap(target);
     }
 
+    @Override
     public void genFramebuffers(int n, IntBuffer framebuffers) {
         glGenFramebuffers(n, framebuffers);
     }
 
+    @Override
     public void genRenderbuffers(int n, IntBuffer renderbuffers) {
         glGenRenderbuffers(n, renderbuffers);
     }
 
+    @Override
     public String getActiveAttrib(int program, int index, IntBuffer size, Buffer type) {
         return glGetActiveAttrib(program,
                 index,
@@ -449,6 +531,7 @@ public class GdxGL extends GwtGL20 implements GL {
                 type);
     }
 
+    @Override
     public String getActiveUniform(int program, int index, IntBuffer size, Buffer type) {
         return glGetActiveUniform(program,
                 index,
@@ -456,6 +539,7 @@ public class GdxGL extends GwtGL20 implements GL {
                 type);
     }
 
+    @Override
     public void getAttachedShaders(int program, int maxcount, Buffer count, IntBuffer shaders) {
         glGetAttachedShaders(program,
                 maxcount,
@@ -463,14 +547,17 @@ public class GdxGL extends GwtGL20 implements GL {
                 shaders);
     }
 
+    @Override
     public int getAttribLocation(int program, String name) {
         return glGetAttribLocation(program, name);
     }
 
+    @Override
     public void getBooleanv(int pname, Buffer params) {
         glGetBooleanv(pname, params);
     }
 
+    @Override
     public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname,
                                                     IntBuffer params) {
         glGetFramebufferAttachmentParameteriv(target,
@@ -479,26 +566,32 @@ public class GdxGL extends GwtGL20 implements GL {
                 params);
     }
 
+    @Override
     public void getProgramiv(int program, int pname, IntBuffer params) {
         glGetProgramiv(program, pname, params);
     }
 
+    @Override
     public String getProgramInfoLog(int program) {
         return glGetProgramInfoLog(program);
     }
 
+    @Override
     public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) {
         glGetRenderbufferParameteriv(target, pname, params);
     }
 
+    @Override
     public void getShaderiv(int shader, int pname, IntBuffer params) {
         glGetShaderiv(shader, pname, params);
     }
 
+    @Override
     public String getShaderInfoLog(int shader) {
         return glGetShaderInfoLog(shader);
     }
 
+    @Override
     public void getShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range,
                                          IntBuffer precision) {
         glGetShaderPrecisionFormat(shadertype,
@@ -507,66 +600,82 @@ public class GdxGL extends GwtGL20 implements GL {
                 precision);
     }
 
+    @Override
     public void getShaderSource(int shader, int bufsize, Buffer length, String source) {
         throw new UnsupportedOperationException("Not implemented");
     }
 
+    @Override
     public void getUniformfv(int program, int location, FloatBuffer params) {
         glGetUniformfv(program, location, params);
     }
 
+    @Override
     public void getUniformiv(int program, int location, IntBuffer params) {
         glGetUniformiv(program, location, params);
     }
 
+    @Override
     public int getUniformLocation(int program, String name) {
         return glGetUniformLocation(program, name);
     }
 
+    @Override
     public void getVertexAttribfv(int index, int pname, FloatBuffer params) {
         glGetVertexAttribfv(index, pname, params);
     }
 
+    @Override
     public void getVertexAttribiv(int index, int pname, IntBuffer params) {
         glGetVertexAttribiv(index, pname, params);
     }
 
+    @Override
     public void getVertexAttribPointerv(int index, int pname, Buffer pointer) {
         glGetVertexAttribPointerv(index, pname, pointer);
     }
 
+    @Override
     public boolean isFramebuffer(int framebuffer) {
         return glIsFramebuffer(framebuffer);
     }
 
+    @Override
     public boolean isProgram(int program) {
         return glIsProgram(program);
     }
 
+    @Override
     public boolean isRenderbuffer(int renderbuffer) {
         return glIsRenderbuffer(renderbuffer);
     }
 
+    @Override
     public boolean isShader(int shader) {
         return glIsShader(shader);
     }
 
+    @Override
     public void linkProgram(int program) {
         glLinkProgram(program);
     }
 
+    @Override
     public void releaseShaderCompiler() {
         glReleaseShaderCompiler();
     }
 
+    @Override
     public void renderbufferStorage(int target, int internalformat, int width, int height) {
         glRenderbufferStorage(target, internalformat, width, height);
     }
 
+    @Override
     public void sampleCoverage(float value, boolean invert) {
         glSampleCoverage(value, invert);
     }
 
+    @Override
     public void shaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
         glShaderBinary(n,
                 shaders,
@@ -575,143 +684,178 @@ public class GdxGL extends GwtGL20 implements GL {
                 length);
     }
 
+    @Override
     public void shaderSource(int shader, String string) {
         glShaderSource(shader, string);
     }
 
+    @Override
     public void stencilFuncSeparate(int face, int func, int ref, int mask) {
         glStencilFuncSeparate(face, func, ref, mask);
     }
 
+    @Override
     public void stencilMaskSeparate(int face, int mask) {
         glStencilMaskSeparate(face, mask);
     }
 
+    @Override
     public void stencilOpSeparate(int face, int fail, int zfail, int zpass) {
         glStencilOpSeparate(face, fail, zfail, zpass);
     }
 
+    @Override
     public void uniform1f(int location, float x) {
         glUniform1f(location, x);
     }
 
+    @Override
     public void uniform1fv(int location, int count, FloatBuffer v) {
         glUniform1fv(location, count, v);
     }
 
+    @Override
     public void uniform1i(int location, int x) {
         glUniform1i(location, x);
     }
 
+    @Override
     public void uniform1iv(int location, int count, IntBuffer v) {
         glUniform1iv(location, count, v);
     }
 
+    @Override
     public void uniform2f(int location, float x, float y) {
         glUniform2f(location, x, y);
     }
 
+    @Override
     public void uniform2fv(int location, int count, FloatBuffer v) {
         glUniform2fv(location, count, v);
     }
 
+    @Override
     public void uniform2i(int location, int x, int y) {
         glUniform2i(location, x, y);
     }
 
+    @Override
     public void uniform2iv(int location, int count, IntBuffer v) {
         glUniform2iv(location, count, v);
     }
 
+    @Override
     public void uniform3f(int location, float x, float y, float z) {
         glUniform3f(location, x, y, z);
     }
 
+    @Override
     public void uniform3fv(int location, int count, FloatBuffer v) {
         glUniform3fv(location, count, v);
     }
 
+    @Override
     public void uniform3i(int location, int x, int y, int z) {
         glUniform3i(location, x, y, z);
     }
 
+    @Override
     public void uniform3iv(int location, int count, IntBuffer v) {
         glUniform3iv(location, count, v);
     }
 
+    @Override
     public void uniform4f(int location, float x, float y, float z, float w) {
         glUniform4f(location, x, y, z, w);
     }
 
+    @Override
     public void uniform4fv(int location, int count, FloatBuffer v) {
         glUniform4fv(location, count, v);
     }
 
+    @Override
     public void uniform4i(int location, int x, int y, int z, int w) {
         glUniform4i(location, x, y, z, w);
     }
 
+    @Override
     public void uniform4iv(int location, int count, IntBuffer v) {
         glUniform4iv(location, count, v);
     }
 
+    @Override
     public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
         glUniformMatrix2fv(location, count, transpose, value);
     }
 
+    @Override
     public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
         glUniformMatrix3fv(location, count, transpose, value);
     }
 
+    @Override
     public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
         glUniformMatrix4fv(location, count, transpose, value);
     }
 
+    @Override
     public void useProgram(int program) {
         glUseProgram(program);
     }
 
+    @Override
     public void validateProgram(int program) {
         glValidateProgram(program);
     }
 
+    @Override
     public void vertexAttrib1f(int indx, float x) {
         glVertexAttrib1f(indx, x);
     }
 
+    @Override
     public void vertexAttrib1fv(int indx, FloatBuffer values) {
         glVertexAttrib1fv(indx, values);
     }
 
+    @Override
     public void vertexAttrib2f(int indx, float x, float y) {
         glVertexAttrib2f(indx, x, y);
     }
 
+    @Override
     public void vertexAttrib2fv(int indx, FloatBuffer values) {
         glVertexAttrib2fv(indx, values);
     }
 
+    @Override
     public void vertexAttrib3f(int indx, float x, float y, float z) {
         glVertexAttrib3f(indx, x, y, z);
     }
 
+    @Override
     public void vertexAttrib3fv(int indx, FloatBuffer values) {
         glVertexAttrib3fv(indx, values);
     }
 
+    @Override
     public void vertexAttrib4f(int indx, float x, float y, float z, float w) {
         glVertexAttrib4f(indx, x, y, z, w);
     }
 
+    @Override
     public void vertexAttrib4fv(int indx, FloatBuffer values) {
         glVertexAttrib4fv(indx, values);
     }
 
+    @Override
     public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
                                     Buffer ptr) {
         glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
     }
 
+    @Override
     public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
                                     int ptr) {
         glVertexAttribPointer(indx, size, type, normalized, stride, ptr);

vtm-web/src/org/oscim/gdx/emu/com/badlogic/gdx/backends/gwt/GwtInput.java

@@ -187,6 +187,7 @@ public class GwtInput implements Input {
         return justPressedKeys[key];
     }
 
+    @Override
     public void getTextInput(TextInputListener listener, String title, String text, String hint) {
         TextInputDialogBox dialog = new TextInputDialogBox(title, text, hint);
         final TextInputListener capturedListener = listener;

vtm-web/src/org/oscim/gdx/emu/org/oscim/backend/MyAttributes.java

@@ -12,18 +12,22 @@ public class MyAttributes implements Attributes {
         map = n.getAttributes();
     }
 
+    @Override
     public String getValue(int i) {
         return map.item(i).getNodeValue();
     }
 
+    @Override
     public int getLength() {
         return map.getLength();
     }
 
+    @Override
     public String getLocalName(int i) {
         return map.item(i).getNodeName();
     }
 
+    @Override
     public String getValue(String string) {
         Node n = map.getNamedItem(string);
         if (n == null)

vtm-web/src/org/oscim/gdx/emu/org/oscim/tiling/source/LwHttp.java

@@ -58,6 +58,7 @@ public class LwHttp implements HttpEngine {
         }
     }
 
+    @Override
     public void close() {
         if (mHttpRequest == null)
             return;

vtm-web/src/org/oscim/gdx/emu/org/oscim/tiling/source/bitmap/BitmapTileSource.java

@@ -47,6 +47,7 @@ public class BitmapTileSource extends UrlTileSource {
             super(null, "/{Z}/{X}/{Y}.png");
         }
 
+        @Override
         public BitmapTileSource build() {
             return new BitmapTileSource(this);
         }
@@ -115,6 +116,7 @@ public class BitmapTileSource extends UrlTileSource {
             RootPanel.get().add(img);
 
             img.addLoadHandler(new LoadHandler() {
+                @Override
                 public void onLoad(LoadEvent event) {
                     TileLoader.postLoadDelay(new LoadDelayTask<Image>(tile, sink, img) {
 

vtm-web/src/org/oscim/tiling/source/JsonTileDataSource.java

@@ -88,6 +88,7 @@ public class JsonTileDataSource implements ITileDataSource {
         //builder.setCallbackParam("json_callback");
 
         mRequestHandle = builder.requestObject(url, new AsyncCallback<JavaScriptObject>() {
+            @Override
             public void onFailure(Throwable caught) {
 
                 mSink.completed(FAILED);
@@ -95,6 +96,7 @@ public class JsonTileDataSource implements ITileDataSource {
                 //mRequestHandle.cancel();
             }
 
+            @Override
             public void onSuccess(JavaScriptObject jso) {
                 if (mTile.state(State.NONE)) {
                     log.debug("tile cleared {}", url);