Draws a marker at the end of the sparkline
326516
function drawEndMarker(){
            if (circle) {
                svg.selectAll('.sparkline-circle').remove();
            }

            circle = svg.selectAll('.chart-group')
              .append('circle')
                .attr('class', 'sparkline-circle')
                .attr('cx', xScale(data[data.length - 1].date))
                .attr('cy', yScale(data[data.length - 1].value))
                .attr('r', markerSize);
        }
864770
function stroke(shape, fill) {
         if (shape.shapeType === "Rectangle") {
           this.strokeRect(shape.left, shape.top, shape.width, shape.height, fill);
         } else if (shape instanceof me.Line || shape instanceof me.Polygon) {
           this.strokePolygon(shape, fill);
         } else if (shape instanceof me.Ellipse) {
           this.strokeEllipse(shape.pos.x, shape.pos.y, shape.radiusV.x, shape.radiusV.y, fill);
         }
       }
356292
def _make_marker_token(self, type_):
        """"""
        tok = Token(type_,
                    '',
                    self.line,
                    self.line_num,
                    self.start,
                    self.start)
        return tok
1045722
def draw(self, context):
        """"""

        context.set_line_width(self.width)
        context.set_source_rgb(*self.color)

        context.move_to(*self.start_point)
        context.line_to(*self.end_point)
        context.stroke()
1023906
def drawPolyline(self, points):
        
        for i, p in enumerate(points):
            if i == 0:
                if not (self.lastPoint == Point(p)):
                    self.draw_cont += "%g %g m\n" % JM_TUPLE(Point(p) * self.ipctm)
                    self.lastPoint = Point(p)
            else:
                self.draw_cont += "%g %g l\n" % JM_TUPLE(Point(p) * self.ipctm)
            self.updateRect(p)

        self.lastPoint = Point(points[-1])
        return self.lastPoint
1204686
function drawHorizontalExtendedLine() {
            baseLine = svg.select('.axis-group')
              .selectAll('line.extended-x-line')
              .data([0])
              .enter()
                .append('line')
                  .attr('class', 'extended-x-line')
                  .attr('x1', 0)
                  .attr('x2', chartWidth);
        }
235584
function(evt) {
    // var polygon = this._poly;
    for (var i = 0, len = this._latlngs.length; i < len; i++) {
      // update marker
      var marker = this._markers[i];
      marker.setLatLng(this._latlngs[i]);

      // this one's needed to update the path
      marker._origLatLng = this._latlngs[i];
      if (marker._middleLeft) {
        marker._middleLeft.setLatLng(this._getMiddleLatLng(marker._prev, marker));
      }
      if (marker._middleRight) {
        marker._middleRight.setLatLng(this._getMiddleLatLng(marker, marker._next));
      }
    }

    // show vertices
    this._poly._map.addLayer(this._markerGroup);
    L.Edit.SimpleShape.prototype._updateMoveMarker.call(this);
    this._fireEdit();
  }
1204627
def draw_marked_line(self, data, coordinates, linestyle, markerstyle,
                         label, mplobj=None):
        
        if linestyle is not None:
            self.draw_line(data, coordinates, linestyle, label, mplobj)
        if markerstyle is not None:
            self.draw_markers(data, coordinates, markerstyle, label, mplobj)
1235816
def draw_point(self, x, y):
        
        check_int_err(lib.SDL_RenderDrawPoint(self._ptr, x, y))
177086
public void setEnd(Color col) {
		((ControlPoint) list.get(list.size()-1)).col = col;
		repaint(0);
	}
256817
function getMarkerLines(
  loc: NodeLocation,
  source: Array<string>,
  opts: Object,
): { start: number, end: number, markerLines: Object }
58911
def _time_marker_move(self, event):
        """"""
        limit = self.pixel_width
        x = self._canvas_ticks.canvasx(event.x)
        x = min(max(x, 0), limit)
        _, y = self._canvas_ticks.coords(self._time_marker_image)
        self._canvas_ticks.coords(self._time_marker_image, x, y)
        self._timeline.coords(self._time_marker_line, x, 0, x, self._timeline.winfo_height())
        self._time_show()
1241867
function colorChanged(elem) {
		var color = elem.getAttribute('stroke');

		$.each(mtypes, function(i, pos) {
			var marker = getLinked(elem, 'marker-'+pos);
			if (!marker) {return;}
			if (!marker.attributes.se_type) {return;} // not created by this extension
			var ch = marker.lastElementChild;
			if (!ch) {return;}
			var curfill = ch.getAttribute('fill');
			var curstroke = ch.getAttribute('stroke');
			if (curfill && curfill != 'none') {ch.setAttribute('fill', color);}
			if (curstroke && curstroke != 'none') {ch.setAttribute('stroke', color);}
		});
	}
1035861
def draw(self, img, pixmapper, bounds):
        ''''''

        if self.hidden:
            return

        if self.trail is not None:
            self.trail.draw(img, pixmapper, bounds)

        icon = self.img()
        (px,py) = pixmapper(self.latlon)

        # find top left
        px -= icon.width/2
        py -= icon.height/2
        w = icon.width
        h = icon.height

        (px, py, sx, sy, w, h) = self.clip(px, py, w, h, img)

        cv.SetImageROI(icon, (sx, sy, w, h))
        cv.SetImageROI(img, (px, py, w, h))
        cv.Add(icon, img, img)
        cv.ResetImageROI(img)
        cv.ResetImageROI(icon)

        # remember where we placed it for clicked()
        self.posx = px+w/2
        self.posy = py+h/2
671976
def _marker_line(self):
        # type: () -> str
        
        output = ''
        for col in sorted(self.col_widths):
            line = self.COLUMN_MARK + (self.DASH * (self.col_widths[col] + self.PADDING * 2))
            output += line
        output += self.COLUMN_MARK + '\n'

        return output
1054788
function(markerCoord) {
            var regexp = new RegExp(this.options.regexp, 'g');
            var text = window.getSelection().toString();

            if (text == '' || !regexp.test(text)) {return;}
            if (!this.rangeIsSelectable()) {return;}

            var coords = this.getMarkerCoords(this.marker, markerCoord);

            this.marker.style.top = coords.y + 'px';
    //        this.marker.style.left = coords.x + 'px';

            var sel = window.getSelection();
            if (sel.rangeCount){
                this.lastRange = new MaSha.Range(sel.getRangeAt(0), this);
            }

            addClass(this.marker, 'show');
        }
182046
function(start, end, direction) {
      var current = (start = startOfLine(start)), before = start && startOfLine(start.previousSibling);
      if (!isBR(end)) end = endOfLine(end, this.container);
      this.addDirtyNode(start);

      do {
        var next = endOfLine(current, this.container);
        if (current) this.highlight(before, next, true);
        this.indentLineAfter(current, direction);
        before = current;
        current = next;
      } while (current != end);
      select.setCursorPos(this.container, {node: start, offset: 0}, {node: end, offset: 0});
    }