Updates the image information.
499371
private void updateImageInfo() {

        String crop = getCrop();
        String point = getPoint();
        m_imageInfoDisplay.fillContent(m_info, crop, point);
    }
1049863
def update_used_images
      ActionController::Base.new.expire_fragment(self)
      image_ids = self.used_images
      if !image_ids.nil?
        Picture.where(id: image_ids).each do |picture|
          picture.update_attributes(article_id: self.id)
        end
      end
    end
280988
private void updateDecoration() {
        if (lastResult != null) {
            if (lastResult) {
                setIcon(validIcon);
                setToolTipText(validText);
            } else {
                setIcon(invalidIcon);
                setToolTipText(invalidText);
            }
        }
    }
315795
def refresh(self):
        
        self._clear()
        for img in self.composed_images:
            self._background_image.paste(img.image(self._device.size),
                                         img.position)
        self._background_image.crop(box=self._device.bounding_box)
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))
1295234
def _update_fields_with_objects(self):
        
        # Update the cover with a photo object
        if isinstance(self.cover, dict):
            self.cover = Photo(self._client, self.cover)

        # Update the photo list with photo objects
        try:
            for i, photo in enumerate(self.photos):
                if isinstance(photo, dict):
                    self.photos[i] = Photo(self._client, photo)
        except (AttributeError, TypeError):
            pass
421972
def _update_fields_with_objects(self):
        
        # Update the photo target with photo objects
        if self.target is not None:
            if self.target_type == "photo":
                self.target = Photo(self._client, self.target)
            else:
                raise NotImplementedError("Actions can only be assigned to "
                                          "Photos")
1356191
private void updateImage() {
		if (!over) {
			currentImage = normalImage;
			currentColor = normalColor;
			state = NORMAL;
			mouseUp = false;
		} else {
			if (mouseDown) {
				if ((state != MOUSE_DOWN) && (mouseUp)) {
					if (mouseDownSound != null) {
						mouseDownSound.play();
					}
					currentImage = mouseDownImage;
					currentColor = mouseDownColor;
					state = MOUSE_DOWN;
					
					notifyListeners();
					mouseUp = false;
				}
				
				return;
			} else {
				mouseUp = true;
				if (state != MOUSE_OVER) {
					if (mouseOverSound != null) {
						mouseOverSound.play();
					}
					currentImage = mouseOverImage;
					currentColor = mouseOverColor;
					state = MOUSE_OVER;
				}
			}
		}

		mouseDown = false;
		state = NORMAL;
	}
295653
def update(self):
        '''
        
        '''
        self.image = self.blank.copy()
        
        bf = self.font.render(''.join(self.text[:self.cursor_loc]), 
                True, self.color)
        br = bf.get_rect().move(self.margin)
        
        af = self.font.render(''.join(self.text[self.cursor_loc:]), 
                True, self.color)
        
        cr = self.cursor.get_rect()
        cvec = Vector(br.w - cr.w, 0) + self.margin
        
        scroll = Vector()
        
        if cvec.x > self.rect.w:
            scroll.x = self.rect.w - cvec.x - self.font.size(' ')[0]
        
        vcenter_blit(self.image, bf, scroll + br)
        vcenter_blit(self.image, af, scroll + br.topright)
        
        if self.cursor_shown and self.focus and pygame.key.get_focused():
            vcenter_blit(self.image, self.cursor, scroll + cvec)
        
        if self.blink_frames != None:
            self.blinker += 1
            self.blinker %= self.blink_frames
            if not self.blinker:
                self.cursor_shown = not self.cursor_shown
805135
def update(self, data, key):
        """"""
        og_data = self.read()
        og_data[key] = data
        self.write(og_data)
996849
def update(self):
        
        DEBUG_MSG("update()", 1, self)
        self._axes = self.canvas.figure.get_axes()
        self._menu.updateAxes(len(self._axes))
39492
def set_data(self, image):
        
        data = np.asarray(image)
        if self._data is None or self._data.shape != data.shape:
            self._need_vertex_update = True
        self._data = data
        self._need_texture_upload = True
723851
def fileupdate(self, data):
        """"""

        self.name = data["name"]
        add = self.__additional
        add["filetype"] = "other"
        for filetype in ("book", "image", "video", "audio", "archive"):
            if filetype in data:
                add["filetype"] = filetype
                break
        if add["filetype"] in ("image", "video", "audio"):
            add["thumb"] = data.get("thumb", dict())
        # checksum is md5
        add["checksum"] = data["checksum"]
        add["expire_time"] = data["expires"] / 1000
        add["size"] = data["size"]
        add["info"] = data.get(add["filetype"], dict())
        add["uploader"] = data["user"]
        if self.room.admin:
            add["info"].update({"room": data.get("room")})
            add["info"].update({"uploader_ip": data.get("uploader_ip")})
        self.updated = True
949261
def update(self, photo, **kwds):
        
        result = self._client.post("/photo/%s/update.json" %
                                   self._extract_id(photo),
                                   **kwds)["result"]
        return Photo(self._client, result)
484972
def update(self, data):
        """"""
        self._md.update(data)
        bufpos = self._nbytes & 63
        self._nbytes += len(data)

        if self._rarbug and len(data) > 64:
            dpos = self.block_size - bufpos
            while dpos + self.block_size <= len(data):
                self._corrupt(data, dpos)
                dpos += self.block_size
1159852
def update(self):
        
        if self.var_info.bits_per_pixel == 1:
            b = self._img.tobytes("raw", "1;R")
            self.mmap[:len(b)] = b

        elif self.var_info.bits_per_pixel == 16:
            self.mmap[:] = self._img_to_rgb565_bytes()

        elif self.var_info.bits_per_pixel == 32:
            self.mmap[:] = self._img.convert("RGB").tobytes("raw", "XRGB")

        else:
            raise Exception("Not supported - platform %s with bits_per_pixel %s" %
                (self.platform, self.var_info.bits_per_pixel))
27065
def update_image_digest(self, image, platform, digest):
        
        image_name_tag = self._key(image)

        image_name = image.to_str(tag=False)
        name_digest = '{}@{}'.format(image_name, digest)

        image_digests = self._images_digests.setdefault(image_name_tag, {})
        image_digests[platform] = name_digest