def _render_checkbox(
value: T,
formatter: VariableFormatter,
size: Tuple[int, int],
highlight: bool,
) -> Tuple[Maybe[T], bool, bool]:
cursor_pos = ig.get_cursor_pos()
_, input = ig.checkbox('##checkbox', dcast(bool, formatter.output(value)))
ig.set_cursor_pos(cursor_pos)
clicked, _ = ig.selectable(
'##checkbox-background',
highlight,
width=size[0],
height=size[1],
)
pressed = ig.is_item_hovered() and ig.is_mouse_clicked()
input_value = formatter.input(input)
assert type(input_value) == type(value)
if input_value != value:
return Just(cast(T, input_value)), clicked, pressed
else:
return None, clicked, pressed
def begin_binding_form() -> None:
controls: Ref[List[str]] = use_state('controls', [])
listening_for: Ref[Optional[str]] = use_state('listening-for', None)
waiting_for_release: Ref[bool] = use_state('waiting-for-release', False)
if ig.is_mouse_clicked():
listening_for.value = None
if listening_for.value is not None:
input = detect_input()
if input is not None and not waiting_for_release.value:
bindings[listening_for.value] = input
config.settings['bindings'] = bindings_to_json(bindings)
if listening_for.value in controls.value:
index = controls.value.index(listening_for.value) + 1
listening_for.value = controls.value[index] if index < len(
controls.value) else None
waiting_for_release.value = True
else:
listening_for.value = None
if input is None:
waiting_for_release.value = False
controls.value = []
def render_headers(self) -> None:
header_labels = [
self.displayer.column_header(column.variable)
for column in self.columns
]
header_lines = max((len(label.split('\n')) for label in header_labels),
default=1)
ig.columns(len(self.columns) + 1)
if len(self.columns) > 0:
ig.set_column_width(-1, self.frame_column_width)
ig.text('')
ig.next_column()
for index, column in enumerate(self.columns):
initial_cursor_pos = ig.get_cursor_pos()
ig.selectable(
'##fs-col-' + str(id(self)) + '-' + str(id(column)),
height=header_lines * ig.get_text_line_height(),
)
# TODO: Width adjusting
ig.set_column_width(-1, column.width)
if ig.begin_drag_drop_source():
ig.text(header_labels[index])
ig.set_drag_drop_payload('fs-col', str(index).encode('utf-8'))
ig.end_drag_drop_source()
if ig.begin_drag_drop_target():
payload = ig.accept_drag_drop_payload('fs-col')
if payload is not None:
source = int(payload.decode('utf-8'))
self._move_column(source, index)
payload = ig.accept_drag_drop_payload('ve-var')
if payload is not None:
self._insert_variable(index, Variable.from_bytes(payload))
ig.end_drag_drop_target()
if ig.is_item_hovered() and ig.is_mouse_clicked(2):
self._remove_column(index)
if ig.begin_popup_context_item('##fs-colctx-' + str(id(self)) +
'-' + str(id(column))):
if ig.selectable('Close')[0]:
self._remove_column(index)
ig.end_popup_context_item()
ig.set_cursor_pos(initial_cursor_pos)
ig.text(header_labels[index])
ig.next_column()
ig.separator()
ig.columns(1)
def _render_text(
value: T,
formatter: VariableFormatter,
size: Tuple[int, int],
highlight: bool,
) -> Tuple[Maybe[T], bool, bool]:
editing = use_state('editing', False)
initial_focus = use_state('initial-focus', False)
if not editing.value:
clicked, _ = ig.selectable(
dcast(str, formatter.output(value)) + '##text',
highlight,
width=size[0],
height=size[1],
flags=ig.SELECTABLE_ALLOW_DOUBLE_CLICK,
)
if clicked:
if ig.is_mouse_double_clicked():
editing.value = True
initial_focus.value = False
pressed = ig.is_item_hovered() and ig.is_mouse_clicked()
return None, clicked, pressed
cursor_pos = ig.get_cursor_pos()
cursor_pos = (
ig.get_window_position()[0] + cursor_pos[0],
ig.get_window_position()[1] + cursor_pos[1] - ig.get_scroll_y(),
)
ig.push_item_width(size[0])
value_text = dcast(str, formatter.output(value))
buffer_size = len(value_text) + ig.get_clipboard_length() + 1000
_, input = ig.input_text('##text-edit', value_text, buffer_size)
ig.pop_item_width()
if not initial_focus.value:
ig.set_keyboard_focus_here(-1)
initial_focus.value = True
elif not ig.is_item_active():
editing.value = False
try:
input_value = formatter.input(input)
assert type(input_value) is type(value)
if input_value != value:
return Just(cast(T, input_value)), False, False
except:
# TODO: Show error message
dl = ig.get_window_draw_list()
dl.add_rect(
cursor_pos[0],
cursor_pos[1],
cursor_pos[0] + size[0],
cursor_pos[1] + ig.get_text_line_height() +
2 * ig.get_style().frame_padding[1],
ig.get_color_u32_rgba(1, 0, 0, 1),
)
return None, False, False
def render_left_column(self, framebuffer_size: Tuple[int, int]) -> None:
total_height = ig.get_window_height() - ig.get_frame_height() # subtract menu bar
slider_space = 45
wall_hitbox_radius = use_state('wall-hitbox-radius', 50)
wall_hitbox_options = [0, 24, 50, 110]
hovered_surface: Ref[Optional[int]] = use_state('hovered-surface', None)
new_hovered_surface: Optional[int] = None
hidden_surfaces_by_area = \
use_state('hidden-surfaces', cast(Dict[Tuple[int, int], Set[int]], {})).value
current_area = (
dcast(int, self.model.get(Variable('level-num').with_frame(self.model.selected_frame))),
dcast(int, self.model.get(Variable('area-index').with_frame(self.model.selected_frame))),
)
hidden_surfaces = hidden_surfaces_by_area.setdefault(current_area, set())
log.timer.begin('gview1')
ig.begin_child(
'Game View 1',
height=int(total_height // 2) - slider_space // 2,
border=True,
)
hovered_surface_1 = ui.render_game_view_rotate(
'game-view-1',
framebuffer_size,
self.model,
wall_hitbox_radius.value,
hovered_surface.value,
hidden_surfaces,
)
ig.set_cursor_pos((10.0, ig.get_window_height() - 30))
ig.text('wall radius')
ig.same_line()
ig.push_item_width(50)
_, index = ig.combo(
'##wall-hitbox-radius',
wall_hitbox_options.index(wall_hitbox_radius.value),
list(map(str, wall_hitbox_options)),
)
wall_hitbox_radius.value = wall_hitbox_options[index]
ig.pop_item_width()
ig.end_child()
log.timer.end()
log.timer.begin('gview2')
ig.begin_child(
'Game View 2',
height=int(total_height // 2) - slider_space // 2,
border=True,
)
hovered_surface_2 = ui.render_game_view_birds_eye(
'game-view-2',
framebuffer_size,
self.model,
wall_hitbox_radius.value,
hovered_surface.value,
hidden_surfaces,
)
ig.end_child()
log.timer.end()
new_hovered_surface = hovered_surface_1 or hovered_surface_2
if new_hovered_surface is not None and ig.is_mouse_clicked(1):
ig.open_popup('surface-ctx')
hovered_surface.value = new_hovered_surface
if ig.begin_popup('surface-ctx'):
if hovered_surface.value is not None:
if hovered_surface.value in hidden_surfaces:
if ig.menu_item('Show')[0]:
hidden_surfaces.remove(hovered_surface.value)
else:
if ig.menu_item('Hide')[0]:
hidden_surfaces.add(hovered_surface.value)
if ig.menu_item('Properties')[0]:
self.variable_explorer.open_surface_tab(hovered_surface.value)
ig.end_popup()
else:
hovered_surface.value = new_hovered_surface
if hovered_surface.value is not None and ig.is_mouse_clicked(2):
if hovered_surface.value in hidden_surfaces:
hidden_surfaces.remove(hovered_surface.value)
else:
hidden_surfaces.add(hovered_surface.value)
speed_options = [0.05, 0.25, 0.5, 1, 2, 4]
saved_play_direction = use_state('saved-play-direction', 0)
saved_speed_index = use_state('saved-speed-index', 3)
play_direction = saved_play_direction.value
speed_index = saved_speed_index.value
if play_direction == 0:
frame_advance = 0
play_override = 0
def control(name: str, speed: int) -> None:
nonlocal frame_advance, play_override
x = input_down_gradual(name, 0.25)
if x == 1.0:
play_override = speed
elif input_pressed(name):
frame_advance += speed
control('frame-next', 1)
control('frame-next-alt', 1)
control('frame-prev', -1)
control('frame-prev-alt', -1)
control('frame-next-fast', 10)
control('frame-prev-fast', -10)
if play_override != 0:
if abs(play_override) in speed_options:
speed_index = speed_options.index(abs(play_override))
else:
speed_index = len(speed_options) - 1
play_direction = 1 if play_override > 0 else -1
else:
self.model.selected_frame += frame_advance
else:
if input_down('frame-next') or input_down('frame-next-alt'):
if play_direction == 1:
speed_index += 1
else:
play_direction = -play_direction
elif input_down('frame-prev') or input_down('frame-prev-alt'):
if play_direction == -1:
speed_index += 1
else:
play_direction = -play_direction
elif input_down('frame-next-fast'):
if play_direction == 1:
speed_index += 2
else:
play_direction = -play_direction
speed_index += 1
elif input_down('frame-prev-fast'):
if play_direction == -1:
speed_index += 2
else:
play_direction = -play_direction
speed_index += 1
speed_index = min(max(speed_index, 0), len(speed_options) - 1)
self.model.play_speed = play_direction * speed_options[speed_index]
self.model.playback_mode = saved_play_direction.value != 0
def play_button(label: str, direction: int) -> None:
disabled = play_direction == direction
if ig.disableable_button(label, enabled=play_direction != direction):
saved_play_direction.value = direction
play_button('<|', -1)
ig.same_line()
play_button('||', 0)
ig.same_line()
play_button('|>', 1)
ig.same_line()
ig.push_item_width(63)
changed, new_index = ig.combo(
'##speed-option',
speed_index,
[str(s) + 'x' for s in speed_options],
)
ig.pop_item_width()
if changed:
saved_speed_index.value = new_index
if input_pressed('playback-play'):
if saved_play_direction.value == 0:
saved_play_direction.value = 1
else:
saved_play_direction.value = 0
if input_pressed('playback-rewind'):
if saved_play_direction.value == 0:
saved_play_direction.value = -1
else:
saved_play_direction.value = 0
if input_pressed('playback-speed-up'):
saved_speed_index.value = min(saved_speed_index.value + 1, len(speed_options) - 1)
if input_pressed('playback-slow-down'):
saved_speed_index.value = max(saved_speed_index.value - 1, 0)
ig.same_line()
new_frame = ui.render_frame_slider(
'frame-slider',
self.model.selected_frame,
self.model.max_frame - 1,
self.model.pipeline.cached_frames() if self.show_debug_pane else [],
)
if new_frame is not None:
self.model.selected_frame = new_frame.value
def render_tabs(
id: str,
tabs: List[TabInfo],
open_tab_index: Optional[int] = None,
allow_windowing=False,
) -> Tuple[Optional[int], Optional[int]]:
ig.push_id(id)
root_id = get_local_state_id_stack()
ig.columns(2)
closed_tab = None
rendered = use_state('rendered', False)
if not rendered.value:
rendered.value = True
ig.set_column_width(-1, 120)
if len(tabs) == 0:
ig.pop_id()
return None, closed_tab
selected_tab_index = use_state_with('selected-tab-index',
lambda: open_tab_index or 0)
selected_tab_id = use_state_with('selected-tab',
lambda: tabs[selected_tab_index.value].id)
if open_tab_index is not None:
selected_tab_index.value = open_tab_index
selected_tab_id.value = tabs[open_tab_index].id
windowed_tabs = use_state('windowed-tabs', cast(Set[str], set())).value
# TODO: Change selected tab if windowed
# Handle deletion/insertion
if selected_tab_index.value >= len(tabs):
selected_tab_index.value = len(tabs) - 1
if tabs[selected_tab_index.value].id != selected_tab_id.value:
matching_indices = [
i for i in range(len(tabs)) if tabs[i].id == selected_tab_id.value
]
if len(matching_indices) > 0:
selected_tab_index.value = matching_indices[0]
else:
selected_tab_id.value = tabs[selected_tab_index.value].id
ig.begin_child('tabs')
for i, tab in enumerate(tabs):
if tab.id in windowed_tabs:
continue
_, selected = ig.selectable(
tab.label + '##tab-' + tab.id,
selected_tab_id.value == tab.id,
)
if selected:
selected_tab_index.value = i
selected_tab_id.value = tab.id
if tab.closable and ig.is_item_hovered() and ig.is_mouse_clicked(2):
closed_tab = i
if allow_windowing or tab.closable:
if ig.begin_popup_context_item(f'##ctx-{tab.id}'):
if allow_windowing and ig.selectable('Pop out')[0]:
windowed_tabs.add(tab.id)
if tab.closable and ig.selectable('Close')[0]:
closed_tab = i
ig.end_popup_context_item()
ig.end_child()
ig.next_column()
ig.begin_child('content', flags=ig.WINDOW_HORIZONTAL_SCROLLING_BAR)
tab = tabs[selected_tab_index.value]
if tab.id not in windowed_tabs:
push_local_state_rebase(('rebase-tabs', ) + root_id)
tab.render(tab.id) # type: ignore
pop_local_state_rebase()
ig.end_child()
ig.columns(1)
for tab_id in set(windowed_tabs):
matching = [tab for tab in tabs if tab.id == tab_id]
if len(matching) == 0:
windowed_tabs.remove(tab.id)
continue
tab = matching[0]
ig.set_next_window_size(*ig.get_window_size(), ig.ONCE)
ig.set_next_window_position(*ig.get_window_position(), ig.ONCE)
ig.push_style_color(ig.COLOR_WINDOW_BACKGROUND, 0.06, 0.06, 0.06, 0.94)
_, opened = ig.begin(
tab.label + '##window-' + tab.id,
closable=True,
flags=ig.WINDOW_HORIZONTAL_SCROLLING_BAR,
)
push_local_state_rebase(('rebase-tabs', ) + root_id)
tab.render(tab.id) # type: ignore
pop_local_state_rebase()
ig.end()
ig.pop_style_color()
if not opened:
windowed_tabs.remove(tab.id)
ig.pop_id()
return (
None if open_tab_index == selected_tab_index.value else
selected_tab_index.value,
closed_tab,
)