amfora/display/private.go

155 lines
4.2 KiB
Go
Raw Normal View History

2020-06-18 23:54:48 +03:00
package display
2021-12-23 01:09:47 +03:00
// This file contains the functions that aren't part of the public API.
// The funcs are for network and displaying.
2020-06-18 23:54:48 +03:00
import (
"net/url"
2020-08-05 20:31:59 +03:00
"strconv"
2020-06-18 23:54:48 +03:00
"strings"
"github.com/makeworld-the-better-one/amfora/renderer"
"github.com/makeworld-the-better-one/amfora/structs"
)
2021-12-23 01:09:47 +03:00
// followLink should be used when the user "clicks" a link on a page,
// but not when a URL is opened on a new tab for the first time.
//
// It will handle updating the bottomBar.
//
// It should be called with the `go` keyword to spawn a new goroutine if
// it would otherwise block the UI loop, such as when called from an input
// handler.
//
// It blocks until navigation is finished, and we've completed any user
// interaction related to loading the URL (such as info, error modals)
func followLink(t *tab, prev, next string) {
if strings.HasPrefix(next, "about:") {
2021-12-23 01:09:47 +03:00
goURL(t, next)
return
}
if t.hasContent() && !t.isAnAboutPage() {
nextURL, err := resolveRelLink(t, prev, next)
if err != nil {
2020-07-01 20:39:13 +03:00
Error("URL Error", err.Error())
return
}
2021-12-23 01:09:47 +03:00
goURL(t, nextURL)
return
}
// No content on current tab, so the "prev" URL is not valid.
// An example is the about:newtab page
_, err := url.Parse(next)
2020-06-18 23:54:48 +03:00
if err != nil {
2020-06-19 21:05:05 +03:00
Error("URL Error", "Link URL could not be parsed")
2020-06-18 23:54:48 +03:00
return
}
2021-12-23 01:09:47 +03:00
goURL(t, next)
2020-06-18 23:54:48 +03:00
}
// reformatPage will take the raw page content and reformat it according to the current terminal dimensions.
// It should be called when the terminal size changes.
// It will not waste resources if the passed page is already fitted to the current terminal width, and can be
// called safely even when the page might be already formatted properly.
func reformatPage(p *structs.Page) {
2021-02-28 02:17:49 +03:00
if p.TermWidth == termW {
// No changes to make
return
}
// TODO: Setup a renderer.RenderFromMediatype func so this isn't needed
var rendered string
switch p.Mediatype {
case structs.TextGemini:
// Links are not recorded because they won't change
proxied := true
if strings.HasPrefix(p.URL, "gemini") ||
strings.HasPrefix(p.URL, "about") ||
strings.HasPrefix(p.URL, "file") {
proxied = false
}
2021-02-28 05:18:03 +03:00
rendered, _ = renderer.RenderGemini(p.Raw, textWidth(), proxied)
case structs.TextPlain:
rendered = renderer.RenderPlainText(p.Raw)
case structs.TextAnsi:
rendered = renderer.RenderANSI(p.Raw)
default:
// Rendering this type is not implemented
return
}
p.Content = rendered
2021-02-28 02:17:49 +03:00
p.TermWidth = termW
}
2020-07-04 18:32:11 +03:00
// reformatPageAndSetView is for reformatting a page that is already being displayed.
// setPage should be used when a page is being loaded for the first time.
func reformatPageAndSetView(t *tab, p *structs.Page) {
2021-02-28 02:17:49 +03:00
if p.TermWidth == termW {
// No changes to make
return
}
2020-07-03 19:22:44 +03:00
reformatPage(p)
t.view.SetText(p.Content)
t.applyScroll() // Go back to where you were, roughly
App.Draw()
}
// setPage displays a Page on the passed tab number.
// The bottomBar is not actually changed in this func
func setPage(t *tab, p *structs.Page) {
if !isValidTab(t) {
// Don't waste time reformatting an invalid tab
return
}
// Make sure the page content is fitted to the terminal every time it's displayed
reformatPage(p)
t.page = p
2020-08-05 20:31:59 +03:00
// Change page on screen
t.view.SetText(p.Content)
t.view.Highlight("") // Turn off highlights, other funcs may restore if necessary
t.view.ScrollToBeginning()
2021-02-28 02:17:49 +03:00
// Reset page left margin
tabNum := tabNumber(t)
2021-02-28 02:17:49 +03:00
browser.AddTab(
strconv.Itoa(tabNum),
t.label(),
2021-02-28 02:17:49 +03:00
makeContentLayout(t.view, leftMargin()),
)
App.Draw()
2020-06-18 23:54:48 +03:00
// Setup display
App.SetFocus(t.view)
// Save bottom bar for the tab - other funcs will apply/display it
t.barLabel = ""
t.barText = p.URL
}
// goURL is like handleURL, but takes care of history and the bottomBar.
// It should be preferred over handleURL in most cases.
// It has no return values to be processed.
//
// It should be called in a goroutine.
func goURL(t *tab, u string) {
// Update page cache in history for #122
t.historyCachePage()
final, displayed := handleURL(t, u, 0)
if displayed {
t.addToHistory(final)
} else if t.page.URL == "" {
// The tab is showing interstitial or no content. Let's go to about:newtab.
handleAbout(t, "about:newtab")
}
if t == tabs[curTab] {
// Display the bottomBar state that handleURL set
t.applyBottomBar()
}
2020-06-18 23:54:48 +03:00
}