584 lines
20 KiB
GDScript
584 lines
20 KiB
GDScript
class_name Main
|
|
extends Control
|
|
|
|
@onready var website_container: Control = %WebsiteContainer
|
|
@onready var website_background: Control = %WebsiteBackground
|
|
@onready var tab_container: TabManager = $VBoxContainer/TabContainer
|
|
@onready var search_bar: LineEdit = $VBoxContainer/HBoxContainer/LineEdit
|
|
|
|
const LOADER_CIRCLE = preload("res://Assets/Icons/loader-circle.svg")
|
|
const AUTO_SIZING_FLEX_CONTAINER = preload("res://Scripts/AutoSizingFlexContainer.gd")
|
|
|
|
const P = preload("res://Scenes/Tags/p.tscn")
|
|
const IMG = preload("res://Scenes/Tags/img.tscn")
|
|
const SEPARATOR = preload("res://Scenes/Tags/separator.tscn")
|
|
const PRE = P
|
|
const BR = preload("res://Scenes/Tags/br.tscn")
|
|
const SPAN = preload("res://Scenes/Tags/span.tscn")
|
|
const H1 = P
|
|
const H2 = P
|
|
const H3 = P
|
|
const H4 = P
|
|
const H5 = P
|
|
const H6 = P
|
|
const FORM = preload("res://Scenes/Tags/form.tscn")
|
|
const INPUT = preload("res://Scenes/Tags/input.tscn")
|
|
const BUTTON = preload("res://Scenes/Tags/button.tscn")
|
|
const UL = preload("res://Scenes/Tags/ul.tscn")
|
|
const OL = preload("res://Scenes/Tags/ol.tscn")
|
|
const SELECT = preload("res://Scenes/Tags/select.tscn")
|
|
const TEXTAREA = preload("res://Scenes/Tags/textarea.tscn")
|
|
const DIV = preload("res://Scenes/Tags/div.tscn")
|
|
const AUDIO = preload("res://Scenes/Tags/audio.tscn")
|
|
|
|
const MIN_SIZE = Vector2i(750, 200)
|
|
|
|
var font_dependent_elements: Array = []
|
|
|
|
func should_group_as_inline(element: HTMLParser.HTMLElement) -> bool:
|
|
# Don't group inputs unless they're inside a form
|
|
if element.tag_name == "input":
|
|
# Check if this element has a form ancestor
|
|
var parent = element.parent
|
|
while parent:
|
|
if parent.tag_name == "form":
|
|
return true
|
|
parent = parent.parent
|
|
return false
|
|
|
|
return element.is_inline_element()
|
|
|
|
func _ready():
|
|
ProjectSettings.set_setting("display/window/size/min_width", MIN_SIZE.x)
|
|
ProjectSettings.set_setting("display/window/size/min_height", MIN_SIZE.y)
|
|
DisplayServer.window_set_min_size(MIN_SIZE)
|
|
|
|
call_deferred("render")
|
|
|
|
var current_domain = "" # Store current domain for display
|
|
|
|
func resolve_url(href: String) -> String:
|
|
return URLUtils.resolve_url(current_domain, href)
|
|
|
|
func handle_link_click(meta: Variant) -> void:
|
|
var href = str(meta)
|
|
|
|
var resolved_url = resolve_url(href)
|
|
|
|
if GurtProtocol.is_gurt_domain(resolved_url):
|
|
_on_search_submitted(resolved_url)
|
|
else:
|
|
OS.shell_open(resolved_url)
|
|
|
|
func _on_search_submitted(url: String) -> void:
|
|
print("Search submitted: ", url)
|
|
|
|
search_bar.release_focus()
|
|
|
|
if GurtProtocol.is_gurt_domain(url):
|
|
print("Processing as GURT domain")
|
|
|
|
var tab = tab_container.tabs[tab_container.active_tab]
|
|
tab.start_loading()
|
|
|
|
var result = await GurtProtocol.handle_gurt_domain(url)
|
|
|
|
if result.has("error"):
|
|
print("GURT domain error: ", result.error)
|
|
const GLOBE_ICON = preload("res://Assets/Icons/globe.svg")
|
|
tab.stop_loading()
|
|
tab.set_icon(GLOBE_ICON)
|
|
return
|
|
|
|
var html_bytes = result.html
|
|
|
|
if result.has("display_url"):
|
|
current_domain = result.display_url
|
|
if not current_domain.begins_with("gurt://"):
|
|
current_domain = "gurt://" + current_domain
|
|
if not search_bar.has_focus():
|
|
search_bar.text = result.display_url # Show clean version in search bar
|
|
else:
|
|
current_domain = url
|
|
|
|
render_content(html_bytes)
|
|
|
|
# Stop loading spinner after successful render
|
|
tab.stop_loading()
|
|
else:
|
|
print("Non-GURT URL entered: ", url)
|
|
|
|
func _on_search_focus_entered() -> void:
|
|
if not current_domain.is_empty():
|
|
search_bar.text = current_domain
|
|
|
|
func _on_search_focus_exited() -> void:
|
|
if not current_domain.is_empty():
|
|
var display_text = current_domain
|
|
if display_text.begins_with("gurt://"):
|
|
display_text = display_text.substr(7)
|
|
search_bar.text = display_text
|
|
|
|
func render() -> void:
|
|
render_content(Constants.HTML_CONTENT)
|
|
|
|
func render_content(html_bytes: PackedByteArray) -> void:
|
|
|
|
var existing_lua_apis = []
|
|
for child in get_children():
|
|
if child is LuaAPI:
|
|
existing_lua_apis.append(child)
|
|
|
|
for lua_api in existing_lua_apis:
|
|
lua_api.kill_script_execution()
|
|
remove_child(lua_api)
|
|
lua_api.queue_free()
|
|
|
|
# Clear existing content
|
|
for child in website_container.get_children():
|
|
child.queue_free()
|
|
|
|
var current_parent = website_container.get_parent()
|
|
if current_parent and current_parent.name == "BodyMarginContainer":
|
|
var original_parent = current_parent.get_parent()
|
|
var container_index = current_parent.get_index()
|
|
|
|
current_parent.remove_child(website_container)
|
|
|
|
original_parent.remove_child(current_parent)
|
|
current_parent.queue_free()
|
|
|
|
original_parent.add_child(website_container)
|
|
original_parent.move_child(website_container, container_index)
|
|
|
|
font_dependent_elements.clear()
|
|
FontManager.clear_fonts()
|
|
FontManager.set_refresh_callback(refresh_fonts)
|
|
|
|
var parser: HTMLParser = HTMLParser.new(html_bytes)
|
|
var parse_result = parser.parse()
|
|
|
|
parser.process_styles()
|
|
|
|
if parse_result.external_css and not parse_result.external_css.is_empty():
|
|
await parser.process_external_styles(current_domain)
|
|
|
|
# Process and load all custom fonts defined in <font> tags
|
|
parser.process_fonts()
|
|
FontManager.load_all_fonts()
|
|
|
|
if parse_result.errors.size() > 0:
|
|
print("Parse errors: " + str(parse_result.errors))
|
|
|
|
var tab = tab_container.tabs[tab_container.active_tab]
|
|
|
|
var title = parser.get_title()
|
|
tab.set_title(title)
|
|
|
|
var icon = parser.get_icon()
|
|
tab.update_icon_from_url(icon)
|
|
|
|
var body = parser.find_first("body")
|
|
|
|
if body:
|
|
StyleManager.apply_body_styles(body, parser, website_container, website_background)
|
|
|
|
parser.register_dom_node(body, website_container)
|
|
|
|
var scripts = parser.find_all("script")
|
|
var lua_api = null
|
|
if scripts.size() > 0:
|
|
lua_api = LuaAPI.new()
|
|
add_child(lua_api)
|
|
|
|
var i = 0
|
|
if body:
|
|
while i < body.children.size():
|
|
var element: HTMLParser.HTMLElement = body.children[i]
|
|
|
|
if should_group_as_inline(element):
|
|
# Create an HBoxContainer for consecutive inline elements
|
|
var inline_elements: Array[HTMLParser.HTMLElement] = []
|
|
|
|
while i < body.children.size() and should_group_as_inline(body.children[i]):
|
|
inline_elements.append(body.children[i])
|
|
i += 1
|
|
|
|
var hbox = HBoxContainer.new()
|
|
hbox.add_theme_constant_override("separation", 4)
|
|
|
|
for inline_element in inline_elements:
|
|
var inline_node = await create_element_node(inline_element, parser)
|
|
if inline_node:
|
|
|
|
# Input elements register their own DOM nodes in their init() function
|
|
if inline_element.tag_name not in ["input", "textarea", "select", "button", "audio"]:
|
|
parser.register_dom_node(inline_element, inline_node)
|
|
|
|
safe_add_child(hbox, inline_node)
|
|
# Handle hyperlinks for all inline elements
|
|
if contains_hyperlink(inline_element) and inline_node is RichTextLabel:
|
|
inline_node.meta_clicked.connect(handle_link_click)
|
|
else:
|
|
print("Failed to create inline element node: ", inline_element.tag_name)
|
|
|
|
safe_add_child(website_container, hbox)
|
|
continue
|
|
|
|
var element_node = await create_element_node(element, parser)
|
|
if element_node:
|
|
|
|
# Input elements register their own DOM nodes in their init() function
|
|
if element.tag_name not in ["input", "textarea", "select", "button", "audio"]:
|
|
parser.register_dom_node(element, element_node)
|
|
|
|
# ul/ol handle their own adding
|
|
if element.tag_name != "ul" and element.tag_name != "ol":
|
|
safe_add_child(website_container, element_node)
|
|
|
|
if contains_hyperlink(element):
|
|
if element_node is RichTextLabel:
|
|
element_node.meta_clicked.connect(handle_link_click)
|
|
elif element_node.has_method("get") and element_node.get("rich_text_label"):
|
|
element_node.rich_text_label.meta_clicked.connect(handle_link_click)
|
|
else:
|
|
print("Couldn't parse unsupported HTML tag \"%s\"" % element.tag_name)
|
|
|
|
i += 1
|
|
|
|
if scripts.size() > 0 and lua_api:
|
|
parser.process_scripts(lua_api, null)
|
|
if parse_result.external_scripts and not parse_result.external_scripts.is_empty():
|
|
await parser.process_external_scripts(lua_api, null, current_domain)
|
|
|
|
static func safe_add_child(parent: Node, child: Node) -> void:
|
|
if child.get_parent():
|
|
child.get_parent().remove_child(child)
|
|
parent.add_child(child)
|
|
|
|
|
|
func contains_hyperlink(element: HTMLParser.HTMLElement) -> bool:
|
|
if element.tag_name == "a":
|
|
return true
|
|
|
|
for child in element.children:
|
|
if contains_hyperlink(child):
|
|
return true
|
|
|
|
return false
|
|
|
|
func is_text_only_element(element: HTMLParser.HTMLElement) -> bool:
|
|
if element.children.size() == 0:
|
|
var text = element.get_collapsed_text()
|
|
return not text.is_empty()
|
|
|
|
return false
|
|
|
|
func create_element_node(element: HTMLParser.HTMLElement, parser: HTMLParser) -> Control:
|
|
var styles = parser.get_element_styles_with_inheritance(element, "", [])
|
|
var hover_styles = parser.get_element_styles_with_inheritance(element, "hover", [])
|
|
var is_flex_container = styles.has("display") and ("flex" in styles["display"])
|
|
var is_grid_container = styles.has("display") and ("grid" in styles["display"])
|
|
|
|
var final_node: Control
|
|
var container_for_children: Node
|
|
|
|
# If this is an inline element AND not a flex or grid container, do NOT recursively add child nodes for its children.
|
|
# Only create a node for the outermost inline group; nested inline tags are handled by BBCode.
|
|
if element.is_inline_element() and not is_flex_container and not is_grid_container:
|
|
final_node = await create_element_node_internal(element, parser)
|
|
if not final_node:
|
|
return null
|
|
final_node = StyleManager.apply_element_styles(final_node, element, parser)
|
|
# Flex item properties may still apply
|
|
FlexUtils.apply_flex_item_properties(final_node, styles)
|
|
return final_node
|
|
|
|
if is_grid_container:
|
|
if element.tag_name == "div":
|
|
if BackgroundUtils.needs_background_wrapper(styles) or hover_styles.size() > 0:
|
|
final_node = BackgroundUtils.create_panel_container_with_background(styles, hover_styles)
|
|
var grid_container = GridContainer.new()
|
|
grid_container.name = "Grid_" + element.tag_name
|
|
var vbox = final_node.get_child(0) as VBoxContainer
|
|
vbox.add_child(grid_container)
|
|
container_for_children = grid_container
|
|
else:
|
|
final_node = GridContainer.new()
|
|
final_node.name = "Grid_" + element.tag_name
|
|
container_for_children = final_node
|
|
else:
|
|
final_node = GridContainer.new()
|
|
final_node.name = "Grid_" + element.tag_name
|
|
container_for_children = final_node
|
|
elif is_flex_container:
|
|
# The element's primary identity IS a flex container.
|
|
if element.tag_name == "div":
|
|
if BackgroundUtils.needs_background_wrapper(styles) or hover_styles.size() > 0:
|
|
final_node = BackgroundUtils.create_panel_container_with_background(styles, hover_styles)
|
|
var flex_container = AUTO_SIZING_FLEX_CONTAINER.new()
|
|
flex_container.name = "Flex_" + element.tag_name
|
|
var vbox = final_node.get_child(0) as VBoxContainer
|
|
vbox.add_child(flex_container)
|
|
container_for_children = flex_container
|
|
else:
|
|
final_node = AUTO_SIZING_FLEX_CONTAINER.new()
|
|
final_node.name = "Flex_" + element.tag_name
|
|
container_for_children = final_node
|
|
else:
|
|
final_node = AUTO_SIZING_FLEX_CONTAINER.new()
|
|
final_node.name = "Flex_" + element.tag_name
|
|
container_for_children = final_node
|
|
|
|
# For FLEX ul/ol elements, we need to create the li children directly in the flex container
|
|
if element.tag_name == "ul" or element.tag_name == "ol":
|
|
final_node.flex_direction = FlexContainer.FlexDirection.Column
|
|
|
|
website_container.add_child(final_node)
|
|
|
|
var temp_list = UL.instantiate() if element.tag_name == "ul" else OL.instantiate()
|
|
website_container.add_child(temp_list)
|
|
await temp_list.init(element, parser)
|
|
|
|
for child in temp_list.get_children():
|
|
temp_list.remove_child(child)
|
|
container_for_children.add_child(child)
|
|
|
|
website_container.remove_child(temp_list)
|
|
temp_list.queue_free()
|
|
# If the element itself has text (like <span style="flex">TEXT</span>)
|
|
elif not element.text_content.is_empty():
|
|
var new_node = await create_element_node_internal(element, parser)
|
|
container_for_children.add_child(new_node)
|
|
# For flex divs, we're done - no additional node creation needed
|
|
elif element.tag_name == "div":
|
|
pass
|
|
else:
|
|
final_node = await create_element_node_internal(element, parser)
|
|
if not final_node:
|
|
return null # Unsupported tag
|
|
|
|
# If final_node is a PanelContainer, children should go to the VBoxContainer inside
|
|
if final_node is PanelContainer and final_node.get_child_count() > 0:
|
|
container_for_children = final_node.get_child(0) # The VBoxContainer inside
|
|
else:
|
|
container_for_children = final_node
|
|
|
|
# Applies background, size, etc. to the FlexContainer (top-level node)
|
|
final_node = StyleManager.apply_element_styles(final_node, element, parser)
|
|
|
|
# Apply flex CONTAINER properties if it's a flex container
|
|
if is_flex_container:
|
|
var flex_container_node = final_node
|
|
|
|
if final_node is FlexContainer:
|
|
# Direct FlexContainer
|
|
flex_container_node = final_node
|
|
elif final_node is MarginContainer and final_node.get_child_count() > 0:
|
|
var first_child = final_node.get_child(0)
|
|
if first_child is FlexContainer:
|
|
flex_container_node = first_child
|
|
elif final_node is PanelContainer and final_node.get_child_count() > 0:
|
|
var vbox = final_node.get_child(0)
|
|
if vbox is VBoxContainer and vbox.get_child_count() > 0:
|
|
var potential_flex = vbox.get_child(0)
|
|
if potential_flex is FlexContainer:
|
|
flex_container_node = potential_flex
|
|
|
|
if flex_container_node is FlexContainer:
|
|
FlexUtils.apply_flex_container_properties(flex_container_node, styles)
|
|
|
|
if is_grid_container:
|
|
var grid_container_node = final_node
|
|
|
|
if final_node is GridContainer:
|
|
grid_container_node = final_node
|
|
elif final_node is MarginContainer and final_node.get_child_count() > 0:
|
|
var first_child = final_node.get_child(0)
|
|
if first_child is GridContainer:
|
|
grid_container_node = first_child
|
|
elif final_node is PanelContainer and final_node.get_child_count() > 0:
|
|
var vbox = final_node.get_child(0)
|
|
if vbox is VBoxContainer and vbox.get_child_count() > 0:
|
|
var potential_grid = vbox.get_child(0)
|
|
if potential_grid is GridContainer:
|
|
grid_container_node = potential_grid
|
|
|
|
if grid_container_node is GridContainer:
|
|
GridUtils.apply_grid_container_properties(grid_container_node, styles)
|
|
|
|
FlexUtils.apply_flex_item_properties(final_node, styles)
|
|
|
|
if not is_grid_container:
|
|
GridUtils.apply_grid_item_properties(final_node, styles)
|
|
|
|
# Skip ul/ol and non-flex forms, they handle their own children
|
|
var skip_general_processing = false
|
|
|
|
if element.tag_name == "ul" or element.tag_name == "ol":
|
|
skip_general_processing = true
|
|
elif element.tag_name == "form":
|
|
skip_general_processing = not is_flex_container and not is_grid_container
|
|
|
|
if not skip_general_processing:
|
|
for child_element in element.children:
|
|
# Only add child nodes if the child is NOT an inline element
|
|
# UNLESS the parent is a flex or grid container (inline elements become flex/grid items)
|
|
if not child_element.is_inline_element() or is_flex_container or is_grid_container:
|
|
var child_node = await create_element_node(child_element, parser)
|
|
if child_node and is_instance_valid(container_for_children):
|
|
# Input elements register their own DOM nodes in their init() function
|
|
if child_element.tag_name not in ["input", "textarea", "select", "button", "audio"]:
|
|
parser.register_dom_node(child_element, child_node)
|
|
safe_add_child(container_for_children, child_node)
|
|
|
|
if contains_hyperlink(child_element):
|
|
if child_node is RichTextLabel:
|
|
child_node.meta_clicked.connect(handle_link_click)
|
|
elif child_node.has_method("get") and child_node.get("rich_text_label"):
|
|
child_node.rich_text_label.meta_clicked.connect(handle_link_click)
|
|
|
|
return final_node
|
|
|
|
func create_element_node_internal(element: HTMLParser.HTMLElement, parser: HTMLParser) -> Control:
|
|
var node: Control = null
|
|
|
|
match element.tag_name:
|
|
"p":
|
|
node = P.instantiate()
|
|
node.init(element, parser)
|
|
"pre":
|
|
node = PRE.instantiate()
|
|
node.init(element, parser)
|
|
"h1", "h2", "h3", "h4", "h5", "h6":
|
|
match element.tag_name:
|
|
"h1": node = H1.instantiate()
|
|
"h2": node = H2.instantiate()
|
|
"h3": node = H3.instantiate()
|
|
"h4": node = H4.instantiate()
|
|
"h5": node = H5.instantiate()
|
|
"h6": node = H6.instantiate()
|
|
node.init(element, parser)
|
|
"br":
|
|
node = BR.instantiate()
|
|
node.init(element, parser)
|
|
"img":
|
|
node = IMG.instantiate()
|
|
node.init(element, parser)
|
|
"separator":
|
|
node = SEPARATOR.instantiate()
|
|
node.init(element, parser)
|
|
"form":
|
|
var form_styles = parser.get_element_styles_with_inheritance(element, "", [])
|
|
var is_flex_form = form_styles.has("display") and ("flex" in form_styles["display"])
|
|
|
|
if is_flex_form:
|
|
# Don't create a form node here - return null so general processing takes over
|
|
return null
|
|
else:
|
|
node = FORM.instantiate()
|
|
node.init(element, parser)
|
|
|
|
# Manually process children for non-flex forms
|
|
for child_element in element.children:
|
|
var child_node = await create_element_node(child_element, parser)
|
|
if child_node:
|
|
safe_add_child(node, child_node)
|
|
"input":
|
|
node = INPUT.instantiate()
|
|
node.init(element, parser)
|
|
"button":
|
|
node = BUTTON.instantiate()
|
|
node.init(element, parser)
|
|
"span", "b", "i", "u", "small", "mark", "code", "a":
|
|
node = SPAN.instantiate()
|
|
node.init(element, parser)
|
|
"ul":
|
|
node = UL.instantiate()
|
|
website_container.add_child(node)
|
|
await node.init(element, parser)
|
|
return node
|
|
"ol":
|
|
node = OL.instantiate()
|
|
website_container.add_child(node)
|
|
await node.init(element, parser)
|
|
return node
|
|
"li":
|
|
node = P.instantiate()
|
|
node.init(element, parser)
|
|
"select":
|
|
node = SELECT.instantiate()
|
|
node.init(element, parser)
|
|
"textarea":
|
|
node = TEXTAREA.instantiate()
|
|
node.init(element, parser)
|
|
"audio":
|
|
node = AUDIO.instantiate()
|
|
node.init(element, parser)
|
|
"div":
|
|
var styles = parser.get_element_styles_with_inheritance(element, "", [])
|
|
var hover_styles = parser.get_element_styles_with_inheritance(element, "hover", [])
|
|
var is_flex_container = styles.has("display") and ("flex" in styles["display"])
|
|
var is_grid_container = styles.has("display") and ("grid" in styles["display"])
|
|
|
|
# For flex or grid divs, let the general flex/grid container logic handle them
|
|
if is_flex_container or is_grid_container:
|
|
return null
|
|
|
|
# Create div container
|
|
if BackgroundUtils.needs_background_wrapper(styles) or hover_styles.size() > 0:
|
|
node = BackgroundUtils.create_panel_container_with_background(styles, hover_styles)
|
|
else:
|
|
node = DIV.instantiate()
|
|
node.init(element, parser)
|
|
|
|
var has_only_text = is_text_only_element(element)
|
|
|
|
if has_only_text:
|
|
var p_node = P.instantiate()
|
|
p_node.init(element, parser)
|
|
|
|
var div_styles = parser.get_element_styles_with_inheritance(element, "", [])
|
|
StyleManager.apply_styles_to_label(p_node, div_styles, element, parser)
|
|
|
|
var container_for_children = node
|
|
if node is PanelContainer and node.get_child_count() > 0:
|
|
container_for_children = node.get_child(0) # The VBoxContainer inside
|
|
|
|
safe_add_child(container_for_children, p_node)
|
|
_:
|
|
return null
|
|
|
|
return node
|
|
|
|
func register_font_dependent_element(label: Control, styles: Dictionary, element: HTMLParser.HTMLElement, parser: HTMLParser) -> void:
|
|
font_dependent_elements.append({
|
|
"label": label,
|
|
"styles": styles,
|
|
"element": element,
|
|
"parser": parser
|
|
})
|
|
|
|
func refresh_fonts(font_name: String) -> void:
|
|
# Find all elements that should use this font and refresh them
|
|
for element_info in font_dependent_elements:
|
|
var label = element_info["label"]
|
|
var styles = element_info["styles"]
|
|
var element = element_info["element"]
|
|
var parser = element_info["parser"]
|
|
|
|
if styles.has("font-family") and styles["font-family"] == font_name:
|
|
if is_instance_valid(label):
|
|
StyleManager.apply_styles_to_label(label, styles, element, parser)
|
|
|
|
func get_current_url() -> String:
|
|
return current_domain if not current_domain.is_empty() else ""
|
|
|
|
func reload_current_page() -> void:
|
|
if not current_domain.is_empty():
|
|
_on_search_submitted(current_domain)
|
|
|
|
func navigate_to_url(url: String) -> void:
|
|
var resolved_url = resolve_url(url)
|
|
_on_search_submitted(resolved_url)
|