Move the font size pointer up. If this would move the pointer past
the maximum font size, track this increase with a virtual size.
495980
public void increaseFontSize() {
        // move INTO range if we have just moved OUT of lower virtual
        if (inRange() || (atMin() && atLowerBoundary())) {
            currentFontIndex++;
        } else if (atMax()) {
            upperVirtualCount++;
        } else if (atMin() && inLower()) {
            lowerVirtualCount++;
        }
    }
405737
def _effectinit_enlarge_font_on_focus(self, name, **kwargs):
        

        self._effects[name] = kwargs
        if "font" not in kwargs:
            raise TypeError(
                "enlarge_font_on_focus: font parameter is required"
            )
        if "size" not in kwargs:
            raise TypeError(
                "enlarge_font_on_focus: size parameter is required"
            )
        if "enlarge_time" not in kwargs:
            kwargs['enlarge_time'] = 0.5
        if "enlarge_factor" not in kwargs:
            kwargs['enlarge_factor'] = 2.0

        kwargs['raise_font_ps'] = (
            kwargs['enlarge_factor'] / kwargs['enlarge_time']  # pixel-per-sec
        )
        for option in self.options:
            option['font'] = pygame.font.Font(kwargs['font'], kwargs['size'])
            option['font_current_size'] = kwargs['size']
            option['raise_font_factor'] = 1.0
173462
def updateFontPicker(self):
        
        font = self.currentFont()
        self._fontPickerWidget.setPointSize(font.pointSize())
        self._fontPickerWidget.setCurrentFamily(font.family())
409245
private void updateSize() {
        int newLineCount = ActionUtils.getLineCount(pane);
        if (newLineCount == lineCount) {
            return;
        }
        lineCount = newLineCount;
        int h = (int) pane.getPreferredSize().getHeight();
        int d = (int) Math.log10(lineCount) + 1;
        if (d < 1) {
            d = 1;
        }
        int w = d * charWidth + r_margin + l_margin;
        format = "%" + d + "d";
        setPreferredSize(new Dimension(w, h));
        getParent().doLayout();
    }
38279
public void moveLocation(double extrp, double vx, double vy)
    {
        checkHorizontalLimit(extrp, vx);
        checkVerticalLimit(extrp, vy);
    }
343785
@Override
  protected final void increaseNewListSize() throws IOException {
    // register old situation
    int tmpOldSize = newKeyList.length;
    int tmpNewPosition = newPosition;
    // increase
    super.increaseNewListSize();
    // reconstruct
    T1[][] tmpNewFullValueList = newFullValueList;
    newFullValueList = operations.createMatrix1(newSize);
    newPosition = tmpNewPosition;
    System.arraycopy(tmpNewFullValueList, 0, newFullValueList, 0, tmpOldSize);
  }
492720
def _resize_buffers(self, font_scale):
        """"""
        new_sizes = (font_scale,) + self.size
        if new_sizes == self._current_sizes:  # don't need resize
            return
        self._n_rows = int(max(self.size[1] /
                               (self._char_height * font_scale), 1))
        self._n_cols = int(max(self.size[0] /
                               (self._char_width * font_scale), 1))
        self._bytes_012 = np.zeros((self._n_rows, self._n_cols, 3), np.float32)
        self._bytes_345 = np.zeros((self._n_rows, self._n_cols, 3), np.float32)
        pos = np.empty((self._n_rows, self._n_cols, 2), np.float32)
        C, R = np.meshgrid(np.arange(self._n_cols), np.arange(self._n_rows))
        # We are in left, top orientation
        x_off = 4.
        y_off = 4 - self.size[1] / font_scale
        pos[..., 0] = x_off + self._char_width * C
        pos[..., 1] = y_off + self._char_height * R
        self._position = VertexBuffer(pos)

        # Restore lines
        for ii, line in enumerate(self._text_lines[:self._n_rows]):
            self._insert_text_buf(line, ii)
        self._current_sizes = new_sizes
950785
def _cursor_up(self, value):
        
        value = int(value)
        if value == 0:
            value = 1
        self._cursor.clearSelection()
        self._cursor.movePosition(self._cursor.Up, self._cursor.MoveAnchor, value)
        self._last_cursor_pos = self._cursor.position()
466534
def adjustHeadingPointer(self):
        ''''''
        self.headingText.set_text(str(self.heading))
        self.headingText.set_size(self.fontSize)
947709
def minimum_font_point_size(self, value):
        

        if value is not None:
            assert type(value) in (int, float), "'{0}' attribute: '{1}' type is not 'int' or 'float'!".format(
                "minimum_font_point_size", value)
            assert value > 0, "'{0}' attribute: '{1}' need to be exactly positive!".format(
                "minimum_font_point_size", value)
        self.__minimum_font_point_size = value
1163407
private void resizeTitleText() {
        double maxWidth = 0.56667 * size;
        double fontSize = 0.08 * size;
        titleText.setFont(Fonts.robotoLight(fontSize));
        if (titleText.getLayoutBounds().getWidth() > maxWidth) { Helper.adjustTextSize(titleText, maxWidth, fontSize); }
        titleText.relocate((size - titleText.getLayoutBounds().getWidth()) * 0.5, size * 0.225);
    }
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)
542382
function restoreFontSize() {
        var fsStyle      = prefs.get("fontSize"),
            fsAdjustment = PreferencesManager.getViewState("fontSizeAdjustment");

        if (fsAdjustment) {
            // Always remove the old view state even if we also have the new view state.
            PreferencesManager.setViewState("fontSizeAdjustment");

            if (!fsStyle) {
                // Migrate the old view state to the new one.
                fsStyle = (DEFAULT_FONT_SIZE + fsAdjustment) + "px";
                prefs.set("fontSize", fsStyle);
            }
        }

        if (fsStyle) {
            _removeDynamicFontSize();
            _addDynamicFontSize(fsStyle);
        }
    }
232502
public void updateInternals()
	{
		if (null == getContainer())
		{
			return;
		}
		super.updateInternals();

		UnitConverter _uc = UnitConverter.getCachedInstance(getContainer().getSheetOfPaper().getPixelPerInch());
		double _zoom = getContainer().convertMillimeterToUnit(_uc.convertPointToMillimiter(1));

		myInternalFont = getFont().deriveFont(AffineTransform.getScaleInstance(_zoom, _zoom));

		// update textformat
		myTextFormat.clear();
		myTextFormat.put(TextAttribute.FONT, myInternalFont);

		myLineBreakMeasurer = new LineBreakMeasurer(new AttributedString(getText(), myTextFormat).getIterator(),
				new FontRenderContext(null, true, true));

		try
		{
			float _wrappingWidth = (float) getFullBounds().getWidth();
			myTextLayout = myLineBreakMeasurer.nextLayout(_wrappingWidth);
			myTextLayouts.clear();
			myTextLayouts.add(myTextLayout);
			while (myLineBreakMeasurer.getPosition() > 0 && myLineBreakMeasurer.getPosition() < getText().length())
			{
				myTextLayouts.add(myLineBreakMeasurer.nextLayout(_wrappingWidth));
			}
		}
		catch (PaperContentIsUnattachedException _exception)
		{
			// Should not arrive
			throw new RuntimeException("Impossible error");
		}
		myBaseLineOffset = myTextLayout.getAscent();
		myTextHeight = myBaseLineOffset + myTextLayout.getDescent();
		myLineHeight = myTextHeight + myTextLayout.getLeading();

		// adjust the height
		double _realHeight = myTextHeight; // at least one line
		if (myTextLayouts.size() > 1)
		{
			_realHeight += ((myTextLayouts.size() - 1) * myLineHeight);
		}
		setCoreHeight(getContainer().convertUnitToMillimeter(_realHeight));
		super.updateInternals();
	}
386365
public void updateListSize() {

        int paramsHeight = m_params.isVisible()
        ? m_params.getOffsetHeight()
            + CmsDomUtil.getCurrentStyleInt(m_params.getElement(), CmsDomUtil.Style.marginBottom)
        : 21;
        int optionsHeight = m_options.getOffsetHeight()
            + CmsDomUtil.getCurrentStyleInt(m_options.getElement(), CmsDomUtil.Style.marginBottom);
        int listTop = paramsHeight + optionsHeight + 5;
        // another sanity check, don't set any top value below 35
        if (listTop > 35) {
            m_list.getElement().getStyle().setTop(listTop, Unit.PX);
        }
    }
627356
def load_font(self, font_path, font_size):
        """"""
        self.__font_path = font_path
        self.__font_size = font_size
        if font_path != "":
            self.__font = pygame.font.Font(font_path, font_size)
            self.__set_text(self.__text)
215669
public void setFontAndSize(BaseFont bf, float size) {
        checkWriter();
        if (size < 0.0001f && size > -0.0001f)
            throw new IllegalArgumentException("Font size too small: " + size);
        state.size = size;
        state.fontDetails = writer.addSimple(bf);
        PageResources prs = getPageResources();
        PdfName name = state.fontDetails.getFontName();
        name = prs.addFont(name, state.fontDetails.getIndirectReference());
        content.append(name.getBytes()).append(' ').append(size).append(" Tf").append_i(separator);
    }