docs: function(node, style, options, geometry) {
          style = style  || node._style;
          options = options || node._options;
          var fillColor = style.fillColor;
  
          var title = style.title || style.graphicTitle;
          if (title) {
              node.title = title;
          } 
  
          if (node._geometryClass === "OpenLayers.Geometry.Point") {
              if (style.externalGraphic) {
                  options.isFilled = true;
                  var width = style.graphicWidth || style.graphicHeight;
                  var height = style.graphicHeight || style.graphicWidth;
                  width = width ? width : style.pointRadius*2;
                  height = height ? height : style.pointRadius*2;
  
                  var resolution = this.getResolution();
                  var xOffset = (style.graphicXOffset != undefined) ?
                      style.graphicXOffset : -(0.5 * width);
                  var yOffset = (style.graphicYOffset != undefined) ?
                      style.graphicYOffset : -(0.5 * height);
                  
                  node.style.left = ((((geometry.x - this.featureDx)/resolution - this.offset.x)+xOffset) | 0) + "px";
                  node.style.top = (((geometry.y/resolution - this.offset.y)-(yOffset+height)) | 0) + "px";
                  node.style.width = width + "px";
                  node.style.height = height + "px";
                  node.style.flip = "y";
                  
                  // modify fillColor and options for stroke styling below
                  fillColor = "none";
                  options.isStroked = false;
              } else if (this.isComplexSymbol(style.graphicName)) {
                  var cache = this.importSymbol(style.graphicName);
                  node.path = cache.path;
                  node.coordorigin = cache.left + "," + cache.bottom;
                  var size = cache.size;
                  node.coordsize = size + "," + size;        
                  this.drawCircle(node, geometry, style.pointRadius);
                  node.style.flip = "y";
              } else {
                  this.drawCircle(node, geometry, style.pointRadius);
              }
          }
  
          // fill 
          if (options.isFilled) { 
              node.fillcolor = fillColor; 
          } else { 
              node.filled = "false"; 
          }
          var fills = node.getElementsByTagName("fill");
          var fill = (fills.length == 0) ? null : fills[0];
          if (!options.isFilled) {
              if (fill) {
                  node.removeChild(fill);
              }
          } else {
              if (!fill) {
                  fill = this.createNode('olv:fill', node.id + "_fill");
              }
              fill.opacity = style.fillOpacity;
  
              if (node._geometryClass === "OpenLayers.Geometry.Point" &&
                      style.externalGraphic) {
  
                  // override fillOpacity
                  if (style.graphicOpacity) {
                      fill.opacity = style.graphicOpacity;
                  }
                  
                  fill.src = style.externalGraphic;
                  fill.type = "frame";
                  
                  if (!(style.graphicWidth && style.graphicHeight)) {
                    fill.aspect = "atmost";
                  }                
              }
              if (fill.parentNode != node) {
                  node.appendChild(fill);
              }
          }
  
          // additional rendering for rotated graphics or symbols
          var rotation = style.rotation;
          if ((rotation !== undefined || node._rotation !== undefined)) {
              node._rotation = rotation;
              if (style.externalGraphic) {
                  this.graphicRotate(node, xOffset, yOffset, style);
                  // make the fill fully transparent, because we now have
                  // the graphic as imagedata element. We cannot just remove
                  // the fill, because this is part of the hack described
                  // in graphicRotate
                  fill.opacity = 0;
              } else if(node._geometryClass === "OpenLayers.Geometry.Point") {
                  node.style.rotation = rotation || 0;
              }
          }
  
          // stroke 
          var strokes = node.getElementsByTagName("stroke");
          var stroke = (strokes.length == 0) ? null : strokes[0];
          if (!options.isStroked) {
              node.stroked = false;
              if (stroke) {
                  stroke.on = false;
              }
          } else {
              if (!stroke) {
                  stroke = this.createNode('olv:stroke', node.id + "_stroke");
                  node.appendChild(stroke);
              }
              stroke.on = true;
              stroke.color = style.strokeColor; 
              stroke.weight = style.strokeWidth + "px"; 
              stroke.opacity = style.strokeOpacity;
              stroke.endcap = style.strokeLinecap == 'butt' ? 'flat' :
                  (style.strokeLinecap || 'round');
              if (style.strokeDashstyle) {
                  stroke.dashstyle = this.dashStyle(style);
              }
          }
          
          if (style.cursor != "inherit" && style.cursor != null) {
              node.style.cursor = style.cursor;
          }
          return node;
      }