455 lines
18 KiB
Ziran
455 lines
18 KiB
Ziran
// The screen of an app the node offers, such as Chess. The app draws itself
|
|
// with hosted Kryon widgets; this screen supplies its frame, its text in the
|
|
// person's language and the account's friends.
|
|
#import "byte_text_linux"
|
|
#import "text_buffer"
|
|
#import "json_scan"
|
|
#import "vec"
|
|
#import "text"
|
|
#import "session"
|
|
#import "geometry"
|
|
#import "text_props"
|
|
#import "text_align"
|
|
#import "text_widget"
|
|
#import "bundle_host"
|
|
#import "hosted_values"
|
|
#import "widget_host"
|
|
#import "widget_codec"
|
|
#import "kryon/app_context_host"
|
|
#import "layout_props"
|
|
#import "loading_indicator"
|
|
#import "progress_widget"
|
|
#import "progress_props"
|
|
#import "drawing_props"
|
|
#import "box_widget"
|
|
#import "box_props"
|
|
#import "layout"
|
|
#import "layout_widget"
|
|
#import "tree"
|
|
#import "tree_input"
|
|
#import "test_driver"
|
|
#import, file "../platform/raylib_text_input.zi";
|
|
#if #defined(PLATFORM_WEB) == false {
|
|
#import "kryon/raylib_runtime"
|
|
}
|
|
#import, file "../apps/node_apps.zi";
|
|
#import, file "../apps/node_app_runner.zi";
|
|
#import, file "../apps/node_app_open.zi";
|
|
#import, file "../apps/node_app_tree.zi";
|
|
#import, file "../app/smooth_frames.zi";
|
|
#import, file "../apps/node_app_input.zi";
|
|
#import "apps/node_types"
|
|
#import "apps/node_codec"
|
|
#import, file "../apps/lists_network.zi";
|
|
#import, file "../apps/hosted_assets.zi";
|
|
#import, file "../apps/package_files.zi";
|
|
#import, file "../apps/package_manager.zi";
|
|
#import, file "../apps/catalog.zi";
|
|
#import, file "../apps/module_host.zi";
|
|
#import, file "../app/app_types.zi";
|
|
#import, file "../app/app.zi";
|
|
#import, file "../app/app_nav_state.zi";
|
|
#import, file "../app/app_launcher_state.zi";
|
|
#import, file "../app/app_modal_state.zi";
|
|
#import, file "../app/modal_rules.zi";
|
|
#import, file "../app/locale.zi";
|
|
#import, file "../app/metrics.zi";
|
|
#import, file "../app/text_buffers.zi";
|
|
#import, file "../core/types.zi";
|
|
#import, file "../storage/storage_settings.zi";
|
|
#import, file "../storage/db.zi";
|
|
#import, file "profile_social.zi";
|
|
#import, file "../apps/media_store.zi";
|
|
#import, file "../platform/environment.zi";
|
|
#import, file "../platform/android/android_import.zi";
|
|
#import "file_picker"
|
|
#import "file_linux"
|
|
#import "android_picker"
|
|
#import, file "node_app_loading.zi";
|
|
|
|
using HostValueKind;
|
|
using TextWrap;
|
|
using TextAlign;
|
|
using AndroidImportKind;
|
|
|
|
c :: #system_library "c";
|
|
GetTime :: () -> float64 #foreign c;
|
|
NodePressedKey :: () -> s32 #foreign c "GetKeyPressed";
|
|
NodeKeyRepeated :: (key: s32) -> bool #foreign c "IsKeyPressedRepeat";
|
|
|
|
// A held key repeats as the system repeats typing, so a game keeps moving
|
|
// while an arrow is held; GetKeyPressed reports only the first press.
|
|
NodeRepeatedKey :: () -> s32 {
|
|
for key: cast(s32)32..348 {
|
|
if NodeKeyRepeated(key) { return key }
|
|
}
|
|
return 0
|
|
}
|
|
app_request_social_refresh :: (app: *InnerBreeze) #foreign c;
|
|
|
|
node_screen_frame: AppUiFrame;
|
|
node_screen_frame_codec: WidgetAppUiFrameCodec;
|
|
node_screen_person_codec: WidgetAppPersonCodec;
|
|
node_screen_friend_id: [80]u8;
|
|
node_screen_friend_name: [80]u8;
|
|
node_screen_alias: [80]u8;
|
|
// The account's public ID, copied: settings reads share one buffer.
|
|
node_screen_account: [80]u8;
|
|
node_screen_hold_pictures: bool;
|
|
|
|
NodeScreenFriends :: (app: *InnerBreeze) -> string {
|
|
if app.profile_friends_loaded == 0 {
|
|
load_friends_cache(app)
|
|
}
|
|
return AppTextFromCString(*app.profile_friends_json[0], 8192)
|
|
}
|
|
|
|
NodeScreenFriendCount :: (app: *InnerBreeze) -> s32 {
|
|
json := NodeScreenFriends(app)
|
|
count := ArrayCount(json, FieldAt(json, 0, "friends"))
|
|
return ifx count < 0 then 0 else count
|
|
}
|
|
|
|
NodeScreenFriend :: (app: *InnerBreeze, index: s32) -> AppPerson {
|
|
json := NodeScreenFriends(app)
|
|
friends := FieldAt(json, 0, "friends")
|
|
if index < 0 || index >= ArrayCount(json, friends) {
|
|
return AppPerson.{}
|
|
}
|
|
at := ElementAt(json, friends, index)
|
|
id := NodeAppJsonText(json, at, "user_id_hash", node_screen_friend_id[:])
|
|
alias := NodeAppJsonText(json, at, "alias", node_screen_alias[:])
|
|
return AppPerson.{.id = id, .name = NodeAppPersonName(alias, id, node_screen_friend_name[:])}
|
|
}
|
|
|
|
node_screen_input_text: [1024]u8;
|
|
node_screen_input_codec: WidgetTextFieldInputCodec;
|
|
|
|
NodeScreenUiCall :: (context: *void, module: *u8, function: *u8,
|
|
arguments: *HostValue, count: s32, result: *HostValue) -> s32 {
|
|
app := cast(*InnerBreeze)context
|
|
name := TextFromCString(function)
|
|
if AppModule(TextFromCString(module)) && name == "ClipboardCopyHost" && count == 2 &&
|
|
HostScalarValid(arguments[0], "string", cast(s32)HostString) {
|
|
result.* = HostScalar("bool", ifx TextInputWriteClipboard(AppArgumentText(arguments[0])) then 1 else 0)
|
|
return 1
|
|
}
|
|
if name == "ReadAppUiHost" && count == 0 {
|
|
result.* = WidgetEncodeAppUiFrame(node_screen_frame, *node_screen_frame_codec)
|
|
return 1
|
|
}
|
|
if name == "AppKeyHost" && count == 0 {
|
|
key := NodeAppKeyFor(NodePressedKey(), NodeRepeatedKey())
|
|
if key == 0 && TestDriverActive() {
|
|
for candidate: cast(s32)32..348 {
|
|
if TestDriverKeyPressed(candidate) {
|
|
key = candidate
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if key == 0 { key = KeyboardTake(app.ui.session) }
|
|
result.* = HostScalar("s32", key)
|
|
return 1
|
|
}
|
|
if name == "CloseAppHost" && count == 0 {
|
|
app_block_current_click(app)
|
|
app_launcher_open(app)
|
|
result.* = HostScalar("bool", 1)
|
|
return 1
|
|
}
|
|
if name == "AppFieldInputHost" && count == 0 {
|
|
input := SampleTextFieldInput(true, node_screen_input_text[:])
|
|
result.* = WidgetEncodeTextFieldInput(input, *node_screen_input_codec)
|
|
return 1
|
|
}
|
|
if name == "AppLocaleHost" && count == 1 &&
|
|
HostScalarValid(arguments[0], "string", cast(s32)HostString) {
|
|
key := NodeAppText(arguments[0])
|
|
translated := NodeAppLocaleText(app.node_app_slot, AppTextFromCString(*app.language[0], 16), key)
|
|
result.* = NodeAppString(ifx translated != "" then translated else LocaleText(key))
|
|
return 1
|
|
}
|
|
if name == "AppFriendHost" && count == 1 &&
|
|
HostScalarValid(arguments[0], "s32", cast(s32)HostInteger) {
|
|
person := NodeScreenFriend(app, cast(s32)arguments[0].integer)
|
|
result.* = WidgetEncodeAppPerson(person, *node_screen_person_codec)
|
|
return 1
|
|
}
|
|
return WidgetHostCall(context, module, function, arguments, count, result)
|
|
}
|
|
|
|
// The platform picker a granted app asked for (MediaPickHost): the
|
|
// desktop's file dialog, or Android's photo picker, whose answer arrives on
|
|
// a later frame. Each picked file is added to the library once.
|
|
node_screen_media_waiting: bool;
|
|
|
|
NodeScreenMediaAdd :: (path: string) {
|
|
if path.count == 0 {
|
|
NodeAppMediaPicked(MediaImport.{}, true)
|
|
return
|
|
}
|
|
NodeAppMediaPicked(MediaImportFile(path), true)
|
|
}
|
|
|
|
NodeScreenMediaPicker :: (app: *InnerBreeze) {
|
|
if node_screen_media_waiting {
|
|
path: [4096]u8
|
|
result := AndroidPickerPoll(cast(s32)ANDROID_IMPORT_KIND_MEDIA, path[:])
|
|
if result == .AndroidPickerNone {
|
|
return
|
|
}
|
|
node_screen_media_waiting = false
|
|
app.file_dialog_active = 0
|
|
if result == .AndroidPickerSelected {
|
|
selected := AppTextFromCString(*path[0], cast(s32)path.count)
|
|
NodeScreenMediaAdd(selected)
|
|
// The picker's private copy; the library keeps its own file.
|
|
if selected.count > 0 {
|
|
unused RemoveFile(selected)
|
|
}
|
|
} else {
|
|
NodeAppMediaPicked(MediaImport.{}, false)
|
|
}
|
|
return
|
|
}
|
|
if !node_media_pick_requested {
|
|
return
|
|
}
|
|
node_media_pick_requested = false
|
|
app.file_dialog_active = 1
|
|
if AndroidPlatform() != 0 {
|
|
node_screen_media_waiting = AndroidPickerOpen(cast(s32)ANDROID_IMPORT_KIND_MEDIA, "image/*")
|
|
if !node_screen_media_waiting {
|
|
app.file_dialog_active = 0
|
|
NodeAppMediaPicked(MediaImport.{}, true)
|
|
}
|
|
return
|
|
}
|
|
path: [4096]u8
|
|
selected := PickFile(FilePickerProps.{.title = LocaleText("photos_add"),
|
|
.filter = "Images | *.png *.jpg *.jpeg *.webp *.gif"}, path[:])
|
|
app.file_dialog_active = 0
|
|
if selected == 1 {
|
|
NodeScreenMediaAdd(AppTextFromCString(*path[0], cast(s32)path.count))
|
|
} else {
|
|
NodeAppMediaPicked(MediaImport.{}, selected < 0)
|
|
}
|
|
}
|
|
|
|
// Opening the app reads friends and shared records again. An installed app
|
|
// that is not running starts now, or downloads again when it cannot.
|
|
#program_export
|
|
node_app_screen_enter :: (app: *InnerBreeze) {
|
|
if app == null {
|
|
return
|
|
}
|
|
name := NodeAppName(app.node_app_slot)
|
|
if name.count > 0 && !NodeAppRunning(app.node_app_slot) {
|
|
unused NodeAppInstall(name)
|
|
}
|
|
if name.count > 0 && !NodeAppLocal(name) {
|
|
index := NodeAppIndex(app.node_app_slot)
|
|
if !PackagePending(index) {
|
|
if PackageAutomaticEnabled() {
|
|
PackageRequest(index)
|
|
} else {
|
|
PackageCheckForUpdate(index)
|
|
}
|
|
}
|
|
}
|
|
load_friends_cache(app)
|
|
app_request_social_refresh(app)
|
|
lists_refresh_at = 0.0
|
|
}
|
|
|
|
// Route changes ask this before showing an app: only one on this device
|
|
// opens, never one still downloading.
|
|
#program_export
|
|
node_app_screen_opens :: (slot: s32) -> bool {
|
|
return NodeAppInstalled(slot)
|
|
}
|
|
|
|
node_screen_loading: NodeScreenLoadingState;
|
|
|
|
NodeScreenIdentity :: (slot: s32) -> u64 {
|
|
identity := (cast(u64)(slot + 1) << cast(u64)48)
|
|
runtime := NodeTreeRuntime(slot)
|
|
if runtime != null && runtime.node != null {
|
|
identity = identity ^ KeyHash(TextUntilNul(runtime.node.identity.id[:]))
|
|
identity = identity ^ KeyHash(TextUntilNul(runtime.node.entry.sha256[:]))
|
|
}
|
|
return identity
|
|
}
|
|
|
|
// Count only this app's requested pictures. Images queued by a background
|
|
// app cannot hold the visible app behind its loading cover.
|
|
NodeScreenPictures :: struct { ready: s32; total: s32 }
|
|
NodeScreenPictureProgress :: (slot: s32) -> NodeScreenPictures {
|
|
result: NodeScreenPictures
|
|
#if #defined(PLATFORM_WEB) == false {
|
|
runtime := NodeTreeRuntime(slot)
|
|
if runtime == null || runtime.node == null { return result }
|
|
digest := TextUntilNul(runtime.node.entry.sha256[:])
|
|
for image: node_tree_images {
|
|
if TextUntilNul(image.digest[:]) != digest { continue }
|
|
result.total += 1
|
|
if ImageWidth(image.path) >= 0 { result.ready += 1 }
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
NodeScreenProgress :: (app: *InnerBreeze, area: Rectangle, title: string,
|
|
stage: string, done: s32, total: s32) {
|
|
scale := MetricsScale()
|
|
width := area.width - 48.0 * scale
|
|
if width > 320.0 * scale { width = 320.0 * scale }
|
|
left := area.x + (area.width - width) / 2.0
|
|
middle := area.y + area.height / 2.0
|
|
Text(app.ui.session, TextProps.{.key = KeyHash("inbe/node-app/loading-title"),
|
|
.text = title, .font = AppFontSize(),
|
|
.bounds = Rectangle.{left, middle - 56.0 * scale, width, 28.0 * scale},
|
|
.align = cast(TextAlign)TextAlignCenter})
|
|
Text(app.ui.session, TextProps.{.key = KeyHash("inbe/node-app/loading-stage"),
|
|
.text = stage, .font = AppFontSize(),
|
|
.bounds = Rectangle.{left, middle - 24.0 * scale, width, 28.0 * scale},
|
|
.align = cast(TextAlign)TextAlignCenter})
|
|
counts: Vec(u8)
|
|
BuilderPrint(*counts, "% / %", done, total)
|
|
Progress(app.ui.session, ProgressProps.{.key = KeyHash("inbe/node-app/loading-progress"),
|
|
.bounds = Rectangle.{left, middle + 16.0 * scale, width, 24.0 * scale},
|
|
.min = 0, .max = total, .value = done, .label = TextView(VecSlice(counts, 0, counts.count))})
|
|
VecFree(counts)
|
|
LoadingIndicator(app.ui.session, LoadingIndicatorProps.{.key = KeyHash("inbe/node-app/loading-animation"),
|
|
.bounds = Rectangle.{left, middle + 56.0 * scale, width, 24.0 * scale},
|
|
.now = GetTime(), .scale = scale})
|
|
AppRequestSmoothFrames(2)
|
|
}
|
|
|
|
NodeScreenCover :: (app: *InnerBreeze, area: Rectangle, pictures: NodeScreenPictures) {
|
|
Box(app.ui.session, BoxProps.{.key = KeyHash("inbe/node-app/cover"), .bounds = area,
|
|
.fill = StyleTokenColor("canvas")})
|
|
NodeScreenProgress(app, area, NodeAppName(app.node_app_slot),
|
|
LocaleText("app_loading_pictures"), pictures.ready, ifx pictures.total > 0 then pictures.total else 1)
|
|
}
|
|
|
|
NodeScreenLoading :: (app: *InnerBreeze) {
|
|
area := Rectangle.{0.0, 0.0, cast(float32)app.ui.view_width,
|
|
cast(float32)(app.ui.view_height - app_content_bottom_reserved(app))}
|
|
slot := AppScreenSlot(app)
|
|
if slot >= 0 {
|
|
done := AppsFeaturesReadyCount()
|
|
total := cast(s32)PackageCount - 1
|
|
NodeScreenProgress(app, area, LocaleText("app_loading_apps"),
|
|
LocaleText("app_loading_open"), done, total)
|
|
return
|
|
}
|
|
step := NodeOpenStep(app.node_app_slot)
|
|
stages: [4]string = .["app_loading_wait", "app_loading_read", "app_loading_open", "app_loading_ready"]
|
|
NodeScreenProgress(app, area, NodeAppName(app.node_app_slot), LocaleText(stages[step]), step, 3)
|
|
}
|
|
|
|
// The bundled app that draws the current screen, by module slot, or -1 for
|
|
// a screen Breeze draws itself.
|
|
AppScreenSlot :: (app: *InnerBreeze) -> s32 {
|
|
screen := app.breathing.screen
|
|
if screen == ScreenEList { return 0 }
|
|
if screen == ScreenHabits || screen == ScreenHabitEdit || screen == ScreenHabitSessionEdit { return 1 }
|
|
if screen == ScreenStart || screen == ScreenResults { return 2 }
|
|
if screen == ScreenDiary { return 4 }
|
|
if screen == ScreenLumi { return 5 }
|
|
if screen == ScreenLeaderboard { return 6 }
|
|
return -1
|
|
}
|
|
|
|
// A screen whose app is still opening after the start shows Kryon's loading
|
|
// indicator in its place, so the first frames never wait for the program.
|
|
AppScreenOpening :: (app: *InnerBreeze) -> bool {
|
|
slot := AppScreenSlot(app)
|
|
return slot >= 0 && !AppsFeatureOpenNow(slot)
|
|
}
|
|
|
|
#program_export
|
|
node_app_screen_draw :: (app: *InnerBreeze) {
|
|
node_screen_hold_pictures = false
|
|
if app == null {
|
|
return
|
|
}
|
|
slot := app.node_app_slot
|
|
name := NodeAppName(slot)
|
|
if name.count == 0 {
|
|
return
|
|
}
|
|
if !NodeAppRunning(slot) {
|
|
if NodeAppInstalled(slot) { unused NodeAppOpen(slot) }
|
|
if NodeAppOpenFailed(slot) && app.modal.active == 0 && !app.launcher_open {
|
|
app_open_modal(app, ModalType.ModalNodeAppFailure)
|
|
}
|
|
NodeScreenLoading(app)
|
|
return
|
|
}
|
|
node_screen_frame = AppUiFrame.{.session = app.ui.session, .width = app.ui.view_width,
|
|
.height = app.ui.view_height, .bottom = app_content_bottom_reserved(app),
|
|
.scale = MetricsScale(), .font = AppFontSize(), .now = GetTime(), .dark = app.dark_mode != 0}
|
|
unused AppCopyText(storage_get_setting_text("sync_public_id"), node_screen_account[:])
|
|
message := AppMessage.{.action = APP_FRAME, .screen = ScreenNodeApp, .name = name,
|
|
.locale = AppTextFromCString(*app.language[0], 16),
|
|
.account = TextUntilNul(node_screen_account[:]),
|
|
.signed_in = ListsNetworkReady(), .friend_count = NodeScreenFriendCount(app),
|
|
.shared_count = NodeAppSharedCount(name), .invitation_count = NodeAppInvitationCount(name),
|
|
.shared_revision = ListsSharedRevision(), .shared_status = lists_status,
|
|
.time = now_seconds()}
|
|
typed: [1024]u8
|
|
if NodeAppPortable(slot) || node_runners[slot].nested != null {
|
|
input := SampleTextFieldInput(true, typed[:])
|
|
key := NodeAppKeyFor(NodePressedKey(), NodeRepeatedKey())
|
|
// Native and IME commands are sampled with the field input. Keep
|
|
// them even when the raw key queue has already been drained.
|
|
if input.commit { key = TextInputKeyEnter }
|
|
else if input.backspace { key = TextInputKeyBackspace }
|
|
else if input.escape { key = TextInputKeyEscape }
|
|
modifiers: s32 = 0
|
|
if input.shift { modifiers |= 1 }
|
|
if TextInputKeyDown(TextInputKeyLeftControl) || TextInputKeyDown(TextInputKeyRightControl) {
|
|
modifiers |= 2
|
|
}
|
|
if node_runners[slot].nested != null {
|
|
NodeTreeFrame(slot, node_screen_frame, key, modifiers, input)
|
|
} else {
|
|
NodeAppPortableFrame(slot, app.ui.session,
|
|
Rectangle.{0.0, 0.0, cast(float32)app.ui.view_width,
|
|
cast(float32)(app.ui.view_height - app_content_bottom_reserved(app))},
|
|
app.dark_mode != 0, MetricsScale(), AppFontSize(), key, modifiers, input)
|
|
}
|
|
}
|
|
if node_runners[slot].nested != null {
|
|
WidgetHostBegin(app.ui.session, NodeTreeAssetAllowed, NodeTreeAssetPath)
|
|
} else {
|
|
WidgetHostBegin(app.ui.session, HostedAssetAllowed, WidgetHostPackedPath)
|
|
}
|
|
// The app draws only inside its area: covers sliding past its edge
|
|
// would otherwise paint over the sidebar's negative content x.
|
|
area := Rectangle.{0.0, 0.0, cast(float32)app.ui.view_width,
|
|
cast(float32)(app.ui.view_height - app_content_bottom_reserved(app))}
|
|
clip := Group(app.ui.session, ColumnProps.{.bounds = area, .key = KeyHash("inbe/node-app-clip")})
|
|
if clip.node >= 0 { TreeSetChildClip(app.ui.session, clip.node, area) }
|
|
NodeAppUiBegin(NodeScreenUiCall, cast(*void)app)
|
|
unused NodeAppRunMessage(slot, message)
|
|
NodeAppUiEnd()
|
|
identity := NodeScreenIdentity(slot)
|
|
pictures := NodeScreenPictureProgress(slot)
|
|
runtime := NodeTreeRuntime(slot)
|
|
node_screen_hold_pictures = runtime != null && runtime.node != null && !runtime.node.collection &&
|
|
NodeScreenHoldPictures(*node_screen_loading, identity, pictures.ready >= pictures.total)
|
|
if NodeScreenNeedsCover(*node_screen_loading, identity, pictures.ready >= pictures.total) {
|
|
NodeScreenCover(app, area, pictures)
|
|
}
|
|
if clip.opened { unused End(app.ui.session) }
|
|
WidgetHostEnd()
|
|
if NodeTreeTakeProfile() {
|
|
app_open_profile_tab(app, PROFILE_TAB_OVERVIEW)
|
|
}
|
|
NodeScreenMediaPicker(app)
|
|
}
|