Emulation/Gopher2600
1
0
Fork 0
mirror of https://github.com/JetSetIlly/Gopher2600.git synced 2024-05-20 05:40:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

DPI aware font scaling

Browse source 
font sizing for non-freetype font rendering
This commit is contained in:
JetSetIlly 2024-01-14 16:12:04 +00:00
parent e2e3ed3b0c
commit 24d4f2531e
15 changed files with 204 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
gui/fonts/fonts.go
View file

@ -131,3 +131,13 @@ const (
HackMin = '\u0003'
HackMax = '\u1ef9'
)
//go:embed "JetBrainsMono-Regular.ttf"
var JetBrainsMono []byte
// The first and last unicode points used in the application. We use this to
// make sure we're using as small a font texture as possible.
const (
JetBrainsMonoMin = '\u0003'
JetBrainsMonoMax = '\u00ff'
)

161
gui/sdlimgui/atlas.go
View file

@ -17,15 +17,22 @@ package sdlimgui
import (
"fmt"
"math"
"github.com/inkyblackness/imgui-go/v4"
"github.com/jetsetilly/gopher2600/gui/fonts"
)
type fontDisplay interface {
displayDPI() (float32, error)
}
type fontAtlas struct {
// default font
defaultFont imgui.Font
defaultFontSize float32
display fontDisplay
// gui font
gui imgui.Font
guiSize float32
// used for notifications (eg. network access, etc.)
largeFontAwesome imgui.Font
@ -52,34 +59,18 @@ type fontAtlas struct {
codeSize float32
}
func (atlas *fontAtlas) mergeFontAwesome(size float32, adjust float32) error {
fnts := imgui.CurrentIO().Fonts()
// config for font loading. merging with default font and adjusting offset
// so that the icons align better.
mergeConfig := imgui.NewFontConfig()
defer mergeConfig.Delete()
mergeConfig.SetMergeMode(true)
mergeConfig.SetPixelSnapH(true)
mergeConfig.SetGlyphOffsetY(adjust)
// limit what glyphs we load
var glyphBuilder imgui.GlyphRangesBuilder
glyphBuilder.Add(fonts.FontAwesomeMin, fonts.FontAwesomeMax)
// merge font awesome
merge := fnts.AddFontFromMemoryTTFV(fonts.FontAwesome, size, mergeConfig, glyphBuilder.Build().GlyphRanges)
if merge == 0 {
return fmt.Errorf("font: error loading font-awesome from memory")
}
return nil
func scaleFontForDPI(pt float32, dpi float32) float32 {
return float32(math.Round(float64(pt * (dpi / 72))))
}
func (atlas *fontAtlas) initialise(renderer renderer, prefs *preferences) error {
fnts := imgui.CurrentIO().Fonts()
func (atlas *fontAtlas) initialise(display fontDisplay, renderer renderer, prefs *preferences) error {
setFontBuilderFlags(imgui.CurrentIO().Fonts())
dpi, err := display.displayDPI()
if err != nil {
return fmt.Errorf("font: %w", err)
}
err := atlas.setDefaultFont(prefs)
err = atlas.setDefaultFont(prefs, dpi)
if err != nil {
return err
}
@ -94,7 +85,7 @@ func (atlas *fontAtlas) initialise(renderer renderer, prefs *preferences) error
largeFontAwesomeBuilder.Add(fonts.FontAwesomeMin, fonts.FontAwesomeMax)
atlas.largeFontAwesomeSize = 22.0
atlas.largeFontAwesome = fnts.AddFontFromMemoryTTFV(fonts.FontAwesome, atlas.largeFontAwesomeSize, largeFontAwesomeConfig, largeFontAwesomeBuilder.Build().GlyphRanges)
atlas.largeFontAwesome = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.FontAwesome, atlas.largeFontAwesomeSize, largeFontAwesomeConfig, largeFontAwesomeBuilder.Build().GlyphRanges)
if atlas.largeFontAwesome == 0 {
return fmt.Errorf("font: error loading font-awesome from memory")
}
@ -110,7 +101,7 @@ func (atlas *fontAtlas) initialise(renderer renderer, prefs *preferences) error
veryLargeFontAwesomeBuilder.Add(fonts.FontAwesomeMin, fonts.FontAwesomeMax)
atlas.veryLargeFontAwesomeSize = 44.0
atlas.veryLargeFontAwesome = fnts.AddFontFromMemoryTTFV(fonts.FontAwesome, atlas.veryLargeFontAwesomeSize, veryLargeFontAwesomeConfig, veryLargeFontAwesomeBuilder.Build().GlyphRanges)
atlas.veryLargeFontAwesome = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.FontAwesome, atlas.veryLargeFontAwesomeSize, veryLargeFontAwesomeConfig, veryLargeFontAwesomeBuilder.Build().GlyphRanges)
if atlas.veryLargeFontAwesome == 0 {
return fmt.Errorf("font: error loading font-awesome from memory")
}
@ -127,7 +118,7 @@ func (atlas *fontAtlas) initialise(renderer renderer, prefs *preferences) error
gopher2600IconBuilder.Add(fonts.Gopher2600IconMin, fonts.Gopher2600IconMax)
atlas.gopher2600IconsSize = 60.0
atlas.gopher2600Icons = fnts.AddFontFromMemoryTTFV(fonts.Gopher2600Icons, atlas.gopher2600IconsSize, gopher2600IconConfig, gopher2600IconBuilder.Build().GlyphRanges)
atlas.gopher2600Icons = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.Gopher2600Icons, atlas.gopher2600IconsSize, gopher2600IconConfig, gopher2600IconBuilder.Build().GlyphRanges)
if atlas.gopher2600Icons == 0 {
return fmt.Errorf("font: error loading Gopher2600 font from memory")
}
@ -142,32 +133,120 @@ func (atlas *fontAtlas) initialise(renderer renderer, prefs *preferences) error
var diagramBuilder imgui.GlyphRangesBuilder
diagramBuilder.Add(fonts.HackMin, fonts.HackMax)
if atlas.isFreeType() {
atlas.diagramSize = 10.0
} else {
atlas.diagramSize = 11.0
}
atlas.diagram = fnts.AddFontFromMemoryTTFV(fonts.Hack, atlas.diagramSize, diagramConfig, diagramBuilder.Build().GlyphRanges)
atlas.diagramSize = scaleFontForDPI(10.0, dpi)
atlas.diagram = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.Hack, atlas.diagramSize, diagramConfig, diagramBuilder.Build().GlyphRanges)
if atlas.diagram == 0 {
return fmt.Errorf("font: error loading hack font from memory")
}
}
// load terminal font
err = atlas.terminalFont(prefs)
err = atlas.terminalFont(prefs, dpi)
if err != nil {
return fmt.Errorf("font: %w", err)
}
// load source code font
err = atlas.sourceCodeFont(prefs)
err = atlas.sourceCodeFont(prefs, dpi)
if err != nil {
return fmt.Errorf("font: %w", err)
}
// create textures and register with imgui
tex := renderer.addFontTexture(fnts)
fnts.SetTextureID(imgui.TextureID(tex.getID()))
tex := renderer.addFontTexture(imgui.CurrentIO().Fonts())
imgui.CurrentIO().Fonts().SetTextureID(imgui.TextureID(tex.getID()))
return nil
}
func (atlas *fontAtlas) setDefaultFont(prefs *preferences, dpi float32) error {
guiFontSize := float32(prefs.guiFontSize.Get().(int))
if atlas.guiSize != 0 && guiFontSize == atlas.guiSize {
return nil
}
atlas.guiSize = guiFontSize
// load gui font
cfg := imgui.NewFontConfig()
defer cfg.Delete()
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
guiFontSize = scaleFontForDPI(guiFontSize, dpi)
atlas.gui = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.JetBrainsMono, guiFontSize, cfg, builder.Build().GlyphRanges)
if atlas.gui == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
atlas.mergeFontAwesome(guiFontSize, 1.0)
return nil
}
func (atlas *fontAtlas) sourceCodeFont(prefs *preferences, dpi float32) error {
codeSize := float32(prefs.codeFontSize.Get().(int))
if atlas.codeSize != 0 && codeSize == atlas.codeSize {
return nil
}
atlas.codeSize = codeSize
cfg := imgui.NewFontConfig()
defer cfg.Delete()
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
codeSize = scaleFontForDPI(codeSize, dpi)
atlas.code = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.JetBrainsMono, codeSize, cfg, builder.Build().GlyphRanges)
if atlas.code == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
atlas.mergeFontAwesome(codeSize, 0.0)
return nil
}
func (atlas *fontAtlas) terminalFont(prefs *preferences, dpi float32) error {
terminalSize := float32(prefs.terminalFontSize.Get().(int))
if atlas.terminalSize != 0 && terminalSize == atlas.terminalSize {
return nil
}
atlas.terminalSize = terminalSize
cfg := imgui.NewFontConfig()
defer cfg.Delete()
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
terminalSize = scaleFontForDPI(terminalSize, dpi)
atlas.terminal = imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.JetBrainsMono, terminalSize, cfg, builder.Build().GlyphRanges)
if atlas.terminal == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
atlas.mergeFontAwesome(terminalSize, 0.0)
return nil
}
func (atlas *fontAtlas) mergeFontAwesome(size float32, adjust float32) error {
mergeConfig := imgui.NewFontConfig()
defer mergeConfig.Delete()
mergeConfig.SetMergeMode(true)
mergeConfig.SetGlyphOffsetY(adjust)
// limit what glyphs we load
var glyphBuilder imgui.GlyphRangesBuilder
glyphBuilder.Add(fonts.FontAwesomeMin, fonts.FontAwesomeMax)
// merge font awesome
merge := imgui.CurrentIO().Fonts().AddFontFromMemoryTTFV(fonts.FontAwesome, size, mergeConfig, glyphBuilder.Build().GlyphRanges)
if merge == 0 {
return fmt.Errorf("font: error loading font-awesome from memory")
}
return nil
}

19
gui/fonts/fonts_freetype.go → gui/sdlimgui/atlas_basic.go
View file

@ -1,4 +1,4 @@
//go:build imguifreetype
//go:build !imguifreetype
// This file is part of Gopher2600.
//
@ -15,16 +15,13 @@
// You should have received a copy of the GNU General Public License
// along with Gopher2600. If not, see <https://www.gnu.org/licenses/>.
package fonts
package sdlimgui
import _ "embed"
import "github.com/inkyblackness/imgui-go/v4"
//go:embed "JetBrainsMono-Regular.ttf"
var JetBrainsMono []byte
func usingFreetypeRendering() bool {
return false
}
// The first and last unicode points used in the application. We use this to
// make sure we're using as small a font texture as possible.
const (
JetBrainsMonoMin = '\u0003'
JetBrainsMonoMax = '\u00ff'
)
func setFontBuilderFlags(atlas imgui.FontAtlas) {
}

90
gui/sdlimgui/atlas_freetype.go
View file

@ -17,96 +17,12 @@
package sdlimgui
import (
"fmt"
import "github.com/inkyblackness/imgui-go/v4"
"github.com/inkyblackness/imgui-go/v4"
"github.com/jetsetilly/gopher2600/gui/fonts"
)
func (fnts *fontAtlas) isFreeType() bool {
func usingFreetypeRendering() bool {
return true
}
func (fnts *fontAtlas) setDefaultFont(prefs *preferences) error {
defaultFontSize := float32(prefs.guiFont.Get().(float64))
if fnts.defaultFont != 0 && defaultFontSize == fnts.defaultFontSize {
return nil
}
atlas := imgui.CurrentIO().Fonts()
func setFontBuilderFlags(atlas imgui.FontAtlas) {
atlas.SetFontBuilderFlags(imgui.FreeTypeBuilderFlagsForceAutoHint)
// load gui font (default)
cfg := imgui.NewFontConfig()
defer cfg.Delete()
cfg.SetPixelSnapH(true)
if int(defaultFontSize)%2 == 0.0 {
cfg.SetGlyphOffsetY(1.0)
}
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
fnts.defaultFontSize = float32(defaultFontSize)
fnts.defaultFont = atlas.AddFontFromMemoryTTFV(fonts.JetBrainsMono, fnts.defaultFontSize, cfg, builder.Build().GlyphRanges)
if fnts.defaultFont == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
fnts.mergeFontAwesome(fnts.defaultFontSize, 1.0)
return nil
}
func (fnts *fontAtlas) sourceCodeFont(prefs *preferences) error {
codeSize := float32(prefs.codeFont.Get().(float64))
if fnts.code != 0 && codeSize == fnts.codeSize {
return nil
}
atlas := imgui.CurrentIO().Fonts()
cfg := imgui.NewFontConfig()
defer cfg.Delete()
cfg.SetPixelSnapH(true)
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
fnts.codeSize = codeSize
fnts.code = atlas.AddFontFromMemoryTTFV(fonts.JetBrainsMono, fnts.codeSize, cfg, builder.Build().GlyphRanges)
if fnts.code == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
fnts.mergeFontAwesome(fnts.codeSize, 0.0)
return nil
}
func (fnts *fontAtlas) terminalFont(prefs *preferences) error {
terminalSize := float32(prefs.terminalFont.Get().(float64))
if fnts.terminal != 0 && terminalSize == fnts.terminalSize {
return nil
}
atlas := imgui.CurrentIO().Fonts()
cfg := imgui.NewFontConfig()
defer cfg.Delete()
cfg.SetPixelSnapH(true)
var builder imgui.GlyphRangesBuilder
builder.Add(fonts.JetBrainsMonoMin, fonts.JetBrainsMonoMax)
fnts.terminalSize = terminalSize
fnts.terminal = atlas.AddFontFromMemoryTTFV(fonts.JetBrainsMono, fnts.terminalSize, cfg, builder.Build().GlyphRanges)
if fnts.terminal == 0 {
return fmt.Errorf("font: error loading JetBrainsMono font from memory")
}
fnts.mergeFontAwesome(fnts.terminalSize, 0.0)
return nil
}

51
gui/sdlimgui/atlas_proggyclean.go
View file

@ -1,51 +0,0 @@
//go:build !imguifreetype
// This file is part of Gopher2600.
//
// Gopher2600 is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Gopher2600 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Gopher2600. If not, see <https://www.gnu.org/licenses/>.
package sdlimgui
import (
"github.com/inkyblackness/imgui-go/v4"
)
func (fnts *fontAtlas) isFreeType() bool {
return false
}
func (fnts *fontAtlas) setDefaultFont(prefs *preferences) error {
// default font has already been set up
if fnts.defaultFont != 0 {
return nil
}
atlas := imgui.CurrentIO().Fonts()
fnts.defaultFont = atlas.AddFontDefault()
fnts.defaultFontSize = 13.0
fnts.mergeFontAwesome(fnts.defaultFontSize, 2.0)
return nil
}
func (fnts *fontAtlas) sourceCodeFont(prefs *preferences) error {
fnts.code = fnts.defaultFont
fnts.codeSize = fnts.defaultFontSize
return nil
}
func (fnts *fontAtlas) terminalFont(prefs *preferences) error {
fnts.terminal = fnts.defaultFont
fnts.terminalSize = fnts.defaultFontSize
return nil
}

2
gui/sdlimgui/modal_unsupported_DWARF.go
View file

@ -58,7 +58,7 @@ func (img *SdlImgui) modalDrawUnsupportedDWARF() {
imgui.Separator()
imgui.Spacing()
sz := imgui.ContentRegionAvail()
sz.Y = img.fonts.defaultFontSize
sz.Y = img.fonts.guiSize
sz.Y += imgui.CurrentStyle().CellPadding().Y * 2
sz.Y += imgui.CurrentStyle().FramePadding().Y * 2
if imgui.ButtonV("Continue without DWARF data", sz) {

10
gui/sdlimgui/platform.go
View file

@ -261,6 +261,16 @@ func (plt *platform) displaySize() [2]float32 {
return [2]float32{float32(w), float32(h)}
}
// displayDPI returns the dots/inch for the display the window is in
func (plt *platform) displayDPI() (float32, error) {
ww, _ := plt.window.GetSize()
dw, _ := plt.window.GLGetDrawableSize()
dpiScale := float32(ww) / float32(dw)
_, dpi, _, err := sdl.GetDisplayDPI(0)
return dpi * dpiScale, err
}
// framebufferSize returns the dimension of the framebuffer.
func (plt *platform) framebufferSize() [2]float32 {
w, h := plt.window.GLGetDrawableSize()

18
gui/sdlimgui/preferences.go
View file

@ -63,9 +63,9 @@ type preferences struct {
notificationVisibility prefs.Float
// fonts
guiFont prefs.Float
terminalFont prefs.Float
codeFont prefs.Float
guiFontSize prefs.Int
terminalFontSize prefs.Int
codeFontSize prefs.Int
codeFontLineSpacing prefs.Int
// display
@ -101,9 +101,9 @@ func newPreferences(img *SdlImgui) (*preferences, error) {
p.coprocDevNotification.Set(true)
p.coprocDevNotification.Set(true)
p.notificationVisibility.Set(0.75)
p.guiFont.Set(13.0)
p.terminalFont.Set(13.0)
p.codeFont.Set(15.0)
p.guiFontSize.Set(13)
p.terminalFontSize.Set(12)
p.codeFontSize.Set(15)
p.codeFontLineSpacing.Set(2.0)
p.frameQueueAuto.Set(false)
p.frameQueue.Set(5)
@ -177,15 +177,15 @@ func newPreferences(img *SdlImgui) (*preferences, error) {
// playmode audio mute options later
// fonts (only used when compiled with imguifreetype build tag)
err = p.dsk.Add("sdlimgui.fonts.gui", &p.guiFont)
err = p.dsk.Add("sdlimgui.fonts.size.gui", &p.guiFontSize)
if err != nil {
return nil, err
}
err = p.dsk.Add("sdlimgui.fonts.terminal", &p.terminalFont)
err = p.dsk.Add("sdlimgui.fonts.size.terminal", &p.terminalFontSize)
if err != nil {
return nil, err
}
err = p.dsk.Add("sdlimgui.fonts.code", &p.codeFont)
err = p.dsk.Add("sdlimgui.fonts.size.code", &p.codeFontSize)
if err != nil {
return nil, err
}

2
gui/sdlimgui/sdlimgui.go
View file

@ -312,7 +312,7 @@ func (img *SdlImgui) draw() {
return
}
imgui.PushFont(img.fonts.defaultFont)
imgui.PushFont(img.fonts.gui)
defer imgui.PopFont()
if mode == govern.ModePlay {

2
gui/sdlimgui/service.go
View file

@ -36,7 +36,7 @@ func (img *SdlImgui) Service() {
// handle font reset procedure
if img.resetFonts >= 1 {
if img.resetFonts == 1 {
err = img.fonts.initialise(img.rnd, img.prefs)
err = img.fonts.initialise(img.plt, img.rnd, img.prefs)
if err != nil {
panic(err)
}

2
gui/sdlimgui/win_cart_cdf_streams.go
View file

@ -189,7 +189,7 @@ func (win *winCDFStreams) debuggerDraw() bool {
}
func (win *winCDFStreams) draw(regs cdf.Registers, static mapper.CartStatic) {
scaling := float32(win.img.prefs.guiFont.Get().(float64)) / 10
scaling := float32(win.img.prefs.guiFontSize.Get().(float64)) / 10
if imgui.BeginChildV("##stream", imgui.Vec2{Y: imguiRemainingWinHeight() - win.optionsHeight}, false, imgui.WindowFlagsNone) {
win.updateStreams(regs, static)

51
gui/sdlimgui/win_prefs.go
View file

@ -607,39 +607,34 @@ func (win *winPrefs) drawPlusROMTab() {
func (win *winPrefs) drawUITab() {
imgui.Spacing()
if !win.img.fonts.isFreeType() {
imgui.Text("No options for UI in this version of Gopher2600")
return
}
if imgui.CollapsingHeaderV("Font Sizing and Spacing", imgui.TreeNodeFlagsDefaultOpen) {
imgui.Spacing()
var resetFonts bool
const (
minFontSize = 10.0
maxFontSize = 30.0
minFontSize = 8
maxFontSize = 30
)
// flags to be used in float slider
sliderFlags := imgui.SliderFlagsAlwaysClamp | imgui.SliderFlagsNoInput
// gui font
guiSize := float32(win.img.prefs.guiFont.Get().(float64))
if imgui.SliderFloatV("##guiFontSizeSlider", &guiSize, minFontSize, maxFontSize, "%0.1fpt", sliderFlags) {
win.img.prefs.guiFont.Set(guiSize)
guiSize := int32(win.img.prefs.guiFontSize.Get().(int))
if imgui.SliderIntV("##guiFontSizeSlider", &guiSize, minFontSize, maxFontSize, "%dpt", sliderFlags) {
win.img.prefs.guiFontSize.Set(guiSize)
}
if imgui.IsItemDeactivatedAfterEdit() {
resetFonts = true
}
imgui.SameLineV(0, 5)
guiSizeS := fmt.Sprintf("%0.1f", guiSize)
if imguiFloatingPointInput("GUI Font Size##guiFontSize", 5, &guiSizeS) {
if sz, err := strconv.ParseFloat(guiSizeS, 32); err == nil {
guiSizeS := fmt.Sprintf("%d", guiSize)
if imguiDecimalInput("GUI Font Size##guiFontSize", 3, &guiSizeS) {
if sz, err := strconv.ParseInt(guiSizeS, 10, 32); err == nil {
if sz >= minFontSize && sz <= maxFontSize {
win.img.prefs.guiFont.Set(sz)
win.img.prefs.guiFontSize.Set(sz)
resetFonts = true
}
}
@ -648,20 +643,20 @@ func (win *winPrefs) drawUITab() {
imgui.Spacing()
// terminal font
terminalSize := float32(win.img.prefs.terminalFont.Get().(float64))
if imgui.SliderFloatV("##terminalFontSizeSlider", &terminalSize, minFontSize, maxFontSize, "%0.1fpt", sliderFlags) {
win.img.prefs.terminalFont.Set(terminalSize)
terminalSize := int32(win.img.prefs.terminalFontSize.Get().(int))
if imgui.SliderIntV("##terminalFontSizeSlider", &terminalSize, minFontSize, maxFontSize, "%dpt", sliderFlags) {
win.img.prefs.terminalFontSize.Set(terminalSize)
}
if imgui.IsItemDeactivatedAfterEdit() {
resetFonts = true
}
imgui.SameLineV(0, 5)
terminalSizeS := fmt.Sprintf("%0.1f", terminalSize)
if imguiFloatingPointInput("Terminal Font Size##terminalFontSize", 5, &terminalSizeS) {
if sz, err := strconv.ParseFloat(terminalSizeS, 32); err == nil {
terminalSizeS := fmt.Sprintf("%d", terminalSize)
if imguiDecimalInput("Terminal Font Size##terminalFontSize", 3, &terminalSizeS) {
if sz, err := strconv.ParseInt(terminalSizeS, 10, 32); err == nil {
if sz >= minFontSize && sz <= maxFontSize {
win.img.prefs.terminalFont.Set(sz)
win.img.prefs.terminalFontSize.Set(sz)
resetFonts = true
}
}
@ -670,20 +665,20 @@ func (win *winPrefs) drawUITab() {
imgui.Spacing()
// code font
codeSize := float32(win.img.prefs.codeFont.Get().(float64))
if imgui.SliderFloatV("##codeFontSizeSlider", &codeSize, minFontSize, maxFontSize, "%0.1fpt", sliderFlags) {
win.img.prefs.codeFont.Set(codeSize)
codeSize := int32(win.img.prefs.codeFontSize.Get().(int))
if imgui.SliderIntV("##codeFontSizeSlider", &codeSize, minFontSize, maxFontSize, "%dpt", sliderFlags) {
win.img.prefs.codeFontSize.Set(codeSize)
}
if imgui.IsItemDeactivatedAfterEdit() {
resetFonts = true
}
imgui.SameLineV(0, 5)
codeSizeS := fmt.Sprintf("%0.1f", codeSize)
if imguiFloatingPointInput("Code Font Size##codeFontSize", 5, &codeSizeS) {
if sz, err := strconv.ParseFloat(codeSizeS, 32); err == nil {
codeSizeS := fmt.Sprintf("%d", codeSize)
if imguiDecimalInput("Code Font Size##codeFontSize", 3, &codeSizeS) {
if sz, err := strconv.ParseInt(codeSizeS, 10, 32); err == nil {
if sz >= minFontSize && sz <= maxFontSize {
win.img.prefs.codeFont.Set(sz)
win.img.prefs.codeFontSize.Set(sz)
resetFonts = true
}
}

2
gui/sdlimgui/win_timeline.go
View file

@ -240,7 +240,7 @@ func (win *winTimeline) drawTrace() {
)
// the amount to allow for the icons when centering etc.
iconRadius := win.img.fonts.defaultFontSize / 2
iconRadius := win.img.fonts.guiSize / 2
// the width that can be seen in the window at any one time. reduce by the
// iconRadius*2 value to allow for the TV icon (current frame icon) when it

3
prefs/defunct.go
View file

@ -60,6 +60,9 @@ var defunct = []string{
"plusrom.id", // replaced with plusrom.id_v2.1.1
"crt.noise",
"crt.noiseLevel",
"sdlimgui.fonts.gui",
"sdlimgui.fonts.terminal",
"sdlimgui.fonts.code",
}
// returns true if string is in list of defunct values.

26
prefs/types.go
View file

@ -67,13 +67,13 @@ func (p *Bool) Set(v Value) error {
nv = false
}
default:
return fmt.Errorf("prefs: cannot convert %T to prefs.Bool", v)
return fmt.Errorf("set: cannot convert %T to prefs.Bool", v)
}
if p.hookPre != nil {
err := p.hookPre(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -83,7 +83,7 @@ func (p *Bool) Set(v Value) error {
if p.hookPost != nil {
err := p.hookPost(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -169,7 +169,7 @@ func (p *String) Set(v Value) error {
if p.hookPre != nil {
err := p.hookPre(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -179,7 +179,7 @@ func (p *String) Set(v Value) error {
if p.hookPost != nil {
err := p.hookPost(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -245,16 +245,16 @@ func (p *Int) Set(v Value) error {
var err error
nv, err = strconv.Atoi(v)
if err != nil {
return fmt.Errorf("prefs: cannot convert %T to prefs.Int", v)
return fmt.Errorf("set: cannot convert %T to prefs.Int: %w", v, err)
}
default:
return fmt.Errorf("prefs: cannot convert %T to prefs.Int", v)
return fmt.Errorf("set: cannot convert %T to prefs.Int", v)
}
if p.hookPre != nil {
err := p.hookPre(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -264,7 +264,7 @@ func (p *Int) Set(v Value) error {
if p.hookPost != nil {
err := p.hookPost(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -334,16 +334,16 @@ func (p *Float) Set(v Value) error {
var err error
nv, err = strconv.ParseFloat(v, 64)
if err != nil {
return fmt.Errorf("prefs: cannot convert %T to prefs.Float", v)
return fmt.Errorf("set: cannot convert %T to prefs.Float: %w", v, err)
}
default:
return fmt.Errorf("prefs: cannot convert %T to prefs.Float", v)
return fmt.Errorf("set: cannot convert %T to prefs.Float", v)
}
if p.hookPre != nil {
err := p.hookPre(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}
@ -353,7 +353,7 @@ func (p *Float) Set(v Value) error {
if p.hookPost != nil {
err := p.hookPost(nv)
if err != nil {
return fmt.Errorf("prefs: %w", err)
return err
}
}