def render_labeled_variable( id: str, label: str, variable: Variable, value: T, formatter: VariableFormatter, is_edited: bool, label_width=80, value_width=80, ) -> Tuple[Maybe[T], bool]: ig.push_id(id) ig.selectable(label + '##label', width=label_width) if ig.begin_drag_drop_source(): ig.text(label) ig.set_drag_drop_payload('ve-var', variable.to_bytes()) ig.end_drag_drop_source() ig.same_line() cell_width = value_width cell_height = ig.get_text_line_height( ) + 2 * ig.get_style().frame_padding[1] cell_cursor_pos = ig.get_cursor_pos() cell_cursor_pos = ( cell_cursor_pos[0] + ig.get_window_position()[0] - ig.get_scroll_x(), cell_cursor_pos[1] + ig.get_window_position()[1] - ig.get_scroll_y(), ) changed_data, _, _ = render_variable_value( 'value', value, formatter, (cell_width, cell_height), ) clear_edit = is_edited and ig.is_item_hovered() and ig.is_mouse_down(2) if is_edited: dl = ig.get_window_draw_list() spacing = ig.get_style().item_spacing spacing = (spacing[0] / 2, spacing[1] / 2) dl.add_rect( cell_cursor_pos[0] - spacing[0], cell_cursor_pos[1] - spacing[1], cell_cursor_pos[0] + cell_width + spacing[0] - 1, cell_cursor_pos[1] + cell_height + spacing[1] - 1, ig.get_color_u32_rgba(0.8, 0.6, 0, 1), ) ig.pop_id() return changed_data, clear_edit
def render_object_slots( id: str, behaviors: List[Optional[ObjectBehavior]], behavior_name: Callable[[ObjectBehavior], str], ) -> Optional[int]: ig.push_id(id) button_size = 50 window_left = ig.get_window_position()[0] window_right = window_left + ig.get_window_content_region_max()[0] prev_item_right = window_left style = ig.get_style() result = None for slot, behavior in enumerate(behaviors): item_right = prev_item_right + style.item_spacing[0] + button_size if item_right > window_right: prev_item_right = window_left elif slot != 0: ig.same_line() prev_item_right = prev_item_right + style.item_spacing[0] + button_size if behavior is None: label = str(slot) else: label = str(slot) + '\n' + behavior_name(behavior) if ig.button(label + '##slot-' + str(slot), button_size, button_size): result = slot ig.pop_id() return result
def is_mouse_in_window(self) -> bool: if not ig.global_mouse_capture(): return False window_x, window_y = cast(Iterable[float], ig.get_window_position()) window_w, window_h = cast(Iterable[float], ig.get_window_size()) return self.mouse_pos[0] >= window_x and self.mouse_pos[0] < window_x + window_w and \ self.mouse_pos[1] >= window_y and self.mouse_pos[1] < window_y + window_h
def get_viewport(framebuffer_size: Tuple[int, int]) -> core.Viewport: window_pos = tuple(map(int, ig.get_window_position())) window_size = tuple(map(int, ig.get_window_size())) viewport = core.Viewport() viewport.x = window_pos[0] viewport.y = window_pos[1] viewport.width = window_size[0] viewport.height = window_size[1] return viewport
def render_frame_slider( id: str, current_frame: int, num_frames: int, loaded_frames: List[int] = [], ) -> Maybe[int]: ig.push_id(id) pos = ig.get_cursor_pos() pos = ( pos[0] + ig.get_window_position()[0], pos[1] + ig.get_window_position()[1] - ig.get_scroll_y(), ) width = ig.get_content_region_available_width() ig.push_item_width(width) changed, new_frame = ig.slider_int( '##slider', current_frame, 0, num_frames - 1, ) ig.pop_item_width() dl = ig.get_window_draw_list() for frame in loaded_frames: line_pos = pos[0] + frame / num_frames * width dl.add_line( line_pos, pos[1] + 13, line_pos, pos[1] + 18, ig.get_color_u32_rgba(1, 0, 0, 1), ) ig.pop_id() if changed: return Just(new_frame) else: return None
def render_input_text_with_error( id: str, value: str, buffer_size: int, width: int, validate: Callable[[str], T], ) -> Maybe[T]: ig.push_id(id) 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(width) changed, new_value = ig.input_text('##input', value, buffer_size) ig.pop_item_width() result_value = None if changed: try: result_value = Just(validate(new_value)) except: # TODO: Show error message dl = ig.get_window_draw_list() dl.add_rect( cursor_pos[0], cursor_pos[1], cursor_pos[0] + width, cursor_pos[1] + ig.get_text_line_height() + 2 * ig.get_style().frame_padding[1], ig.get_color_u32_rgba(1, 0, 0, 1), ) new_value = value ig.pop_id() return result_value
def render_variable_cell( id: str, value: T, formatter: VariableFormatter, cell_size: Tuple[int, int], is_selected: bool, frame: Optional[int] = None, highlight_range: Optional[Tuple[range, ig.Color4f]] = None, ) -> Tuple[Maybe[T], bool, bool, bool]: ig.push_id(id) window_pos = ig.get_window_position() item_spacing = ig.get_style().item_spacing cell_cursor_pos = ig.get_cursor_pos() cell_cursor_pos = ( cell_cursor_pos.x + window_pos.x - item_spacing.x, cell_cursor_pos.y + window_pos.y - ig.get_scroll_y() - item_spacing.y, ) if highlight_range is not None: assert frame is not None frames, color = highlight_range margin = 5 offset_top = margin if frame == frames.start else 0 offset_bottom = margin if frame == frames.stop - 1 else 0 dl = ig.get_window_draw_list() dl.add_rect_filled( cell_cursor_pos[0] + margin, cell_cursor_pos[1] + offset_top, cell_cursor_pos[0] + cell_size[0] - margin, cell_cursor_pos[1] + cell_size[1] - offset_bottom, ig.get_color_u32_rgba(*color), ) changed_data, selected, pressed = render_variable_value( 'value', value, formatter, ( cell_size[0] - 2 * item_spacing.x, cell_size[1] - 2 * item_spacing.y, ), highlight=is_selected, ) clear_edit = ig.is_item_hovered() and ig.is_mouse_down(2) ig.pop_id() return changed_data, clear_edit, selected, pressed
def get_normalized_mouse_pos() -> Optional[Tuple[float, float]]: if not ig.global_mouse_capture(): return None window_pos = tuple(map(int, ig.get_window_position())) window_size = tuple(map(int, ig.get_window_size())) mouse_pos = tuple(map(float, ig.get_mouse_pos())) mouse_pos = ( mouse_pos[0] - window_pos[0], window_size[1] - mouse_pos[1] + window_pos[1], ) mouse_pos = ( 2 * mouse_pos[0] / window_size[0] - 1, 2 * mouse_pos[1] / window_size[1] - 1, ) if any(c < -1 or c > 1 for c in mouse_pos): return None return mouse_pos
def get_drag_amount(self) -> Tuple[float, float]: mouse_was_down = self.mouse_down last_mouse_pos = self.mouse_pos self.mouse_down = ig.is_mouse_down() and ig.global_mouse_capture() self.mouse_pos = ig.get_mouse_pos() if self.dragging: if not self.mouse_down: self.dragging = False return ( self.mouse_pos[0] - last_mouse_pos[0], self.mouse_pos[1] - last_mouse_pos[1], ) elif not mouse_was_down and self.mouse_down and not ig.is_any_item_hovered( ): window_x, window_y = ig.get_window_position() window_w, window_h = ig.get_window_size() if self.mouse_pos[0] >= window_x and self.mouse_pos[0] < window_x + window_w and \ self.mouse_pos[1] >= window_y and self.mouse_pos[1] < window_y + window_h: self.dragging = True return (0, 0)
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_joystick_control( id: str, stick_x: float, stick_y: float, shape='square', ) -> Optional[Tuple[float, float]]: ig.push_id(id) state = use_state('', JoystickControlState()).value dl = ig.get_window_draw_list() padding = 10 content_region = ig.get_content_region_available() size = min( content_region.x - ig.get_style().scrollbar_size - 2 * padding, content_region.y - 2 * padding, 200, ) size = max(size, 100) initial_cursor_pos = ig.get_cursor_pos() top_left = ( initial_cursor_pos[0] + ig.get_window_position()[0] - ig.get_scroll_x() + padding, initial_cursor_pos[1] + ig.get_window_position()[1] - ig.get_scroll_y() + padding, ) background_color = ig.get_color_u32_rgba(0, 0, 0, 0.3) if shape == 'square': dl.add_rect_filled( top_left[0], top_left[1], top_left[0] + size, top_left[1] + size, background_color, ) elif shape == 'circle': dl.add_circle_filled( top_left[0] + size / 2, top_left[1] + size / 2, size / 2, background_color, num_segments=32, ) result = None if state.active and ig.is_mouse_down(): new_offset = state.get_value(ig.get_mouse_drag_delta(lock_threshold=0)) new_stick_x = new_offset[0] / size * 2 - 1 new_stick_y = (1 - new_offset[1] / size) * 2 - 1 if shape == 'square': new_stick_x = min(max(new_stick_x, -1), 1) new_stick_y = min(max(new_stick_y, -1), 1) elif shape == 'circle': mag = math.sqrt(new_stick_x**2 + new_stick_y**2) if mag > 1: new_stick_x /= mag new_stick_y /= mag if (new_stick_x, new_stick_y) != (stick_x, stick_y): stick_x, stick_y = new_stick_x, new_stick_y result = (stick_x, stick_y) offset = ( (stick_x + 1) / 2 * size, (1 - (stick_y + 1) / 2) * size, ) dl.add_line( top_left[0] + size / 2, top_left[1] + size / 2, top_left[0] + offset[0], top_left[1] + offset[1], ig.get_color_u32_rgba(1, 1, 1, 0.5), ) button_size = 20 button_pos = ( padding + initial_cursor_pos[0] + offset[0] - button_size / 2, padding + initial_cursor_pos[1] + offset[1] - button_size / 2, ) ig.set_cursor_pos(button_pos) ig.button('##joystick-button', button_size, button_size) ig.set_cursor_pos(( initial_cursor_pos[0], initial_cursor_pos[1] + size + 2 * padding, )) if ig.is_item_active(): state.set_active(offset) else: state.reset() ig.pop_id() return result
def render_rows(self) -> None: ig.columns(len(self.columns) + 1) min_row = int(ig.get_scroll_y() + self.scroll_delta) // self.row_height - 1 min_row = max(min_row, 0) max_row = int(ig.get_scroll_y() + self.scroll_delta + ig.get_window_height()) // self.row_height # max_row = min(max_row, self.get_row_count() - 1) self.sequence.extend_to_frame(max_row + 100) timeline_operations: List[Callable[[], None]] = [] mouse_pos = ( ig.get_mouse_pos().x - ig.get_window_position().x, ig.get_mouse_pos().y - ig.get_window_position().y + ig.get_scroll_y() + self.scroll_delta, ) for row in range(min_row, max_row + 1): row_pos = (0.0, row * self.row_height - self.scroll_delta) ig.set_cursor_pos(row_pos) mouse_in_row = mouse_pos[1] > row_pos[1] and mouse_pos[ 1] <= row_pos[1] + self.row_height if mouse_in_row and self.dragging and time.time( ) - self.time_started_dragging > 0.1: self.drag_handler.update_drag(row) if len(self.columns) > 0: ig.set_column_width(-1, self.frame_column_width) clicked, _ = ig.selectable( str(row) + '##fs-framenum-' + str(id(self)) + '-' + str(row), row == self.sequence.selected_frame, height=self.row_height - 8, # TODO: Compute padding ) if clicked: self.sequence.set_selected_frame(row) if ig.begin_popup_context_item('##fs-framenumctx-' + str(id(self)) + '-' + str(row)): if ig.selectable('Insert above')[0]: def op(row): return lambda: self.sequence.insert_frame(row) timeline_operations.append(op(row)) if ig.selectable('Insert below')[0]: def op(row): return lambda: self.sequence.insert_frame(row + 1) timeline_operations.append(op(row)) if ig.selectable('Delete')[0]: def op(row): return lambda: self.sequence.delete_frame(row) timeline_operations.append(op(row)) ig.end_popup_context_item() ig.next_column() for column in self.columns: self.render_cell(row, column) ig.set_column_width(-1, column.width) ig.next_column() ig.separator() ig.set_cursor_pos((0, (self.sequence.max_frame + 1) * self.row_height)) ig.columns(1) for operation in timeline_operations: operation()
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, )