contextPrototype.stroke = function(aFill) {
        var lineStr = [];
        var lineOpen = false;
        var a = processStyle(aFill ? this.fillStyle : this.strokeStyle);
        var color = a.color;
        var opacity = a.alpha * this.globalAlpha;

        var W = 10;
        var H = 10;

        lineStr.push('<g_vml_:shape',
                                 ' filled="', !!aFill, '"',
                                 ' style="position:absolute;width:', W, 'px;height:', H, 'px;"',
                                 ' coordorigin="0 0" coordsize="', Z * W, ' ', Z * H, '"',
                                 ' stroked="', !aFill, '"',
                                 ' path="');

        var newSeq = false;
        var min = {x: null, y: null};
        var max = {x: null, y: null};

        for (var i = 0; i < this.currentPath_.length; i++) {
            var p = this.currentPath_[i];
            var c;

            switch (p.type) {
                case 'moveTo':
                    c = p;
                    lineStr.push(' m ', mr(p.x), ',', mr(p.y));
                    break;
                case 'lineTo':
                    lineStr.push(' l ', mr(p.x), ',', mr(p.y));
                    break;
                case 'close':
                    lineStr.push(' x ');
                    p = null;
                    break;
                case 'bezierCurveTo':
                    lineStr.push(' c ',
                                             mr(p.cp1x), ',', mr(p.cp1y), ',',
                                             mr(p.cp2x), ',', mr(p.cp2y), ',',
                                             mr(p.x), ',', mr(p.y));
                    break;
                case 'at':
                case 'wa':
                    lineStr.push(' ', p.type, ' ',
                                             mr(p.x - this.arcScaleX_ * p.radius), ',',
                                             mr(p.y - this.arcScaleY_ * p.radius), ' ',
                                             mr(p.x + this.arcScaleX_ * p.radius), ',',
                                             mr(p.y + this.arcScaleY_ * p.radius), ' ',
                                             mr(p.xStart), ',', mr(p.yStart), ' ',
                                             mr(p.xEnd), ',', mr(p.yEnd));
                    break;
            }


            // TODO: Following is broken for curves due to
            //           move to proper paths.

            // Figure out dimensions so we can do gradient fills
            // properly
            if (p) {
                if (min.x == null || p.x < min.x) {
                    min.x = p.x;
                }
                if (max.x == null || p.x > max.x) {
                    max.x = p.x;
                }
                if (min.y == null || p.y < min.y) {
                    min.y = p.y;
                }
                if (max.y == null || p.y > max.y) {
                    max.y = p.y;
                }
            }
        }
        lineStr.push(' ">');

        if (!aFill) {
            var lineWidth = this.lineScale_ * this.lineWidth;

            // VML cannot correctly render a line if the width is less than 1px.
            // In that case, we dilute the color to make the line look thinner.
            if (lineWidth < 1) {
                opacity *= lineWidth;
            }

            lineStr.push(
                '<g_vml_:stroke',
                ' opacity="', opacity, '"',
                ' joinstyle="', this.lineJoin, '"',
                ' miterlimit="', this.miterLimit, '"',
                ' endcap="', processLineCap(this.lineCap), '"',
                ' weight="', lineWidth, 'px"',
                ' color="', color, '" />'
            );
        } else if (typeof this.fillStyle == 'object') {
            var fillStyle = this.fillStyle;
            var angle = 0;
            var focus = {x: 0, y: 0};

            // additional offset
            var shift = 0;
            // scale factor for offset
            var expansion = 1;

            if (fillStyle.type_ == 'gradient') {
                var x0 = fillStyle.x0_ / this.arcScaleX_;
                var y0 = fillStyle.y0_ / this.arcScaleY_;
                var x1 = fillStyle.x1_ / this.arcScaleX_;
                var y1 = fillStyle.y1_ / this.arcScaleY_;
                var p0 = this.getCoords_(x0, y0);
                var p1 = this.getCoords_(x1, y1);
                var dx = p1.x - p0.x;
                var dy = p1.y - p0.y;
                angle = Math.atan2(dx, dy) * 180 / Math.PI;

                // The angle should be a non-negative number.
                if (angle < 0) {
                    angle += 360;
                }

                // Very small angles produce an unexpected result because they are
                // converted to a scientific notation string.
                if (angle < 1e-6) {
                    angle = 0;
                }
            } else {
                var p0 = this.getCoords_(fillStyle.x0_, fillStyle.y0_);
                var width   = max.x - min.x;
                var height = max.y - min.y;
                focus = {
                    x: (p0.x - min.x) / width,
                    y: (p0.y - min.y) / height
                };

                width   /= this.arcScaleX_ * Z;
                height /= this.arcScaleY_ * Z;
                var dimension = m.max(width, height);
                shift = 2 * fillStyle.r0_ / dimension;
                expansion = 2 * fillStyle.r1_ / dimension - shift;
            }

            // We need to sort the color stops in ascending order by offset,
            // otherwise IE won't interpret it correctly.
            var stops = fillStyle.colors_;
            stops.sort(function(cs1, cs2) {
                return cs1.offset - cs2.offset;
            });

            var length = stops.length;
            var color1 = stops[0].color;
            var color2 = stops[length - 1].color;
            var opacity1 = stops[0].alpha * this.globalAlpha;
            var opacity2 = stops[length - 1].alpha * this.globalAlpha;

            var colors = [];
            for (var i = 0; i < length; i++) {
                var stop = stops[i];
                colors.push(stop.offset * expansion + shift + ' ' + stop.color);
            }

            // When colors attribute is used, the meanings of opacity and o:opacity2
            // are reversed.
            lineStr.push('<g_vml_:fill type="', fillStyle.type_, '"',
                                     ' method="none" focus="100%"',
                                     ' color="', color1, '"',
                                     ' color2="', color2, '"',
                                     ' colors="', colors.join(','), '"',
                                     ' opacity="', opacity2, '"',
                                     ' g_o_:opacity2="', opacity1, '"',
                                     ' angle="', angle, '"',
                                     ' focusposition="', focus.x, ',', focus.y, '" />');
        } else {
            lineStr.push('<g_vml_:fill color="', color, '" opacity="', opacity,
                                     '" />');
        }

        lineStr.push('</g_vml_:shape>');

        this.element_.insertAdjacentHTML('beforeEnd', lineStr.join(''));
    };