New version of dart:html

client/html/generated/src/wrapping/_WebGLRenderingContextWrappingImplementation.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // WARNING: Do not edit - generated code.
 
 class WebGLRenderingContextWrappingImplementation extends CanvasRenderingContextWrappingImplementation implements WebGLRenderingContext {
   WebGLRenderingContextWrappingImplementation._wrap(ptr) : super._wrap(ptr) {}
 
   int get drawingBufferHeight() { return _ptr.drawingBufferHeight; }
@@ skipping 55 matching lines @@
     return;
   }
 
   void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
     _ptr.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     return;
   }
 
   void bufferData(int target, var data_OR_size, int usage) {
     if (data_OR_size is ArrayBuffer) {
-      _ptr.bufferData(target, LevelDom.unwrap(data_OR_size), usage);
+      _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), usage);
       return;
     } else {
       if (data_OR_size is ArrayBufferView) {
-        _ptr.bufferData(target, LevelDom.unwrap(data_OR_size), usage);
+        _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), usage);
         return;
       } else {
         if (data_OR_size is int) {
-          _ptr.bufferData(target, LevelDom.unwrap(data_OR_size), usage);
+          _ptr.bufferData(target, LevelDom.unwrapMaybePrimitive(data_OR_size), usage);
           return;
         }
       }
     }
     throw "Incorrect number or type of arguments";
   }
 
   void bufferSubData(int target, int offset, var data) {
     if (data is ArrayBuffer) {
-      _ptr.bufferSubData(target, offset, LevelDom.unwrap(data));
+      _ptr.bufferSubData(target, offset, LevelDom.unwrapMaybePrimitive(data));
       return;
     } else {
       if (data is ArrayBufferView) {
-        _ptr.bufferSubData(target, offset, LevelDom.unwrap(data));
+        _ptr.bufferSubData(target, offset, LevelDom.unwrapMaybePrimitive(data));
         return;
       }
     }
     throw "Incorrect number or type of arguments";
   }
 
   int checkFramebufferStatus(int target) {
     return _ptr.checkFramebufferStatus(target);
   }
 
@@ skipping 186 matching lines @@
 
   void getAttachedShaders(WebGLProgram program) {
     _ptr.getAttachedShaders(LevelDom.unwrap(program));
     return;
   }
 
   int getAttribLocation(WebGLProgram program, String name) {
     return _ptr.getAttribLocation(LevelDom.unwrap(program), name);
   }
 
-  void getBufferParameter() {
-    _ptr.getBufferParameter();
-    return;
+  Object getBufferParameter(int target, int pname) {
+    return LevelDom.wrapObject(_ptr.getBufferParameter(target, pname));
   }
 
   WebGLContextAttributes getContextAttributes() {
     return LevelDom.wrapWebGLContextAttributes(_ptr.getContextAttributes());
   }
 
   int getError() {
     return _ptr.getError();
   }
 
-  void getExtension(String name) {
-    _ptr.getExtension(name);
-    return;
+  Object getExtension(String name) {
+    return LevelDom.wrapObject(_ptr.getExtension(name));
   }
 
-  void getFramebufferAttachmentParameter() {
-    _ptr.getFramebufferAttachmentParameter();
-    return;
+  Object getFramebufferAttachmentParameter(int target, int attachment, int pname) {
+    return LevelDom.wrapObject(_ptr.getFramebufferAttachmentParameter(target, attachment, pname));
   }
 
-  void getParameter() {
-    _ptr.getParameter();
-    return;
+  Object getParameter(int pname) {
+    return LevelDom.wrapObject(_ptr.getParameter(pname));
   }
 
   String getProgramInfoLog(WebGLProgram program) {
     return _ptr.getProgramInfoLog(LevelDom.unwrap(program));
   }
 
-  void getProgramParameter() {
-    _ptr.getProgramParameter();
-    return;
+  Object getProgramParameter(WebGLProgram program, int pname) {
+    return LevelDom.wrapObject(_ptr.getProgramParameter(LevelDom.unwrap(program), pname));
   }
 
-  void getRenderbufferParameter() {
-    _ptr.getRenderbufferParameter();
-    return;
+  Object getRenderbufferParameter(int target, int pname) {
+    return LevelDom.wrapObject(_ptr.getRenderbufferParameter(target, pname));
   }
 
   String getShaderInfoLog(WebGLShader shader) {
     return _ptr.getShaderInfoLog(LevelDom.unwrap(shader));
   }
 
-  void getShaderParameter() {
-    _ptr.getShaderParameter();
-    return;
+  Object getShaderParameter(WebGLShader shader, int pname) {
+    return LevelDom.wrapObject(_ptr.getShaderParameter(LevelDom.unwrap(shader), pname));
   }
 
   String getShaderSource(WebGLShader shader) {
     return _ptr.getShaderSource(LevelDom.unwrap(shader));
   }
 
-  void getSupportedExtensions() {
-    _ptr.getSupportedExtensions();
-    return;
+  Object getTexParameter(int target, int pname) {
+    return LevelDom.wrapObject(_ptr.getTexParameter(target, pname));
   }
 
-  void getTexParameter() {
-    _ptr.getTexParameter();
-    return;
-  }
-
-  void getUniform() {
-    _ptr.getUniform();
-    return;
+  Object getUniform(WebGLProgram program, WebGLUniformLocation location) {
+    return LevelDom.wrapObject(_ptr.getUniform(LevelDom.unwrap(program), LevelDom.unwrap(location)));
   }
 
   WebGLUniformLocation getUniformLocation(WebGLProgram program, String name) {
     return LevelDom.wrapWebGLUniformLocation(_ptr.getUniformLocation(LevelDom.unwrap(program), name));
   }
 
-  void getVertexAttrib() {
-    _ptr.getVertexAttrib();
-    return;
+  Object getVertexAttrib(int index, int pname) {
+    return LevelDom.wrapObject(_ptr.getVertexAttrib(index, pname));
   }
 
   int getVertexAttribOffset(int index, int pname) {
     return _ptr.getVertexAttribOffset(index, pname);
   }
 
   void hint(int target, int mode) {
     _ptr.hint(target, mode);
     return;
   }
@@ skipping 103 matching lines @@
   void stencilOp(int fail, int zfail, int zpass) {
     _ptr.stencilOp(fail, zfail, zpass);
     return;
   }
 
   void stencilOpSeparate(int face, int fail, int zfail, int zpass) {
     _ptr.stencilOpSeparate(face, fail, zfail, zpass);
     return;
   }
 
-  void texImage2D(int target, int level, int internalformat, int format_OR_width, int height_OR_type, var border_OR_canvas_OR_image_OR_pixels, [int format = null, int type = null, ArrayBufferView pixels = null]) {
+  void texImage2D(int target, int level, int internalformat, int format_OR_width, int height_OR_type, var border_OR_canvas_OR_image_OR_pixels, [int format, int type, ArrayBufferView pixels]) {
     if (border_OR_canvas_OR_image_OR_pixels is ImageData) {
       if (format === null) {
         if (type === null) {
           if (pixels === null) {
-            _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrap(border_OR_canvas_OR_image_OR_pixels));
+            _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels));
             return;
           }
         }
       }
     } else {
       if (border_OR_canvas_OR_image_OR_pixels is ImageElement) {
         if (format === null) {
           if (type === null) {
             if (pixels === null) {
-              _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrap(border_OR_canvas_OR_image_OR_pixels));
+              _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels));
               return;
             }
           }
         }
       } else {
         if (border_OR_canvas_OR_image_OR_pixels is CanvasElement) {
           if (format === null) {
             if (type === null) {
               if (pixels === null) {
-                _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrap(border_OR_canvas_OR_image_OR_pixels));
+                _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels));
                 return;
               }
             }
           }
         } else {
           if (border_OR_canvas_OR_image_OR_pixels is int) {
-            _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrap(border_OR_canvas_OR_image_OR_pixels), format, type, LevelDom.unwrap(pixels));
+            _ptr.texImage2D(target, level, internalformat, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(border_OR_canvas_OR_image_OR_pixels), format, type, LevelDom.unwrap(pixels));
             return;
           }
         }
       }
     }
     throw "Incorrect number or type of arguments";
   }
 
   void texParameterf(int target, int pname, num param) {
     _ptr.texParameterf(target, pname, param);
     return;
   }
 
   void texParameteri(int target, int pname, int param) {
     _ptr.texParameteri(target, pname, param);
     return;
   }
 
-  void texSubImage2D(int target, int level, int xoffset, int yoffset, int format_OR_width, int height_OR_type, var canvas_OR_format_OR_image_OR_pixels, [int type = null, ArrayBufferView pixels = null]) {
+  void texSubImage2D(int target, int level, int xoffset, int yoffset, int format_OR_width, int height_OR_type, var canvas_OR_format_OR_image_OR_pixels, [int type, ArrayBufferView pixels]) {
     if (canvas_OR_format_OR_image_OR_pixels is ImageData) {
       if (type === null) {
         if (pixels === null) {
-          _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrap(canvas_OR_format_OR_image_OR_pixels));
+          _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixels));
           return;
         }
       }
     } else {
       if (canvas_OR_format_OR_image_OR_pixels is ImageElement) {
         if (type === null) {
           if (pixels === null) {
-            _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrap(canvas_OR_format_OR_image_OR_pixels));
+            _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixels));
             return;
           }
         }
       } else {
         if (canvas_OR_format_OR_image_OR_pixels is CanvasElement) {
           if (type === null) {
             if (pixels === null) {
-              _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrap(canvas_OR_format_OR_image_OR_pixels));
+              _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixels));
               return;
             }
           }
         } else {
           if (canvas_OR_format_OR_image_OR_pixels is int) {
-            _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrap(canvas_OR_format_OR_image_OR_pixels), type, LevelDom.unwrap(pixels));
+            _ptr.texSubImage2D(target, level, xoffset, yoffset, format_OR_width, height_OR_type, LevelDom.unwrapMaybePrimitive(canvas_OR_format_OR_image_OR_pixels), type, LevelDom.unwrap(pixels));
             return;
           }
         }
       }
     }
     throw "Incorrect number or type of arguments";
   }
 
   void uniform1f(WebGLUniformLocation location, num x) {
     _ptr.uniform1f(LevelDom.unwrap(location), x);
@@ skipping 143 matching lines @@
   void vertexAttribPointer(int indx, int size, int type, bool normalized, int stride, int offset) {
     _ptr.vertexAttribPointer(indx, size, type, normalized, stride, offset);
     return;
   }
 
   void viewport(int x, int y, int width, int height) {
     _ptr.viewport(x, y, width, height);
     return;
   }
 }