Emit custom signal when the window is re-sized.

        :param event: The re-sized event.
        :type event: QResizeEvent
191896
def resizeEvent(self, event):
        
        self.resized.emit()
        return super(WizardDialog, self).resizeEvent(event)
791463
public void onResize(final ResizeEvent event) {

        if ((m_selectedItem != null) && m_selectedItem.hasSubmenu()) {

            Scheduler.get().scheduleDeferred(new ScheduledCommand() {

                /**
                 * @see com.google.gwt.user.client.Command#execute()
                 */
                public void execute() {

                    getSelectedItem().getSubMenu().setSubMenuPosition(getSelectedItem());
                    getSelectedItem().getSubMenu().onResize(event);
                }
            });
        }
    }
535081
def emit_event(self, event):
        """"""
        with self._lock:
            listeners = list(self._event_listeners)

        for cb in list(self._event_listeners):
            # noinspection PyBroadException
            try:
                cb(event)
            except:
                # Don't let exceptions from callbacks kill our thread of execution
                logger.exception("Event callback resulted in unhandled exception")
603568
function handleWindowResize () {
    ctrl.lastSelectedIndex = ctrl.selectedIndex;
    ctrl.offsetLeft        = fixOffset(ctrl.offsetLeft);

    $mdUtil.nextTick(function () {
      ctrl.updateInkBarStyles();
      updatePagination();
    });
  }
545257
def OnSize(self, event):
        """"""

        # Store window size in config

        size = event.GetSize()

        config["window_size"] = repr((size.width, size.height))
1063027
def on_resize(self, event):
        """"""
        self.context.set_viewport(0, 0, event.size[0], event.size[1])
        for visual in self.visuals:
            visual.on_resize(event.size)
        self.update()
875286
def resizeEvent(self, event):
        

        frame_width = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
        search_active_labelSize = self.__search_active_label.sizeHint()
        self.__search_active_label.move(self.rect().left() + frame_width,
                                        (self.rect().bottom() - search_active_labelSize.height()) / 2 + frame_width / 2)
        clear_buttonSize = self.__clear_button.sizeHint()
        self.__clear_button.move(self.rect().right() - frame_width - clear_buttonSize.width(),
                                 (self.rect().bottom() - clear_buttonSize.height()) / 2 + frame_width / 2)
302339
def resizeEvent(self, event):
        
        value = self.config.value
        self.idx_fig.fitInView(value['x_min'],
                               value['y_min'],
                               value['x_max'] - value['x_min'],
                               value['y_max'] - value['y_min'])
652477
function onResizeEnd() {
            utils.dragInfo.inDragging = false;
            utils.dragInfo.justResized = true; // if winJustDragged, should force children re-render
            setTimeout(function () {
              utils.dragInfo.justResized = false;
            }, 1200);

            refreshFrame();
          }
1232945
def on_size(self, event):
        ''''''
        state = self.state
        self.need_redraw = True
        if state.report_size_changes:
            # tell owner the new size
            size = self.frame.GetSize()
            if size != self.last_size:
                self.last_size = size
                state.out_queue.put(MPImageNewSize(size))
871947
def OnResizeGrid(self, event):
        """"""

        shape = min(event.shape[2], 2**30)
        self.SetItemCount(shape)
        event.Skip()
743526
function fireComponentResizeEvent(event) {
        frameIsRequested = false;
        if (!componentInformation) {
            return;
        }
        var newSizes = componentInformation.map(function (_a) {
            var node = _a.node;
            return ({
                width: node.clientWidth,
                height: node.clientHeight
            });
        });
        var handlerResults = [];
        componentInformation.forEach(function (componentInformation, i) {
            var newSize = newSizes[i];
            // Skip if the size did not change
            if (newSize.width === componentInformation.width &&
                newSize.height === componentInformation.height) {
                return;
            }
            // Skip if the component is not running anymore
            if (componentInformation.component._stopped) {
                return;
            }
            componentInformation.component.__resizeSize = newSize;
            componentInformation.width = newSize.width;
            componentInformation.height = newSize.height;
            componentInformation.selectors.forEach(function (selector) {
                return selector.forEach(function (handler) {
                    return handlerResults.push(handler.call(componentInformation.component, event, newSize));
                });
            });
        });
        handlerResults.forEach(function (handlerResult) {
            if (typeof handlerResult === "function") {
                handlerResult();
            }
        });
    }
1138940
def on_resize(self, event):
        
        self._update_transforms()
        
        if self._central_widget is not None:
            self._central_widget.size = self.size
            
        if len(self._vp_stack) == 0:
            self.context.set_viewport(0, 0, *self.physical_size)
642901
def resizeEvent(self, event):
        
        self.resized.emit()
        return super(MetadataConverterDialog, self).resizeEvent(event)
524266
def resizeEvent(self, event):
        
        super(XTabBar, self).resizeEvent(event)
        self.resized.emit()
330595
def showEvent(self, event):
        
        super(XWalkthroughWidget, self).showEvent(event)
        
        self.autoLayout()
        self.restart()
        self.setFocus()
        self.raise_()
715789
def callback(self, event):
        
        self.init_width()

        if len(self.initial) > 0:
            for cell in self.initial:
                self.color_square(cell[0], cell[1], True)
            self.initial = []
        self.begin_drag = event
        self.color_square(event.x, event.y)