Update all the artists in the histogram. Subclassable to
        allow updating of further artists.
963286
def _update_artists(self, key, hist, edges, hvals, widths, lims, ranges):
        
        plot_vals = zip(self.handles['artist'], edges, hvals, widths)
        for bar, edge, height, width in plot_vals:
            if self.invert_axes:
                bar.set_y(edge)
                bar.set_width(height)
                bar.set_height(width)
            else:
                bar.set_x(edge)
                bar.set_height(height)
                bar.set_width(width)
1044898
def artist(self):
        
        if not self._artist:
            self._artist = Artist(self._artist_id, self._artist_name, self._connection)
        return self._artist
50695
def update(self, **kwargs):
        

        # Update node properties with additional elements
        svg_changed = False
        for prop in kwargs:
            if prop == "drawing_id":
                pass  # No good reason to change a drawing_id
            elif getattr(self, prop) != kwargs[prop]:
                if prop == "svg":
                    # To avoid spamming client with large data we don't send the svg if the SVG didn't change
                    svg_changed = True
                setattr(self, prop, kwargs[prop])
        data = self.__json__()
        if not svg_changed:
            del data["svg"]
        self._project.controller.notification.emit("drawing.updated", data)
        self._project.dump()
568633
def refresh(self):
        
        for cbar in self.colorbars:
            cbar.draw_all()
        self.canvas.draw()
917802
def _updateImage(self):
        """"""
        # Fill the background of the image
        if self.backgroundColor is not None:
            self.textImage.fill(self.backgroundColor)

        # Render the text as a single line, and blit it onto the textImage surface
        if self.mask is None:
            lineSurface = self.font.render(self.text, True, self.textColor)
        else:
            nChars = len(self.text)
            maskedText = self.mask * nChars
            lineSurface = self.font.render(maskedText, True, self.textColor)
        self.textImage.blit(lineSurface, (0, 0))
424967
public void updateNoDraw() {
		if (autoUpdate) {
			long now = getTime();
			long delta = now - lastUpdate;
			if (firstUpdate) {
				delta = 0;
				firstUpdate = false;
			}
			lastUpdate = now;
			nextFrame(delta);
		}
	}
913948
def update(self):
        '''
        
        '''
        self.updateIncomeProcess()
        self.updateAssetsGrid()
        self.updatepLvlNextFunc()
        self.updatepLvlGrid()
        self.updateMedShockProcess()
        self.updateSolutionTerminal()
681203
def on_release_event(self, event):
        " "
        element = self.element_from_artist[self.selected_patch]
        self.position[element] = [event.xdata, event.ydata]
        # Signal is a variable! therefore must be tested before
        if isinstance(element, bms.Signal):
            artists = self.artists_from_element[element]
            points = np.array((5, 2))
            xp, yp = self.position[element]
            points = np.array([[xp-1.5*self.l, yp-0.5*self.l], [xp-0.5*self.l, yp-0.5*self.l], [
                              xp, yp], [xp-0.5*self.l, yp+0.5*self.l], [xp-1.5*self.l, yp+0.5*self.l]])
            artists[0].set_xy(xy=points)
            artists[1].set(x=xp-1*self.l, y=yp)
            for artist in artists[3]:  # update out arrows
                artist.set_positions((xp, yp), None)

        elif isinstance(element, bms.Variable):
            artists = self.artists_from_element[element]
            pos = self.position[element]
            artists[0].set(x=pos[0], y=pos[1])
            for artist in artists[2]:  # update in arrows
                artist.set_positions(None, pos)
            for artist in artists[3]:  # update out arrows
                artist.set_positions(pos, None)

        elif isinstance(element, bms.Block):
            artists = self.artists_from_element[element]
            pb = self.position[element][:]
            hb = 0.5*(1+max(len(element.inputs), len(element.outputs)))*self.l
            artists[0].set(xy=(pb[0]-0.5*self.l, pb[1]-hb/2))
            artists[1].set(x=pb[0], y=pb[1])
            li = len(element.inputs)
#            lo=len(element.outputs)
            for i in range(2, li+2):
                artists[i].set_positions(
                    None, (pb[0]-0.5*self.l, pb[1]+hb/2-0.5*(i+1-2)*self.l))
            for i in range(2+li, len(artists)):
                artists[i].set_positions(
                    (pb[0]+0.5*self.l, pb[1]+hb/2-0.5*(i+1-2-li)*self.l), None)

        plt.draw()
        return True
1048169
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqb*con.tind)
481560
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi2*con.tind)
744774
public void setOriginalArtist(String artist)
	{
		if (allow(ID3V2))
		{
			id3v2.setTextFrame(ID3v2Frames.ORIGINAL_ARTIST, artist);
		}
	}
1156073
def update(self, **kwds):
        
        result = self._client.photo.update(self, **kwds)
        self._replace_fields(result.get_fields())
79346
def update(self, duration):
        """"""
        if duration >= 0:
            self.histogram.update(duration)
            self.meter.mark()
207353
function updateChartPainters(data, envelope) {
  if (data.x.fields[0].data.length) {
    xChartPainter.updateData(data.x);
  }
  if (data.y.fields[0].data.length) {
    yChartPainter.updateData(data.y);
  }
  if (data.z.fields[0].data.length) {
    zChartPainter.updateData(data.z);
  }
}
270826
def update(self):
        
        display_data = []
        for y in range(self.height):
            for x in range(self.width):
                for color in self.matrix[x][y]:
                    display_data.append(int(color))

        checksum = bytearray([0, 0, 0, 0])
        data_as_bytes = bytearray(display_data)
        data = data_as_bytes + checksum
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.sendto(data, (self.host, self.port))
1064325
public void update() {

        switch (shapeType) {

            case POLYLINE_MARKERS:
                ((PolylineMarkers) shape).update();
                break;
            case POLYGON_MARKERS:
                ((PolygonMarkers) shape).update();
                break;
            case MULTI_POLYLINE_MARKERS:
                ((MultiPolylineMarkers) shape).update();
                break;
            case MULTI_POLYGON_MARKERS:
                ((MultiPolygonMarkers) shape).update();
                break;
            case COLLECTION:
                @SuppressWarnings("unchecked")
                List<GoogleMapShape> shapeList = (List<GoogleMapShape>) shape;
                for (GoogleMapShape shapeListItem : shapeList) {
                    shapeListItem.update();
                }
                break;
            default:
        }

    }
1165247
def _update_Prxy(self):
        """"""
        self.Prxy = self.Frxy * self.Qxy
        _fill_diagonals(self.Prxy, self._diag_indices)