Resize handler

        Parameters
        ----------
        event : instance of Event
            The event.
349565
def on_resize(self, event):
        
        if self._aspect is None:
            return
        w, h = self._canvas.size
        aspect = self._aspect / (w / h)
        self.scale = (self.scale[0], self.scale[0] / aspect)
        self.shader_map()
1138522
function startResizeWatching(event) {
        var components = getComponentsInEventRegistry(eventRegistry, namespace);
        isRunning = true;
        // The resize listener is fired very often
        // for performance optimisations we search and store
        // all components during the initial start event
        componentInformation = components.map(function (component) {
            var size = component.__resizeSize || {
                width: 0,
                height: 0
            };
            var gondelComponentHandlers = eventRegistry[component._componentName];
            return {
                component: component,
                node: component._ctx,
                selectors: Object.keys(gondelComponentHandlers).map(function (selector) {
                    return gondelComponentHandlers[selector].map(function (handlerOption) { return component[handlerOption.handlerName]; });
                }),
                width: size.width,
                height: size.height
            };
        });
        fireResizeEvent(event);
    }
1361189
def resizeEvent(self, event):
        
        super(XTextEdit, self).resizeEvent(event)
        
        if self.autoResizeToContents():
            self.resizeToContents()
800566
def resizeEvent(self, event):
        
        super(XLabel, self).resizeEvent(event)
        
        if self._lineEdit:
            self._lineEdit.resize(self.size())
1071799
def eventFilter(self, obj, event):
        
        if event.type() == event.Resize:
            self.resize(event.size())
        
        return False
871947
def OnResizeGrid(self, event):
        """"""

        shape = min(event.shape[2], 2**30)
        self.SetItemCount(shape)
        event.Skip()
967472
function resizableSlotEvent(event, eventElement, timeElement) {
		var snapDelta, prevSnapDelta;
		var snapHeight = getSnapHeight();
		var snapMinutes = getSnapMinutes();
		eventElement.resizable({
			handles: {
				s: '.ui-resizable-handle'
			},
			grid: snapHeight,
			start: function(ev, ui) {
				snapDelta = prevSnapDelta = 0;
				hideEvents(event, eventElement);
				trigger('eventResizeStart', this, event, ev, ui);
			},
			resize: function(ev, ui) {
				// don't rely on ui.size.height, doesn't take grid into account
				snapDelta = Math.round((Math.max(snapHeight, eventElement.height()) - ui.originalSize.height) / snapHeight);
				if (snapDelta != prevSnapDelta) {
					timeElement.text(
						formatDates(
							event.start,
							(!snapDelta && !event.end) ? null : // no change, so don't display time range
								addMinutes(eventEnd(event), snapMinutes*snapDelta),
							opt('timeFormat')
						)
					);
					prevSnapDelta = snapDelta;
				}
			},
			stop: function(ev, ui) {
				trigger('eventResizeStop', this, event, ev, ui);
				if (snapDelta) {
					eventResize(this, event, 0, snapMinutes*snapDelta, ev, ui);
				}else{
					showEvents(event, eventElement);
					// BUG: if event was really short, need to put title back in span
				}
			}
		});
	}
749843
def resizeEvent(self, event):
        
        super(XPushButton, self).resizeEvent(event)
        
        if self._richTextLabel:
            self._richTextLabel.resize(event.size())
1055053
function(handleObj) {
            // Since window has its own native 'resize' event, return false so that
            // jQuery doesn't modify the event object. Unless, of course, we're
            // throttling the 'resize' event for window.
            if(!jq_resize[str_throttle] && this[str_setTimeout]) {
                return false;
            }

            var old_handler;

            // The new_handler function is executed every time the event is triggered.
            // This is used to update the internal element data store with the width
            // and height when the event is triggered manually, to avoid double-firing
            // of the event callback. See the "Double firing issue in jQuery 1.3.2"
            // comments above for more information.

            function new_handler(e, w, h) {
                var elem = $(this),
                    data = $.data(this, str_data) || {};

                // If called from the polling loop, w and h will be passed in as
                // arguments. If called manually, via .trigger( 'resize' ) or .resize(),
                // those values will need to be computed.
                data.w = w !== undefined ? w : elem.width();
                data.h = h !== undefined ? h : elem.height();

                old_handler.apply(this, arguments);
            };

            // This may seem a little complicated, but it normalizes the special event
            // .add method between jQuery 1.4/1.4.1 and 1.4.2+
            if($.isFunction(handleObj)) {
                // 1.4, 1.4.1
                old_handler = handleObj;
                return new_handler;
            } else {
                // 1.4.2+
                old_handler = handleObj.handler;
                handleObj.handler = new_handler;
            }
        }
651520
def _trigger_event(self, event):
    

    if event is None or event not in self.__listeners:
      raise ValueError('invalid event type: {0!r}'.format(event))

    # Check the event has not already been triggered, then mark
    # the event as triggered.
    if event in self.__event_set:
      raise RuntimeError('event already triggered: {0!r}'.format(event))
    self.__event_set.add(event)
    listeners = self.__listeners[event] + self.__listeners[None]

    # Remove one-off listeners.
    self.__listeners[event][:] = (l for l in self.__listeners[event] if not l.once)
    self.__listeners[None][:] = (l for l in self.__listeners[None] if not l.once)

    for listener in listeners:
      # XXX: What to do on exceptions? Catch and make sure all listeners
      # run through? What to do with the exception(s) then?
      listener.callback(self, event)
575318
function resizeHandler()
			{
				var viewPaneSize = mainWindow.getViewPaneSize();
				shim && shim.setStyles( { width : viewPaneSize.width + 'px', height : viewPaneSize.height + 'px' } );
				editor.resize( viewPaneSize.width, viewPaneSize.height, null, true );
			}
476697
def resize(self, size):
        
        if isinstance(self._data, Stream):
            self._data.resize(size)
646850
def resize(self, size):
        
        if isinstance(self._data, Array):
            self._data.resize(size)
764782
@UiHandler("m_descriptionArea")
    public void onTextAreaBoxResize(ResizeEvent event) {

        ResizeEvent.fire(this, event.getWidth(), event.getHeight());
    }
235566
def resizeEvent( self, event ):
        
        super(XNavigationEdit, self).resizeEvent(event)
        
        w = self.width()
        h = self.height()
        
        self._scrollWidget.resize(w - 4, h - 4)
        
        if ( self._scrollWidget.width() < self._partsWidget.width() ):
           self.scrollParts( self._partsWidget.width() - self._scrollWidget.width() )
1049466
def resizeEvent(self, event):
        """"""
        self._viewIsDirty = True
        super(StimulusView, self).resizeEvent(event)
752459
public void setResizable(boolean resize) {

        if (resize != m_isResize) {
            if (resize) {
                getElement().appendChild(m_resize.getElement());
                adopt(m_resize);
                m_resize.addMouseDownHandler(new MouseDownHandler() {

                    public void onMouseDown(MouseDownEvent event) {

                        setStartParameters(event);
                        CmsDebugLog.getInstance().printLine("Registering preview handler");
                        if (m_previewHandlerRegistration != null) {
                            m_previewHandlerRegistration.removeHandler();
                        }
                        m_previewHandlerRegistration = Event.addNativePreviewHandler(new ResizeEventPreviewHandler());
                    }
                });
            } else {
                m_resize.removeFromParent();
            }
            m_isResize = resize;
        }
    }