Zoom out a level.
        Also see :meth:`zoom_to`.

        Parameters
        ----------
        decr : float (optional, defaults to 1)
            The value to decrease the zoom level
345857
def zoom_out(self, decr=1.0):
        
        level = self.zoom.calc_level(self.t_['scale'])
        self.zoom_to(level - decr)
159193
def zoom_in(self):
        """"""
        if self._scalefactor <= self._sfmax:
            self._scalefactor += 1
            self.scale_image()
            self._adjust_scrollbar(self._scalestep)
            self.sig_zoom_changed.emit(self.get_scaling())
91165
def decr(name, value=1, rate=1, tags=None):
    
    client().decr(name, value, rate, tags)
921230
function (toZoom) {
		var crs = this.options.crs;
		return crs.scale(toZoom) / crs.scale(this._zoom);
	}
330972
def wheelEvent(self, event):
        

        if event.modifiers() == Qt.ControlModifier:
            if event.delta() == 120:
                self.zoom_in()
            elif event.delta() == -120:
                self.zoom_out()
            event.ignore()
        else:
            QPlainTextEdit.wheelEvent(self, event)
89682
def zoom_out(self):
        """"""

        zoom = self.grid.grid_renderer.zoom

        target_zoom = zoom * (1 - config["zoom_factor"])

        if target_zoom > config["minimum_zoom"]:
            self.zoom(target_zoom)
1067900
def unzoom(self, full=False, delay_draw=False):
        """"""
        if full:
            self.zoom_lims = self.zoom_lims[:1]
            self.zoom_lims = []
        elif len(self.zoom_lims) > 0:
            self.zoom_lims.pop()
        self.set_viewlimits()
        if not delay_draw:
            self.canvas.draw()
787138
def zoom_in_frag(self, curr_frag):
        
        level = curr_frag[1]
        frag = curr_frag[0]
        output = []
        if level > 0:
            str_level = str(level)
            sub_low = self.spec_level[str_level]["fragments_dict"][frag][
                "sub_low_index"
            ]
            sub_high = self.spec_level[str_level]["fragments_dict"][frag][
                "sub_high_index"
            ]
            new_level = level - 1
            for i in range(sub_low, sub_high + 1):
                output.append((i, new_level))
        else:
            output.append(curr_frag)
        return output
1074579
def min_zoom(self):
        
        zoom_levels = [map_layer.min_zoom for map_layer in self.layers]
        return min(zoom_levels)
1021754
def zoom_leftdown(self, event=None):
        """"""
        self.x_lastmove, self.y_lastmove = None, None
        self.zoom_ini = (event.x, event.y, event.xdata, event.ydata)
        self.report_leftdown(event=event)
955404
def _reduced_call(self, **params_to_override):
        
        p=param.ParamOverrides(self,params_to_override)

        fn_result = self.function(p)
        self._apply_mask(p,fn_result)
        result = p.scale*fn_result+p.offset
        return result
975779
def _der(self,*args):
        '''
        
        '''
        if len(args) > 0:
            if _isscalar(args[0]):
                return 0.0
            else:
                shape = args[0].shape
                return np.zeros(shape)
        else:
            return 0.0
1224896
def zoomTo(self, bbox):
        ''
        self.fixPoint(self.plotviewBox.xymin, bbox.xymin)
        self.zoomlevel=max(bbox.w/self.canvasBox.w, bbox.h/self.canvasBox.h)
222742
def dynamic_zoom_plot(x, y, N, RegionStartSize=1000):
    
    x_lowres = x[::N]
    y_lowres = y[::N]
    
    ax1 = _plt.subplot2grid((2, 1), (0, 0), colspan=1)
    ax2 = _plt.subplot2grid((2, 1), (1, 0))
    
    fig = ax1.get_figure()
    _plt.subplots_adjust(bottom=0.25) # makes space at bottom for sliders
    
    CenterTime0 = len(x)/2
    TimeWidth0 = len(x)/RegionStartSize
    
    l1, = ax1.plot(x_lowres, y_lowres, lw=2, color='red')
    global r1
    r1 = ax1.fill_between(x_lowres[int((CenterTime0 - TimeWidth0)/N) : int((CenterTime0 + TimeWidth0)/N)], min(y), max(y), facecolor='green', alpha=0.5)
    l2, = ax2.plot(x, y, lw=2, color='red')
    
    
    axcolor = 'lightgoldenrodyellow'
    axCenterTime = _plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)
    axTimeWidth = _plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor)
    
    SliderCentreTime = Slider(axCenterTime, 'Center Time', 0, len(x), valinit=CenterTime0)
    SliderTimeWidth = Slider(axTimeWidth, 'Time Width', 0, len(x), valinit=TimeWidth0)
    
    
    def update(val):
        TimeWidth = SliderTimeWidth.val
        CentreTime = SliderCentreTime.val
        LeftIndex = int(CentreTime-TimeWidth)
        if LeftIndex < 0:
            LeftIndex = 0
        RightIndex = int(CentreTime+TimeWidth)
        if RightIndex > len(x)-1:
            RightIndex = len(x)-1
        global r1
        r1.remove()
        r1 = ax1.fill_between(x[LeftIndex:RightIndex], min(y), max(y), facecolor='green', alpha=0.5)
        l2.set_xdata(x[LeftIndex:RightIndex])
        l2.set_ydata(y[LeftIndex:RightIndex])
        ax2.set_xlim([x[LeftIndex], x[RightIndex]])
        fig.canvas.draw_idle()
    SliderCentreTime.on_changed(update)
    SliderTimeWidth.on_changed(update)
    
    resetax = _plt.axes([0.8, 0.025, 0.1, 0.04])
    button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
    
    
    def reset(event):
        SliderCentreTime.reset()
        SliderTimeWidth.reset()
    button.on_clicked(reset)    
    
    _plt.show()
352479
private void zoomTo() {

		if (urlParser.isValid() && !zoomedTo) {

			final Timer timer = new Timer() {
				@Override
				public void run() {
					mapWidget.getMapModel().getMapView().setCurrentScale(urlParser.getR(), MapView.ZoomOption.EXACT);
					mapWidget.getMapModel().getMapView().setCenterPosition(new Coordinate(urlParser.getX(),
							urlParser.getY()));

					this.cancel();
					zoomedTo = true;

				}
			};
			//run one time after 0.1s to be sure that the map has been resized.
			timer.schedule(100);
		}
	}
537918
def zoom_out_pixel(self, curr_pixel):
        
        low_frag = curr_pixel[0]
        high_frag = curr_pixel[1]
        level = curr_pixel[2]
        str_level = str(level)
        if level < self.n_level - 1:
            low_super = self.spec_level[str_level]["fragments_dict"][low_frag][
                "super_index"
            ]
            high_super = self.spec_level[str_level]["fragments_dict"][
                high_frag
            ]["sub_index"]

            new_pix_low = min([low_super, high_super])
            new_pix_high = max([low_super, high_super])
            new_level = level + 1
            new_pixel = [new_pix_low, new_pix_high, new_level]
        else:
            new_pixel = curr_pixel
        return new_pixel
1328097
def zoom(self, locator, percent="200%", steps=1):
        
        driver = self._current_application()
        element = self._element_find(locator, True, True)
        driver.zoom(element=element, percent=percent, steps=steps)