Files
breeze/src/app/application.zi
T
waozi 1e2fe7050d Log, pick files, watch window close, read idle time and notify through Kryon
These platform services now come from Kryon: raylib_trace routes raylib's
log (trace_log.zi keeps only Inner Breeze's formatted lines),
window_close watches the app's own window, idle_time reads the session's
idle time for break reminders, notification_desktop sends desktop
notifications, and file_picker opens data, photo and audio pickers,
including the browser's chooser, which no longer needs Inner Breeze's
JavaScript. Audio files are still picked only on Linux and BSD desktops.

Tests that compile host services gain Kryon's backend module path; the
tests of the moved code live in Kryon now.
2026-10-11 10:15:34 -03:00

1751 lines
63 KiB
Ziran

#import, file "../cells/shared_state.zi";
#import, file "../cells/lumi_online.zi";
#import, file "../cells/module_host.zi";
c :: #system_library "c";
raylib_log :: #system_library "raylib";
LOG_INFO :: 3
LOG_WARNING :: 4
LOG_ERROR :: 5
#import, file "../platform/trace_log.zi";
#import "raylib_trace"
GetTime :: () -> float64 #foreign c;
PackageNow :: () -> s64 #foreign c "now_seconds";
#import, file "modal_rules.zi";
#import, file "../habits/habit_types.zi";
#import, file "../core/types.zi";
#import, file "app_types.zi";
#import, file "route_types.zi";
#import, file "exercise_types.zi";
#import, file "../platform/web_storage.zi";
#import, file "../platform/environment.zi";
#import, file "../platform/asset_download.zi";
#import, file "../platform/asset_download_types.zi";
#import, file "../platform/android/android_device.zi";
#import, file "../platform/android/graphics_context.zi";
#if #defined(PLATFORM_WEB) {
#import "kryon/canvas_host"
} else {
#import "kryon/raylib_runtime"
}
#if #defined(DESKTOP_TRAY_ENABLED) {
#import, file "../platform/desktop_tray.zi";
}
#import "open_uri"
#import "text_align"
#import "text_props"
#import "image_props"
#import "control_props"
#import "layout"
#import, file "app.zi";
#import, file "fonts.zi";
#import, file "../core/breath_timing.zi";
#import, file "manual_seen.zi";
#import, file "manual_seen_actions.zi";
#import, file "navigation_routes.zi";
#import, file "app_nav_state.zi";
#import, file "../widgets/bottom_nav.zi";
#import, file "profile_image_picker.zi";
#import, file "../breaks/break_rules.zi";
#import, file "../breaks/break_types.zi";
#import, file "../screens/elist_types.zi";
#import, file "../habits/habit_model.zi";
#import, file "../habits/habit_sessions.zi";
#import, file "../storage/data.zi";
#import, file "audio.zi";
#import, file "app_nav.zi";
#import, file "app_launcher.zi";
#import, file "app_launcher_state.zi";
#import, file "return_bar.zi";
#import, file "session_window.zi";
#import, file "session_window_view.zi";
#import, file "../platform/practice_window_host.zi";
#import, file "../platform/android/android_picture_window.zi";
#import, file "account_activity.zi";
#import, file "account_activity_view.zi";
#import "tree_input"
#import, file "../screens/habits/edit.zi";
#import, file "../screens/habits_screen.zi";
#import, file "../screens/elist_screen.zi";
#import, file "../screens/settings/settings_status.zi";
#import, file "app_sync.zi";
#import, file "sync_safety.zi";
#import, file "telegram_account_flow.zi";
#import, file "../platform/telegram_bridge.zi";
#import, file "../storage/delegate_store.zi";
#import, file "app_route_state.zi";
#import, file "app_route_url.zi";
#import, file "app_donation.zi";
#import, file "donation_modal.zi";
#import, file "app_donation_reminder.zi";
#import, file "app_profile.zi";
#import, file "app_frame_pacing.zi";
#import, file "app_frame_transition.zi";
#import, file "app_persistence.zi";
#import, file "app_modal_state.zi";
#import, file "app_chrome.zi";
#import, file "mini_mode.zi";
#import, file "mini_mode_expand.zi";
#import, file "app_settings.zi";
#import, file "language_selection.zi";
#import, file "../habits/view_settings.zi";
#import, file "locale.zi";
#import, file "update_check.zi";
#import, file "text_buffers.zi";
#import "c_string"
#import, file "app_notifications.zi";
#import, file "../screens/language_screen.zi";
#import, file "../screens/app_selection_screen.zi";
#import, file "../screens/diary_screen.zi";
#import, file "../screens/lumi_screen.zi";
#import, file "../screens/leaderboard_screen.zi";
#import, file "../cells/package_manager.zi";
#import, file "../cells/catalog.zi";
#import, file "../cells/inbe_types.zi";
#import, file "app_style.zi";
#import, file "../screens/manual_screen.zi";
#import, file "../screens/manual_dispatch.zi";
#import, file "../screens/break_overlay.zi";
#import, file "../breaks/app_breaks.zi";
#import, file "../screens/profile_screen.zi";
#import, file "../screens/profile_social.zi";
#import, file "../screens/settings/settings_screen.zi";
#import, file "../screens/settings/settings_audio.zi";
#import, file "../screens/settings/settings_data_ui.zi";
#import, file "../screens/settings/settings_sync_account_impl.zi";
#import, file "../screens/settings/settings_theme.zi";
#import, file "../screens/practice_screen.zi";
#import, file "../practices/practice_registry.zi";
#import, file "../screens/session_results_screen.zi";
#import, file "../screens/habits/habit_session_screen.zi";
#import, file "device_preferences.zi";
#import, file "../practices/meditation/meditation_music.zi";
#import, file "metrics.zi";
#import, file "dpi_state.zi";
#import, file "draw.zi";
#import, file "direct_draw_plan.zi";
#import, file "current_app.zi";
#import "button_widget"
#import "image_widget"
#import "text_widget"
#import "drawing_props"
#import "geometry"
#import "session"
#import "button_props"
#import "modal_props"
#import "modal_widget"
#import "toast_props"
#import "tree_draw"
#import "tree"
#import "frame_pacing"
using SessionExitModalResult;
using AppClosePromptResult;
using NavigationMode;
using NavigationPlacement;
using ModalType;
using AppMainTab;
using ExerciseType;
using HabitSyncMode;
using TextAlign;
using TextWrap;
using ImageFit;
using ButtonTone;
using ButtonEmphasis;
KEY_Q :: 81;
KEY_LEFT_CONTROL :: 341;
KEY_RIGHT_CONTROL :: 345;
KEY_BACKSPACE :: 259;
APP_KEY_BACK :: 4;
APP_KEY_ESCAPE :: 256;
IsKeyPressed :: (key: s32) -> bool #foreign raylib_log "IsKeyPressed";
IsKeyDown :: (key: s32) -> bool #foreign raylib_log "IsKeyDown";
BeginMode2D :: (camera: Camera) #foreign raylib_log "BeginMode2D";
EndMode2D :: () #foreign raylib_log "EndMode2D";
BeginScissorMode :: (x: s32, y: s32, width: s32, height: s32) #foreign raylib_log "BeginScissorMode";
EndScissorMode :: () #foreign raylib_log "EndScissorMode";
#if #defined(PLATFORM_WEB) {
}
#if #defined(ANDROID_BUILD) {
#import, file "../platform/android/android_wakelock.zi";
#import, file "../platform/android/android_insets.zi";
android_network_pump_begin :: () -> bool #foreign c;
android_network_pump_end :: () #foreign c;
}
#if #defined(PLATFORM_WEB) || #defined(ANDROID_BUILD) {
APP_DEFAULT_WIDTH :: 320
APP_DEFAULT_HEIGHT :: 560
} else {
APP_DEFAULT_WIDTH :: 900
APP_DEFAULT_HEIGHT :: 720
}
config: AppConfig = AppConfig.{.width = APP_DEFAULT_WIDTH, .height = APP_DEFAULT_HEIGHT};
view_width: s32 = APP_DEFAULT_WIDTH;
view_height: s32 = APP_DEFAULT_HEIGHT;
app_full_view_width: s32 = APP_DEFAULT_WIDTH;
// Theme colors are now accessed via theme accessor functions
#program_export
app_leave_practice_config :: (app: *InnerBreeze) {
if app == null {
return
}
if app.settings_dirty != 0 {
save_settings(app)
}
{
practice: *PracticeDefinition = practice_get(app.exercise_type)
if practice.leave_config != null {
practice.leave_config(app)
}
}
app.settings_scroll = 0
}
#program_export
app_request_desktop_close :: (app: *InnerBreeze) {
if app == null {
return
}
// The mini window has no tray or close prompt.
if AppMiniMode() {
app.request_quit = 1
return
}
// Configured close behaviour overrides the ask prompt (desktop only).
if app.desktop_close_action == CLOSE_QUIT {
app.request_quit = 1
return
}
#if #defined(DESKTOP_TRAY_ENABLED) {
if desktop_tray_ready() == 0 {
app.request_quit = 1
return
}
}
if app.desktop_close_action == CLOSE_KEEP_RUNNING {
#if #defined(DESKTOP_TRAY_ENABLED) {
if desktop_tray_keep_running() == 0 {
app.request_quit = 1
}
} else {
app.request_quit = 1
}
return
}
app.close_prompt_open = 1
app_block_current_click(app)
app.close_prompt_result = cast(AppClosePromptResult)AppClosePromptNone
}
//
// Desktop quit request from an explicit command such as Ctrl+Q. Window-close
// requests may still ask whether to keep running, but a quit command should
// always terminate the app.
//
#program_export
app_request_desktop_quit :: (app: *InnerBreeze) {
if app == null {
return
}
app.request_quit = 1
}
#program_export
app_consume_close_prompt_result :: (app: *InnerBreeze) -> AppClosePromptResult {
result: AppClosePromptResult
if app == null {
return cast(AppClosePromptResult)AppClosePromptNone
}
result = app.close_prompt_result
app.close_prompt_result = cast(AppClosePromptResult)AppClosePromptNone
return result
}
#program_export
app_draw_session_exit_modal :: (app: *InnerBreeze, can_save: s32, save_message: string, discard_message: string) -> SessionExitModalResult {
modal_result: s32
if can_save != 0 {
actions: [3] ActionModalAction = .[
ActionModalAction.{.label = LocaleText("cancel_button"), .tone = cast(ButtonTone)ButtonToneNeutral, .emphasis = cast(ButtonEmphasis)ButtonEmphasisSoft},
ActionModalAction.{.label = LocaleText("save_button"), .tone = cast(ButtonTone)ButtonToneAccent, .emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled},
ActionModalAction.{.label = LocaleText("discard_button"), .tone = cast(ButtonTone)ButtonToneDanger, .emphasis = cast(ButtonEmphasis)ButtonEmphasisSoft},
]
modal_result = ActionModal(app.ui.session, ActionModalProps.{.title = LocaleText("exit_session_title"), .message = save_message}, actions[:3]).action
if modal_result == 2 {
return cast(SessionExitModalResult)SessionExitModalSave
}
if modal_result == 3 {
return cast(SessionExitModalResult)SessionExitModalDiscard
}
} else {
actions: [2] ActionModalAction = .[
ActionModalAction.{.label = LocaleText("cancel_button"), .tone = cast(ButtonTone)ButtonToneNeutral, .emphasis = cast(ButtonEmphasis)ButtonEmphasisSoft},
ActionModalAction.{.label = LocaleText("exit_button"), .tone = cast(ButtonTone)ButtonToneDanger, .emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled},
]
modal_result = ActionModal(app.ui.session, ActionModalProps.{.title = LocaleText("exit_session_title"), .message = discard_message}, actions[:2]).action
if modal_result == 2 {
return cast(SessionExitModalResult)SessionExitModalDiscard
}
}
return ifx (modal_result == 1) then (cast(SessionExitModalResult)SessionExitModalCancel) else (cast(SessionExitModalResult)SessionExitModalNone)
}
app_draw_close_prompt :: (app: *InnerBreeze) {
modal_result: s32
actions: [2] ActionModalAction = .[ActionModalAction.{}, ActionModalAction.{}]
props: ActionModalProps = .{}
if app == null || app.close_prompt_open == 0 {
return
}
if app.blocked_input_frame == app.breathing.frame {
return
}
actions[0].label = LocaleText("desktop_close_keep_running_button")
actions[0].tone = cast(ButtonTone)ButtonToneAccent
actions[0].emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled
actions[1].label = LocaleText("desktop_close_quit_button")
actions[1].tone = cast(ButtonTone)ButtonToneDanger
actions[1].emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled
props.key = KeyHash("inbe/desktop-close")
props.title = LocaleText("desktop_close_prompt_title")
props.message = LocaleText("desktop_close_prompt_message")
props.max_width = 420
modal_result = ActionModal(app.ui.session, props, actions[:2]).action
if modal_result == {
case -1;
app.close_prompt_open = 0
case 1;
app.close_prompt_open = 0
app.close_prompt_result = cast(AppClosePromptResult)AppClosePromptKeepRunning
case 2;
app.close_prompt_open = 0
app.close_prompt_result = cast(AppClosePromptResult)AppClosePromptQuit
app_request_desktop_quit(app)
}
}
app_reload_graphics_resources :: (app: *InnerBreeze) -> bool {
if app == null {
return false
}
context_lost: bool = false
#if #defined(ANDROID_BUILD) {
context := AndroidGraphicsContext()
if context == null {
// EndDrawing continues polling Android events until the surface
// is rebound. Do not populate any GPU caches in the meantime.
return false
}
context_lost = app.graphics_context != null &&
app.graphics_context != context
app.graphics_context = context
}
if app.graphics_reload_requested == 0 && !context_lost {
return true
}
app.graphics_reload_requested = 0
if PreviewMode() != 0 {
return true
}
TraceLog(LOG_INFO, "ANDROID: Reloading graphics resources")
#if #defined(ANDROID_BUILD) {
ResetRaylibGraphics(context_lost)
// Retained frames are gone even when the context survived. A route
// fade must not keep a borrowed texture from the discarded frame.
app_route_transition_cancel(app, context_lost)
app.ui.retained_target_active = false
app.ui.retained_frame_unchanged = false
}
if !LoadLocaleFont(app) {
TraceLog(LOG_WARNING, "FONT: Failed to reload Noto UI font")
}
return true
}
#program_export
refresh_locale_dependent_text :: (app: *InnerBreeze) {
if app == null {
return
}
if config.title_custom == 0 {
CopyCString(LocaleText("app_title"), config.title[:])
}
manual_screen_reset_layouts(app)
app.language_index = LocaleActiveIndex()
if app.language_index < 0 {
app.language_index = 0
}
}
load_config :: () {
if config.loaded != 0 {
return
}
if config.title[0] == #char "\0" {
AppCopyText(LocaleText("app_title"), config.title[:])
config.title_custom = 0
}
#if #defined(PLATFORM_WEB) {
refresh_theme_colors(0, 1)
} else {
refresh_theme_colors(0, 0)
}
config.loaded = 1
}
#program_export
clampi :: (value: s32, min: s32, max: s32) -> s32 {
if value < min {
return min
}
if value > max {
return max
}
return value
}
#program_export
app_reload_after_import :: (app: *InnerBreeze, reload_settings: s32) {
detail_habit_id: [HABIT_ID_SIZE] u8 = .[0]
detail_index: s32 = -1
view_mode: s32 = HABIT_VIEW_CALENDAR
habit_tab: s32 = HABIT_TAB_WEEKLY
month_offset: s32 = 0
scroll: s32 = 0
weekly_days: s32 = 0
hold_stats_range_days: s32 = 0
i: s32
if app == null {
return
}
if reload_settings == 0 {
app.app_choices_pending = true
if app.habit_detail_index >= 0 && app.habit_detail_index < app.habits.count {
AppCopyText(AppTextFromCString(
*app.habits.items[app.habit_detail_index].id[0],
HABIT_ID_SIZE), detail_habit_id[:])
}
detail_index = app.habit_detail_index
view_mode = app.habits.view_mode
habit_tab = app.habits.tab
month_offset = app.habits.month_offset
scroll = app.habits.scroll
weekly_days = app.habits.weekly_days
hold_stats_range_days = app.habits.hold_stats_range_days
}
if reload_settings != 0 {
settings_missing := app_load_settings(app)
refresh_locale_dependent_text(app)
app_device_preferences_init(app)
if settings_missing != 0 {
save_settings(app)
}
app_apply_style(app)
reset_settings_preview(app)
practice_update_session_sounds(app)
}
if !TelegramAccountFlowOwnsContext() {
habits_init_with_defaults(*app.habits, app.language_selected)
}
if reload_settings != 0 {
app_restore_habits_view_settings(app)
}
if reload_settings == 0 {
app.habits.selected = -1
app.habit_detail_index = -1
{
i: s32 = 0
while i < app.habits.count {
if detail_habit_id[0] != cast(u8)0 &&
AppTextFromCString(*app.habits.items[i].id[0], HABIT_ID_SIZE) ==
AppTextFromCString(*detail_habit_id[0], HABIT_ID_SIZE) {
app.habit_detail_index = i
break
}
i += 1
}
}
if app.habit_detail_index < 0 && detail_index >= 0 && detail_index < app.habits.count {
app.habit_detail_index = detail_index
}
app.habits.view_mode = view_mode
app.habits.tab = habit_tab
app.habits.month_offset = month_offset
app.habits.scroll = scroll
app.habits.weekly_days = weekly_days
app.habits.hold_stats_range_days = ifx (hold_stats_range_days == 31) then (31) else (7)
}
if app.habit_detail_index >= app.habits.count {
app.habit_detail_index = -1
}
if app.habits.selected >= app.habits.count {
app.habits.selected = -1
}
app.habit_session_edit.active = 0
app.habit_edit.active = 0
}
#if #defined(ANDROID_BUILD) {
#program_export
app_request_graphics_reload :: (app: *InnerBreeze) {
if app != null {
app.graphics_reload_requested = 1
}
}
}
app_draw_blank_home_easteregg :: (app: *InnerBreeze) {
if app == null {
return
}
available_h := view_height - app_content_bottom_reserved(app)
if available_h < AppScale(120) {
available_h = view_height
}
Image(CurrentApp().ui.session, ImageProps.{
.asset_path = "assets/easteregg/art.png",
.bounds = Rectangle.{0, 0, cast(float32)view_width, cast(float32)available_h},
.fit = cast(ImageFit)ImageFitCover
})
logo_size := cast(float32)view_width * 0.58f
if logo_size > cast(float32)available_h * 0.58f {
logo_size = cast(float32)available_h * 0.58f
}
if logo_size > cast(float32)AppScale(320) {
logo_size = cast(float32)AppScale(320)
}
bounds := Rectangle.{(cast(float32)view_width - logo_size) / 2,
(cast(float32)available_h - logo_size) / 2, logo_size, logo_size
}
if Button(CurrentApp().ui.session, ButtonProps.{
.bounds = bounds,
.image = ImageProps.{
.asset_path = "assets/easteregg/waozi.png",
.bounds = bounds, .fit = cast(ImageFit)ImageFitContain
},
.tone = cast(ButtonTone)ButtonToneNeutral, .emphasis = cast(ButtonEmphasis)ButtonEmphasisGhost
}) != 0 {
OpenUri("https://waozi.xyz")
}
}
app_apply_initial_screen :: (app: *InnerBreeze) {
if app == null {
return
}
// Mini mode uses the root's temporary Practice selection and skips the
// full app's onboarding without bypassing its route policy.
if AppMiniMode() {
app.main_tab = APP_MAIN_TAB_PRACTICE
}
initial := InbeRun(InbeMessage.{.action = INBE_INITIAL_SCREEN,
.enabled_apps = ifx AppMiniMode() then APP_PRACTICE else app.enabled_apps,
.language_selected = AppMiniMode() || app.language_selected != 0,
.apps_selected = AppMiniMode() || app.apps_selected != 0,
.screen = app_screen_for_main_tab(app.main_tab)})
if !initial.succeeded {
app.request_quit = 1
return
}
app.breathing.screen = initial.screen
if initial.screen == ScreenAppSelection && !app.launcher_open {
app_launcher_toggle(app)
}
app.habits.focus_selected_tab = ifx (app.breathing.screen == ScreenHabits) then (1) else (0)
}
#program_export
app_mini_restore_selection :: (app: *InnerBreeze) {
if app == null {
return
}
// An active mini practice continues when the full window opens, while
// the stored selection still controls full-app navigation and saving.
active := practice_active(app) != null
mask := app.enabled_apps
if active {
mask |= APP_PRACTICE
}
if !CellsSetEnabled(mask) {
app.request_quit = 1
return
}
if !active {
app_apply_initial_screen(app)
}
}
// Host feature IDs use the app-selection bits; zero restores the parent route.
#program_export
app_open_feature :: (vapp: *void, feature: s32) -> s32 {
app := cast(*InnerBreeze)vapp
if app == null || !CellsReady() || AppMiniMode() {
return 0
}
before := app_current_route(app)
if feature == 0 {
app_apply_initial_screen(app)
app_observe_direct_route_change(app, before)
return cast(s32)(app.request_quit == 0)
}
bit: s32 = 0
tab: s32 = APP_MAIN_TAB_NONE
if feature == APP_PRACTICE {
bit = APP_PRACTICE
tab = APP_MAIN_TAB_PRACTICE
} else if feature == APP_HABITS {
bit = APP_HABITS
tab = APP_MAIN_TAB_HABITS
} else if feature == APP_LISTS {
bit = APP_LISTS
tab = APP_MAIN_TAB_ELIST
} else if feature == APP_LUMI {
bit = APP_LUMI
tab = APP_MAIN_TAB_LUMI
} else if feature == APP_DIARY {
bit = APP_DIARY
tab = APP_MAIN_TAB_DIARY
} else if feature == APP_LEADERBOARD {
bit = APP_LEADERBOARD
tab = APP_MAIN_TAB_LEADERBOARD
} else {
return 0
}
if app.breathing.screen == ScreenDiary && !app_diary_save() {
return 0
}
selected := InbeRun(InbeMessage.{.action = INBE_TOGGLE_APP,
.enabled_apps = app.enabled_apps, .app = bit, .checked = true})
if !selected.succeeded || !CellsSetEnabled(selected.enabled_apps) {
return 0
}
app.enabled_apps = selected.enabled_apps
app.apps_selected = 1
if (CellsInstalledMask() & bit) == 0 {
for index: cast(s32)1..cast(s32)(PackageCount - 1) {
if PackageBit(index) == bit {
PackageRequest(index)
}
}
app_update_app_navigation(app, bit)
app_switch_screen(app, ScreenAppSelection)
save_settings(app)
return 0
}
app.main_tab = tab
app_update_app_navigation(app, bit)
app_switch_screen(app, app_screen_for_main_tab(tab))
app_observe_direct_route_change(app, before)
save_settings(app)
return cast(s32)(app.breathing.screen == app_screen_for_main_tab(tab))
}
#program_export
app_init :: (vapp: *void) {
app: *InnerBreeze = cast(*InnerBreeze)vapp
i: s32
if app == null {
return
}
FramePacingReset()
app.ui.session = SessionOpen()
if !SessionValid(app.ui.session) { return }
android_text_input_open(app.ui.session)
#if #defined(ANDROID_BUILD) {
app.graphics_context = AndroidGraphicsContext()
if practice_active(app) != null {
android_allow_screen_off()
}
practice_active_background_stop(app)
}
InitDPI()
TraceLogInit(LOG_INFO, "APP: app init width=%d height=%d embedded=%d",
config.width, config.height, config.loaded)
load_config()
app_notifications_init(app)
view_width = ifx (config.width > 0) then (config.width) else (APP_DEFAULT_WIDTH)
view_height = ifx (config.height > 0) then (config.height) else (APP_DEFAULT_HEIGHT)
UpdateDPI(view_width, view_height)
view_width = GetLayoutWidth()
view_height = GetLayoutHeight()
TraceLogScale(LOG_INFO, "APP: render scale=%.2f layout=%dx%d",
GetRenderScale(), view_width, view_height)
app_capture_navigation_viewport(app, view_width, view_height)
app.breathing = BreathSessionInit()
app.breaks = BreakInit()
app.breaks_enabled = 0
app.desktop_startup_mode = STARTUP_SHOW
app.desktop_close_action = CLOSE_ASK
app.break_hud_x = -1
app.break_hud_y = -1
#if !#defined(ANDROID_BUILD) && !#defined(PLATFORM_WEB) {
app.break_sounds_enabled = 1
} else {
app.break_sounds_enabled = 0
}
data_init()
TelegramAccountFlowStart()
if !CellsStart(app) {
TraceLog(LOG_ERROR, "APP: required Lists, Habits or Practice bundle failed validation")
app.request_quit = 1
return
}
TraceLog(LOG_INFO, "APP PROBE: data initialized")
settings_missing := app_load_settings(app)
configuration_action: s32 = INBE_CONFIGURE
if AppMiniMode() {
configuration_action = INBE_MINI_CONFIGURE
}
selection := InbeRun(InbeMessage.{.action = configuration_action,
.enabled_apps = app.enabled_apps})
if !selection.succeeded || !CellsSetEnabled(selection.enabled_apps) {
app.request_quit = 1
return
}
if !AppMiniMode() {
app.enabled_apps = selection.enabled_apps
previous_routes := app.bottom_nav_routes
previous_count := app.bottom_nav_route_count
app_update_app_navigation(app, app.enabled_apps)
navigation_changed := previous_count != app.bottom_nav_route_count
for index: cast(s32)0..previous_count - 1 {
navigation_changed = navigation_changed ||
previous_routes[index] != app.bottom_nav_routes[index]
}
if navigation_changed {
save_settings(app)
}
if app.apps_selected != 0 {
for index: cast(s32)1..cast(s32)(PackageCount - 1) {
bit := PackageBit(index)
if (app.enabled_apps & bit) != 0 && (CellsInstalledMask() & bit) == 0 {
PackageRequest(index)
}
}
}
}
refresh_locale_dependent_text(app)
app_device_preferences_init(app)
if settings_missing != 0 {
save_settings(app)
}
app_apply_style(app)
app_init_donation_reminder_observed_practice_count(app)
if !LoadLocaleFont(app) {
TraceLog(LOG_WARNING, "FONT: Failed to load Noto UI font -> using built-in default")
}
TraceLog(LOG_INFO, "APP PROBE: locale font initialized")
if !AppMiniMode() {
update_check_start()
}
app.practice_tab = PRACTICE_TAB_PLAY
app.practice_config_tab = 0
app.session_result = SessionResult.{}
if app.language_needs_save != 0 {
save_settings(app)
app.language_needs_save = 0
}
if !TelegramAccountFlowOwnsContext() {
habits_init_with_defaults(*app.habits, app.language_selected)
}
app_restore_habits_view_settings(app)
app.habit_detail_index = -1
elist_state: *EListState = *app.elist
elist_state.editing_item = -1
app.habit_session_edit = HabitSessionEditState.{}
app.habit_session_edit.round = -1
app_apply_initial_screen(app)
practice_update_circle_bounds(app, app_content_top_reserved(app),
app_content_bottom_reserved(app))
#if !#defined(PLATFORM_WEB) && !#defined(ANDROID_BUILD) {
if PreviewMode() == 0 {
init_audio(app)
}
}
TraceLog(LOG_INFO, "APP PROBE: audio setup complete")
{
i: s32 = 0
while i < practice_count() {
practice: *PracticeDefinition = practice_get(i)
if practice.init != null {
practice.init(app)
}
i += 1
}
}
app.camera = Camera.{}
app.camera.zoom = 1.0
app.play_circle_hover = 0
app.play_circle_scale = 1.0f
app.settings_tab = SETTINGS_TAB_DEVICE
app.settings_overview = 1
app.habit_edit = HabitEditState.{}
app.habit_edit.index = -1
app.habit_edit.color.r = 99
app.habit_edit.color.g = 196
app.habit_edit.color.b = 165
app.habit_edit.color.a = 255
app.habit_edit.sync_mode = HABIT_SYNC_NONE
practice_update_session_sounds(app)
reset_settings_preview(app)
app.start_speed_preview = BreathSessionInit()
// Icons resolve from Kryon's embedded sheets; no app-side textures.
app.modal = AppModal.{}
app.meditation.duration_seconds = 0
app.meditation.remaining_seconds = 0
app.meditation.frame_ticks = 0
if !AppMiniMode() {
unused app_request_sync(app)
}
TraceLog(LOG_INFO, "APP PROBE: app init complete")
}
handle_back_button :: (app: *InnerBreeze) {
// If modal is active, let modal drawing handle it
if app.modal.active != 0 {
return
}
if app_return_bar_takes_back(app) {
app_return_to_apps(app)
return
}
screen := app.breathing.screen
if screen == ScreenStart {
if app.practice_tab == PRACTICE_TAB_CONFIG {
app_leave_practice_config(app)
}
if app.practice_tab != PRACTICE_TAB_PLAY {
route: AppRoute = app_current_route(app)
route.practice_tab = PRACTICE_TAB_PLAY
app.manual_scroll = 0
app.settings_scroll = 0
app.tutorial_step = 0
app_switch_route(app, route)
}
} else if screen == ScreenSettings {
app_settings_back(app)
} else if screen == ScreenProfile {
profile_screen_back(app)
} else if screen == ScreenCustomizeNav {
app_return_from_customize_nav(app)
} else if screen == ScreenPracticeConfig {
app_leave_practice_config(app)
app_switch_screen(app, ScreenStart)
} else if screen == ScreenHabits {
if app.habits.screen_mode == HABITS_SCREEN_HISTORY || app.habits.screen_mode == HABITS_SCREEN_STATISTICS {
app.habits.screen_mode = HABITS_SCREEN_OVERVIEW
app.habits.selected = -1
app.habits.tab = HABIT_TAB_WEEKLY
app.habits.view_mode = HABIT_VIEW_WEEKLY
app.habits.scroll = 0
save_settings(app)
} else if app.habits.tab == HABIT_TAB_EDIT && app.habit_edit.active != 0 {
habit_edit_cancel(app)
} else {
app_switch_screen(app, ScreenStart)
}
} else if screen == ScreenEList {
app_switch_screen(app, app_screen_for_main_tab(APP_MAIN_TAB_PRACTICE))
} else if screen == ScreenHabitEdit {
habit_edit_cancel(app)
app_switch_screen(app, ScreenHabits)
} else if screen == ScreenHabitSessionEdit {
habit_session_cancel_edit(app)
app_switch_screen(app, ScreenHabits)
} else if screen == ScreenLanguage || screen == ScreenManual {
manual_screen_close_tutorial(app, 0)
} else if screen == ScreenResults {
practice_ensure_results_saved(app)
#if #defined(ANDROID_BUILD) {
android_allow_screen_off()
android_wakelock_release()
}
app_init(cast(*void)app)
} else if screen == ScreenSession {
// When paused, exit immediately
if app.session_paused != 0 {
practice_active_background_stop(app)
app_init(cast(*void)app)
} else {
// Show confirmation modal
app_open_modal(app, cast(ModalType)ModalConfirmExitSession)
}
} else if screen == ScreenMeditation {
{
practice: *PracticeDefinition = practice_get(EXERCISE_MEDITATION)
if practice.request_exit != null {
practice.request_exit(app)
}
}
} else if screen == ScreenPatterns {
{
practice: *PracticeDefinition = practice_get(EXERCISE_PATTERNS)
if practice.request_exit != null {
practice.request_exit(app)
}
}
}
}
draw_profile_picture_picker_modal :: (app: *InnerBreeze) {
if app == null {
return
}
props: ProfileImagePickerProps
props.title = LocaleText("profile_picture_title")
props.selected_icon_type = app.profile_picture_icon
props.max_width = 520
props.scroll_offset = app.profile_picture_picker_scroll
props.view_width = app.ui.view_width
props.view_height = app.ui.view_height
result := ProfileImagePicker(app.ui.session, props)
app.profile_picture_picker_scroll = result.scroll_offset
if result.changed {
app.profile_picture_icon = result.selected_icon_type
save_settings(app)
}
if result.closed {
app_close_modal(app)
}
}
draw_donation_reminder_modal :: (app: *InnerBreeze) {
modal_result: s32
actions: [3] ActionModalAction = .[
ActionModalAction.{}, ActionModalAction.{}, ActionModalAction.{}
]
props: ActionModalProps = .{}
if app == null {
return
}
actions[0].label = LocaleText("donation_reminder_donate_button")
actions[0].tone = cast(ButtonTone)ButtonToneAccent
actions[0].emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled
actions[1].label = LocaleText("donation_reminder_skip_button")
actions[1].tone = cast(ButtonTone)ButtonToneNeutral
actions[1].emphasis = cast(ButtonEmphasis)ButtonEmphasisSoft
actions[2].label = LocaleText("donation_reminder_dismiss_button")
actions[2].tone = cast(ButtonTone)ButtonToneDanger
actions[2].emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled
props.title = LocaleText("donation_reminder_title")
props.message = LocaleText("donation_reminder_message")
props.max_width = 420
modal_result = ActionModal(app.ui.session, props, actions[:3]).action
if modal_result == -1 {
app_record_donation_reminder_seen(app)
app_close_modal(app)
} else if modal_result > 0 {
app_handle_donation_reminder_action(app, modal_result)
}
}
draw_global_modal :: (app: *InnerBreeze) {
modal_result: s32
if app == null || app.modal.active == 0 {
return
}
if app.blocked_input_frame == app.breathing.frame {
return
}
if settings_data_draw_modals(app) != 0 {
return
}
if app.modal.type == cast(ModalType)ModalDonationReminder {
draw_donation_reminder_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalAboutDonation {
draw_about_donation_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalMeditationNetworkError {
actions: [2] ActionModalAction = .[
ActionModalAction.{.label = LocaleText("cancel_button"), .tone = cast(ButtonTone)ButtonToneNeutral, .emphasis = cast(ButtonEmphasis)ButtonEmphasisSoft},
ActionModalAction.{.label = LocaleText("retry_button"), .tone = cast(ButtonTone)ButtonToneAccent, .emphasis = cast(ButtonEmphasis)ButtonEmphasisFilled},
]
modal_result = ActionModal(app.ui.session, ActionModalProps.{.title = LocaleText("meditation_music_network_error_title"), .message = LocaleText("meditation_music_network_error_message")}, actions[:2]).action
if modal_result == 1 {
TraceLog(LOG_INFO, "AUDIO: Network error download cancelled")
app_close_modal(app)
} else if modal_result == 2 {
TraceLog(LOG_INFO, "AUDIO: Network error download retry requested")
app_close_modal(app)
meditation_music_start_download(app)
}
}
if app.modal.type == cast(ModalType)ModalAppIconPicker {
settings_screen_draw_app_icon_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalThemePicker {
settings_screen_draw_theme_picker_modal(app)
}
if app.modal.type == cast(ModalType)ModalProfilePicturePicker {
draw_profile_picture_picker_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalConfirmRemoveFriend {
profile_screen_draw_remove_friend_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalPracticeManual || app.modal.type == cast(ModalType)ModalPracticeConfig || app.modal.type == cast(ModalType)ModalEditProgressiveStartSpeed {
practice_screen_draw_modal(app)
return
}
if app.modal.type == cast(ModalType)ModalSyncAlias {
modal_result = settings_sync_account_draw_alias_modal(app)
if modal_result == {
case 1;
then_backup: s32 = app.sync_alias_then_backup
app.sync_alias_then_backup = 0
app_close_modal(app)
settings_screen_set_status_success(LocaleText("sync_alias_saved"), "")
if then_backup != 0 {
app_open_modal(app, cast(ModalType)ModalSyncAccountBackup)
}
case 2;
settings_screen_set_status_error(LocaleText("sync_alias_failed"))
case 3;
then_backup: s32 = app.sync_alias_then_backup
app.sync_alias_then_backup = 0
app_close_modal(app)
if then_backup != 0 {
app_open_modal(app, cast(ModalType)ModalSyncAccountBackup)
}
}
}
if app.modal.type == cast(ModalType)ModalSyncPublicId {
modal_result = settings_sync_account_draw_public_id_modal(app)
if modal_result != 0 {
app_close_modal(app)
}
}
}
updateapp :: (app: *InnerBreeze) {
app_activity_pump(app)
hover: s32 = 0
center_x: s32 = view_width / 2
frame_view_height: s32 = view_height
center_y: s32
i: s32
frame_route: AppRoute
first_run_guide_active: s32 = 0
habits_guide_active: s32 = 0
practice_fullscreen_modal: bool = false
global_modal_drawn: bool = false
if TelegramAccountFlowOwnsContext() {
// Host identity must still be current before exposing any cached
// plaintext or actions, rather than waiting until the post-draw pump.
if !TelegramContextCurrent() && telegram_account_flow.phase != 90 &&
telegram_account_flow.phase != 91 {
TelegramFlowFail(*telegram_account_flow)
}
if TelegramContextCurrent() && StoredDelegateAvailable() != 0 &&
(app.enabled_apps & APP_LUMI) != 0 {
if account_activity.view_open && ActivityRemoteVisible() {
unused ActivityDrawRemote(app, true)
} else {
lumi_screen_draw(app)
ActivityDrawIndicator(app, true)
}
}
DrawTelegramAccountFlow(app)
app.breathing.frame += 1
return
}
app_sync_route_from_url(app)
frame_route = app_current_route(app)
#if #defined(ANDROID_BUILD) {
{
if android_take_pending_donation_reminder() != 0 {
if app.modal.active != 0 {
app_close_modal(app)
}
app_open_modal(app, cast(ModalType)ModalDonationReminder)
}
}
{
practice_id: s32 = android_take_pending_practice_start()
if practice_id >= 0 {
active_break: s32
practice: *PracticeDefinition
app.exercise_type = practice_clamp_id(practice_id)
if app.modal.active != 0 {
app_close_modal(app)
}
active_break = BreakActive(app.breaks)
if active_break >= 0 {
app_breaks_start_practice(app, active_break, app.exercise_type)
} else {
app.main_tab = APP_MAIN_TAB_PRACTICE
app.practice_tab = PRACTICE_TAB_PLAY
practice = practice_get(app.exercise_type)
if practice != null && practice.start != null {
practice.start(app)
}
}
}
}
}
// Mini mode is only the practices: no break or reminder prompts.
if !AppMiniMode() {
app_breaks_update(app)
if app_notifications_tick(app) {
save_settings(app)
}
}
{
i: s32 = 0
while i < practice_count() {
practice: *PracticeDefinition = practice_get(i)
if practice.update != null {
practice.update(app)
}
i += 1
}
}
// Streams need fresh buffers even when their controls are on another tab.
settings_audio_update_preview(app)
if app.practice_coming_soon_ticks > 0 {
app.practice_coming_soon_ticks -= 1
}
practice_screen_prepare_first_run_guide(app)
habits_screen_prepare_first_run_guide(app)
first_run_guide_active = practice_screen_first_run_guide_active(app)
habits_guide_active = habits_screen_first_run_guide_active(app)
app_clear_invalid_screen_local_modal(app)
if !AppMiniMode() {
app_maybe_open_donation_reminder(app, first_run_guide_active,
habits_guide_active)
}
// These modals cover the practice page, which must then not draw the
// same manual or configuration a second time with the same widget keys.
practice_fullscreen_modal = app.modal.active != 0 &&
(app.modal.type == cast(ModalType)ModalEditProgressiveStartSpeed ||
app.modal.type == cast(ModalType)ModalPracticeManual ||
app.modal.type == cast(ModalType)ModalPracticeConfig)
view_height = app_page_height(app, view_height)
center_y = view_height / 2
// A practice in its small window keeps running, and the navigation
// slides toward where it belongs on this screen.
app_session_window_tick(app)
app_session_nav_update(app)
// Resolve dock input before drawing the page on every viewport. A
// bottom-dock click must draw its destination in this frame, just like
// the desktop rail, so a cold page cannot swallow the next tap.
app_draw_bottom_nav(app)
app_draw_return_bar(app)
back_requested := IsKeyPressed(APP_KEY_BACK) ||
(app.launcher_open && IsKeyPressed(APP_KEY_ESCAPE))
#if !#defined(ANDROID_BUILD) && !#defined(PLATFORM_WEB) {
if IsKeyPressed(KEY_BACKSPACE) && ((app.breathing.screen == ScreenStart && app.practice_tab != PRACTICE_TAB_PLAY) || app.breathing.screen == ScreenSession || app.breathing.screen == ScreenMeditation || app.breathing.screen == ScreenSunSalutation || app.breathing.screen == ScreenPatterns) {
back_requested = true
}
}
if back_requested {
if app.launcher_open {
if app.breathing.screen != ScreenAppSelection {
app_launcher_close(app)
}
} else if app.close_prompt_open != 0 {
app.close_prompt_open = 0
} else if first_run_guide_active != 0 || habits_guide_active != 0 {
if first_run_guide_active != 0 {
practice_screen_dismiss_first_run_guide(app)
}
if habits_guide_active != 0 {
habits_screen_dismiss_first_run_guide(app)
}
} else if app.modal.active != 0 {
app_close_modal(app)
} else {
handle_back_button(app)
}
}
#if !#defined(ANDROID_BUILD) && !#defined(PLATFORM_WEB) {
// Ctrl+Q quits from any screen; Esc quits only from idle home.
if IsKeyPressed(KEY_Q) && (IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_RIGHT_CONTROL)) {
app_request_desktop_quit(app)
} else if !back_requested && IsKeyPressed(APP_KEY_ESCAPE) &&
app.breathing.screen == ScreenStart &&
app.practice_tab == PRACTICE_TAB_PLAY &&
app.modal.active == 0 && first_run_guide_active == 0 &&
habits_guide_active == 0 {
app_request_desktop_quit(app)
}
}
launcher_input: InputSnapshot
launcher_owns_input := app.launcher_open
if launcher_owns_input { launcher_input = TreeInputSuspend(app.ui.session) }
handled_screen: bool = false
if app.launcher_open {
handled_screen = true
} else if app.breathing.screen == ScreenSettings {
settings_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenProfile {
profile_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenCustomizeNav {
app_draw_customize_nav_page(app)
handled_screen = true
} else if app.breathing.screen == ScreenLanguage {
language_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenAppSelection {
app_selection_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenHabits {
draw_habits_screen(app)
handled_screen = true
} else if app.breathing.screen == ScreenLumi {
lumi_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenDiary {
diary_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenLeaderboard {
leaderboard_screen_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenEList {
draw_elist_screen(app)
handled_screen = true
} else if app.breathing.screen == ScreenHabitEdit {
habit_edit_draw(app)
handled_screen = true
} else if app.breathing.screen == ScreenHabitSessionEdit {
habit_session_draw_edit_screen(app)
handled_screen = true
} else if app.breathing.screen == ScreenBreak {
break_overlay_draw(app)
handled_screen = true
}
if !handled_screen {
if app.breathing.screen == ScreenStart {
practice_update_circle_bounds(app, app_content_top_reserved(app),
app_content_bottom_reserved(app))
} else if app.breathing.screen == ScreenSession {
practice_update_circle_bounds(app, AppTitleBarHeight(), 84)
}
if app.breathing.screen == ScreenSession {
practice_draw_active_breathing(app, center_x, center_y)
}
if app.breathing.screen == ScreenStart {
{
if !practice_fullscreen_modal && app.main_tab == APP_MAIN_TAB_NONE {
app_draw_blank_home_easteregg(app)
} else if !practice_fullscreen_modal && app.main_tab != APP_MAIN_TAB_NONE {
if app.practice_tab == PRACTICE_TAB_MANUAL {
manual_screen_draw(app)
} else if app.practice_tab == PRACTICE_TAB_CONFIG {
practice: *PracticeDefinition = practice_get(app.exercise_type)
if practice.draw_config != null {
practice.draw_config(app)
}
} else {
practice_screen_draw_home(app)
}
}
}
// Skip drawing on the same frame modal opens to prevent click propagation
if app.modal.active != 0 &&
app.modal.type == cast(ModalType)ModalMeditationSetup &&
app.blocked_input_frame != app.breathing.frame {
practice: *PracticeDefinition = practice_get(EXERCISE_MEDITATION)
if practice.draw_setup_modal != null {
practice.draw_setup_modal(app)
}
}
} else if app.breathing.screen == ScreenSession {
practice_update_active_breathing(app, center_x, center_y, *hover)
} else if app.breathing.screen == ScreenMeditation {
{
practice: *PracticeDefinition = practice_get(EXERCISE_MEDITATION)
if practice.draw_active_session != null {
practice.draw_active_session(app, center_x, center_y)
}
}
} else if app.breathing.screen == ScreenSunSalutation {
{
practice: *PracticeDefinition = practice_get(EXERCISE_SUN_SALUTATION)
if practice.draw_active_session != null {
practice.draw_active_session(app, center_x, center_y)
}
}
} else if app.breathing.screen == ScreenPatterns {
{
practice: *PracticeDefinition = practice_get(EXERCISE_PATTERNS)
if practice.draw_active_session != null {
practice.draw_active_session(app, center_x, center_y)
}
}
} else if app.breathing.screen == ScreenResults {
practice_draw_results(app, center_x, center_y, *hover)
}
}
if practice_fullscreen_modal {
draw_global_modal(app)
global_modal_drawn = true
}
if launcher_owns_input { unused TreeInputResume(app.ui.session, launcher_input) }
view_height = frame_view_height
app_draw_session_nav(app)
// The Apps screen covers the page, so the practice window is drawn on it
// while it is open.
launcher_covers_page := app.launcher_open
if !launcher_covers_page {
app_session_window_draw(app)
}
ActivityDrawIndicator(app)
app_draw_mini_expand_button(app)
practice_screen_draw_first_run_guide(app)
habits_screen_draw_first_run_guide(app)
if !global_modal_drawn {
draw_global_modal(app)
}
if !launcher_covers_page {
app_draw_close_prompt(app)
}
app_draw_launcher(app)
if launcher_covers_page {
// Apps is an overlay above the page, so the window and the close
// prompt are drawn inside its panel, above the apps. If Apps closed
// during this frame, they are drawn over the page instead.
inside_launcher := app.launcher_panel_node >= 0 &&
TreePushScope(app.ui.session, app.launcher_panel_node)
app_session_window_draw(app)
app_draw_close_prompt(app)
if inside_launcher {
unused End(app.ui.session)
}
}
app_flush_deferred_settings(app)
app_observe_direct_route_change(app, frame_route)
app.breathing.frame += 1
}
// Exchanges live activity records and sync. On Android the frame and the
// background practice timer both call this, and around picture-in-picture
// both run at once: only one exchanges at a time, so a finished sync is
// applied and released by one thread only.
app_network_pump :: (app: *InnerBreeze) {
#if #defined(ANDROID_BUILD) {
if !android_network_pump_begin() {
return
}
}
ActivityPump(app)
app_sync_pump(app)
#if #defined(ANDROID_BUILD) {
android_network_pump_end()
}
}
// Exchanges live activity records alone, under the same one-thread rule.
app_activity_pump :: (app: *InnerBreeze) {
#if #defined(ANDROID_BUILD) {
if !android_network_pump_begin() {
return
}
}
ActivityPump(app)
#if #defined(ANDROID_BUILD) {
android_network_pump_end()
}
}
// Android's practice timer exchanges live records while a practice continues
// in the background; drawing and result ownership remain on their existing
// paths.
#program_export
app_activity_background_sync :: (vapp: *void) {
app := cast(*InnerBreeze)vapp
if app == null {
return
}
app_network_pump(app)
}
app_update_draw_last_full_w: s32 = -1;
app_update_draw_last_full_h: s32 = -1;
app_update_draw_last_content_x: s32 = -1;
app_update_draw_last_content_w: s32 = -1;
app_update_draw_last_log_time: float64 = -1.0;
app_last_frame_status: s32;
app_finish_frame :: (app: *InnerBreeze) {
status: s32
paint_unchanged: bool = false
// The previous frame is presented again only when the direct draws
// match too; otherwise the frame is repainted, widgets included.
direct_unchanged := DirectDrawFrameFinish()
if app.ui.retained_target_active {
result := EndFrameRetained(app.ui.session, direct_unchanged)
status = cast(s32)result.status
paint_unchanged = result.paint_unchanged
} else {
status = cast(s32)EndFrame(app.ui.session)
}
if status != 0 && status != app_last_frame_status {
TraceLogResult(LOG_WARNING, "APP: frame rejected with status %d", status)
TraceLogResult(LOG_WARNING, "APP: rejected widget key %d",
cast(s32)TreeFrameErrorKey(app.ui.session))
TraceLogResult(LOG_WARNING, "APP: rejected widget kind %d",
TreeFrameErrorKind(app.ui.session))
}
app_last_frame_status = status
app.ui.retained_frame_unchanged = status == 0 && paint_unchanged &&
direct_unchanged
}
#program_export
app_update_draw :: (vapp: *void, viewport: Rectangle) {
app: *InnerBreeze = cast(*InnerBreeze)vapp
profile_frame_start: float64
profile_update_start: float64
profile_habits_start: float64
profile_sync_start: float64
full_width: s32
full_height: s32
content_x: s32 = 0
rail_width: s32 = 0
top_height: s32 = 0
content_w: s32
layout_width: s32
layout_height: s32
layout_content_x: s32
layout_content_w: s32
render_scale: float32
if app == null || !CellsReady() {
return
}
if viewport.width <= 0 || viewport.height <= 0 {
return
}
profile_frame_start = app_profile_now()
FrameTextReset(*app.ui.frame_text)
// Styles follow the current app route, with cached parsing between edits.
unused app_apply_style(app)
frame_sample: FrameActivitySample
frame_sample.mouse_x = app.ui.mouse_x
frame_sample.mouse_y = app.ui.mouse_y
frame_sample.pointer_active = app.ui.pointer_active
frame_sample.keyboard_active = app.ui.keyboard_active
frame_sample.text_input_active = app.ui.text_input_active
frame_decision := app_update_frame_pacing(app, frame_sample)
app.ui.frame_target_fps = frame_decision.state.target_fps
app.ui.frame_target_changed = frame_decision.apply_target
if !app_reload_graphics_resources(app) {
return
}
#if #defined(ANDROID_BUILD) {
picture_state := AndroidPictureWindowState()
app.session_window.system_visible = (picture_state & 2) != 0
generation := picture_state >> 3
if generation != app.session_window.system_generation {
app.session_window.system_generation = generation
app.session_window.system_last_tick = GetTime()
}
// Opening the floating window back into the app shows its practice,
// not the page that was open behind the practice's in-app window.
// Like other window input from outside the frame, the window tick
// applies it after the frame has read the current route.
returned := (picture_state & 4) != 0
if returned != app.session_window.system_returned {
app.session_window.system_returned = returned
app.session_window.restore_requested = true
}
if app.session_window.system_visible {
app_draw_android_picture_window(app, viewport)
return
}
app.session_window.system_last_tick = GetTime()
}
full_width = cast(s32)viewport.width
full_height = cast(s32)viewport.height
view_width = full_width
view_height = full_height
// Update DPI cache
UpdateDPI(view_width, view_height)
if !(GetDPIScale() > 0.0f) || GetDPIScale() > 8.0f {
TraceLogScale(LOG_WARNING, "APP_EMBED: repairing invalid dpi %.2f for %dx%d",
GetDPIScale(), view_width, view_height)
InitDPI()
UpdateDPI(view_width, view_height)
}
// The layout is already in density-independent units and the render
// scale applies the density, so app metrics must not scale it again.
AppMetricsConfigure(1.0)
layout_width = GetLayoutWidth()
layout_height = GetLayoutHeight()
render_scale = GetRenderScale()
if !(render_scale > 0.0f) {
render_scale = 1.0f
}
app_full_view_width = layout_width
view_width = layout_width
view_height = layout_height
app.ui.view_width = view_width
app.ui.view_height = view_height
// Freeze responsive navigation from the full viewport before narrowing content.
app_capture_navigation_viewport(app, view_width, view_height)
rail_width = ifx (app_nav_desktop_rail_enabled(app) != 0) then (app_nav_desktop_rail_width(app)) else (0)
layout_content_x = ifx (app_navigation_placement(app) == NAVIGATION_LEFT) then (rail_width) else (0)
layout_content_w = layout_width - rail_width
if layout_content_w < 1 {
layout_content_w = 1
}
content_x = cast(s32)(cast(float32)layout_content_x * render_scale + 0.5f)
rail_width = cast(s32)(cast(float32)rail_width * render_scale + 0.5f)
top_layout := app_return_bar_height(app)
if app_navigation_placement(app) == NAVIGATION_TOP {
top_layout += app_navigation_height(app)
}
top_height = cast(s32)(cast(float32)top_layout * render_scale + 0.5f)
practice_update_circle_bounds(app, app_content_top_reserved(app),
app_content_bottom_reserved(app))
app_device_preferences_update(app)
update_check_poll()
app_refresh_theme(app)
DirectDrawFrameBegin(viewport)
DrawRectangleRec(viewport, StyleTokenColor("canvas"))
content_w = full_width - rail_width
if content_w < 1 {
content_w = 1
}
{
now: float64 = GetTime()
changed := full_width != app_update_draw_last_full_w ||
full_height != app_update_draw_last_full_h ||
content_x != app_update_draw_last_content_x ||
content_w != app_update_draw_last_content_w
if changed && (app_update_draw_last_log_time < 0.0 || now - app_update_draw_last_log_time >= 0.25) {
TraceLogGeometry(LOG_INFO, "APP_EMBED: geometry viewport=%dx%d layout=%dx%d content_x=%d content=%dx%d render_scale=%.2f",
full_width, full_height, layout_width, layout_height,
layout_content_x, layout_content_w, layout_height,
GetRenderScale())
app_update_draw_last_log_time = now
}
if changed {
app_update_draw_last_full_w = full_width
app_update_draw_last_full_h = full_height
app_update_draw_last_content_x = content_x
app_update_draw_last_content_w = content_w
}
}
view_width = layout_content_w
view_height = layout_height - cast(s32)(cast(float32)top_height / render_scale + 0.5f)
app.ui.view_width = view_width
app.ui.view_height = view_height
app.camera = Camera.{}
app.camera.zoom = render_scale
app.camera.offset.x = ifx (PreviewMode() != 0) then (0.0f) else (viewport.x + cast(float32)content_x)
app.camera.offset.y = ifx (PreviewMode() != 0) then (0.0f) else (viewport.y + cast(float32)top_height)
if PreviewMode() == 0 {
DirectDrawTransform(app.camera)
}
// Retained hit testing and widget bounds use the same logical coordinates
// as the camera. A left navigation rail occupies negative content x.
frame_origin := Vector2.{0.0, 0.0}
if PreviewMode() == 0 {
frame_origin = ScreenToWorld(Vector2.{viewport.x, viewport.y}, app.camera)
}
logical_frame := Rectangle.{frame_origin.x, frame_origin.y,
viewport.width / render_scale, viewport.height / render_scale}
app.ui.retained_frame_unchanged = false
if cast(s32)BeginFrame(app.ui.session, KeyHash("inbe/frame"),
logical_frame) != 0 {
return
}
if PreviewMode() != 0 {
DrawRectangle(0, 0, view_width, view_height, StyleTokenColor("canvas"))
profile_update_start = app_profile_now()
updateapp(app)
app_profile_record_update(profile_update_start)
app_breaks_draw_toast(app,
Rectangle.{0.0, 0.0, cast(float32)view_width, cast(float32)view_height})
app_route_transition_draw(app, logical_frame, GetTime())
app_finish_frame(app)
} else {
BeginScissorMode(cast(s32)viewport.x, cast(s32)viewport.y,
full_width, full_height)
BeginMode2D(app.camera)
DrawRectangle(0, 0, view_width, view_height, StyleTokenColor("canvas"))
profile_update_start = app_profile_now()
updateapp(app)
app_profile_record_update(profile_update_start)
app_breaks_draw_toast(app,
Rectangle.{0.0, 0.0, cast(float32)view_width, cast(float32)view_height})
app_route_transition_draw(app, logical_frame, GetTime())
app_finish_frame(app)
EndMode2D()
EndScissorMode()
}
profile_habits_start = app_profile_now()
if app.request_quit != 0 {
return
}
if TelegramAccountFlowOwnsContext() {
TelegramAccountFlowPump(app)
app_activity_pump(app)
app_profile_frame_end(profile_frame_start)
return
}
app_flush_habits_after_frame(app)
app_profile_record_habits(profile_habits_start)
profile_sync_start = app_profile_now()
settings_sync_account_pump(app)
app_network_pump(app)
// Lumi and package requests run on the frame thread on every platform.
if !app_practice_holds_frame_work(app) {
app_lumi_pump(app)
PackagePump(app.enabled_apps, cast(s32)PackageNow())
}
if app.app_choices_pending && practice_active(app) == null && app.modal.active == 0 &&
app.breathing.screen != ScreenHabitEdit && app.breathing.screen != ScreenHabitSessionEdit &&
app_diary_save() {
app_reload_app_choices(app)
app.app_choices_pending = false
}
if app.package_revision != PackageRevision() && app.modal.active == 0 &&
practice_active(app) == null &&
app.breathing.screen != ScreenHabitEdit && app.breathing.screen != ScreenHabitSessionEdit &&
app_diary_save() {
if CellsReloadFeatures(app.enabled_apps) {
#if #defined(PLATFORM_WEB) {
InvalidateCanvasAssets()
} else {
InvalidateRaylibAssets()
}
app.package_revision = PackageRevision()
app_diary_reset()
app_update_app_navigation(app)
}
}
app_profile_record_sync(profile_sync_start)
app_profile_frame_end(profile_frame_start)
}
// Android supplies the floating activity surface. Draw only the live practice,
// with a stable 200-unit layout while the OS moves and resizes it.
app_draw_android_picture_window :: (app: *InnerBreeze, viewport: Rectangle) {
#if #defined(ANDROID_BUILD) {
now := GetTime()
elapsed := now - app.session_window.system_last_tick
app.session_window.system_last_tick = now
// The in-app card must not replay the whole PiP interval on return.
app.session_window.last_tick = now
practice := practice_active(app)
if practice != null {
screen := app.session_window.screen
if screen == ScreenStart {
screen = app.breathing.screen
}
app.session_window.system_screen = screen
if app.backgrounded == 0 && elapsed > 0.0 && practice.advance_elapsed != null {
total := elapsed * 1000.0 + app.session_window.system_elapsed_carry
milliseconds := cast(s32)total
app.session_window.system_elapsed_carry = total - cast(float64)milliseconds
practice.advance_elapsed(app, milliseconds)
}
}
scale := viewport.width / 200.0
bounds := Rectangle.{0.0, 0.0, 200.0, viewport.height / scale}
camera: Camera
camera.zoom = scale
camera.offset = Vector2.{viewport.x, viewport.y}
AppMetricsConfigure(1.0)
DirectDrawFrameBegin(viewport)
DrawRectangleRec(viewport, StyleTokenColor("surface"))
if cast(s32)BeginFrame(app.ui.session, KeyHash("inbe/picture-window"), bounds) == 0 {
BeginMode2D(camera)
app_session_window_picture(app, app.session_window.system_screen, bounds, 0.0)
app_finish_frame(app)
EndMode2D()
}
app_network_pump(app)
}
unused app
unused viewport
}
#program_export
app_destroy :: (vapp: *void) {
app: *InnerBreeze = cast(*InnerBreeze)vapp
i: s32
if app == null {
return
}
if !CellsReady() {
CellsClose()
return
}
if TelegramAccountFlowOwnsContext() {
// Closing preserves the protected delegate for an explicitly verified
// Restore on the next launch; only Cancel or revocation clears it.
TelegramFlowStopOperations(*telegram_account_flow)
TelegramFlowWipeSecrets(*telegram_account_flow)
telegram_account_flow.hosted = false
ClearDelegate()
}
CloseBreakWindows()
ClosePracticeWindow(app)
ReleaseRuntimeAssetDownload(*app.meditation.music_download)
unused app_diary_save()
PackageCancel()
save_settings(app)
settings_sync_account_cancel(app)
LumiOnlineCancel()
app_clear_disconnected_sync_work()
android_text_input_close(app.ui.session)
SessionClose(app.ui.session)
habits_flush_save(app)
if PreviewMode() == 0 {
ReleaseLocaleFont(app)
}
{
i: s32 = 0
while i < practice_count() {
practice: *PracticeDefinition = practice_get(i)
if practice.destroy != null {
practice.destroy(app)
}
i += 1
}
}
settings_audio_stop_preview(app)
app_audio_shutdown(app)
app_diary_reset()
app_lumi_reset()
app.* = InnerBreeze.{}
CellsClose()
}
#program_export
app_should_use_tab_bar :: (app: *InnerBreeze) -> s32 {
if app == null {
return 0
}
return ifx (app.navigation_mode == NAV_MODE_TABBAR) then (1) else (0)
}