Ejemplo n.º 1
0
    def __init__(
        self,
        parent: core.NodePath,
        tile_manager: manager.Manager,
        handle_type_selected: typing.Callable[
            [map_objects.sprite_type_descriptor.Descriptor], None],
    ):
        self._tile_manager = tile_manager
        self._handle_type_selected = handle_type_selected

        self._frame = DirectGui.DirectScrolledFrame(
            parent=parent,
            pos=core.Vec3(0.04, 0),
            canvasSize=(0, 0.54, -1, 0),
            frameSize=(0, 0.6, 0.05, 1.68),
            frameColor=(0.65, 0.65, 0.65, 1),
            relief=DirectGuiGlobals.SUNKEN,
            scrollBarWidth=0.04,
            state=DirectGuiGlobals.NORMAL,
        )
        self._selected_frame: DirectGui.DirectButton = None
        self._sprite_frames: typing.List[DirectGui.DirectButton] = []
        self._bind_scroll(self._frame)
        self._top = 0.0
Ejemplo n.º 2
0
    def __init__(
        self,
        parent: DirectGui.DirectFrame,
        frame_size: typing.Tuple[float, float, float, float],
        tile_manager: manager.Manager,
        on_tile_selected: typing.Callable[[int], None],
    ):
        self._tile_manager = tile_manager
        self._on_tile_selected = on_tile_selected
        self._tile_indices: typing.Optional[typing.List[int]] = None

        self._frame = DirectGui.DirectScrolledFrame(
            parent=parent,
            canvasSize=(0, 1, -1, 0),
            frameSize=frame_size,
            frameColor=(0.65, 0.65, 0.65, 1),
            relief=DirectGuiGlobals.SUNKEN,
            scrollBarWidth=0.04,
            state=DirectGuiGlobals.NORMAL,
        )
        self._bind_scroll(self._frame)

        self._selected_tile: DirectGui.DirectFrame = None
        self._tile_frames: typing.Dict[int, DirectGui.DirectFrame] = {}
Ejemplo n.º 3
0
    def __init__(
        self,
        parent: core.NodePath,
        audio_manager: manager.Manager,
        task_manager: Task.TaskManager,
        edit_mode_selector: edit_mode.EditMode,
    ):
        path = find_resource("sound_names.yaml")
        with open(path, "r") as file:
            self._sound_descriptors = yaml.safe_load(file.read())
        self._dialog = DirectGui.DirectFrame(
            parent=parent,
            frameSize=(-1.02, 1.02, -0.95, 0.95),
            frameColor=(0.85, 0.85, 0.85, 1),
            relief=DirectGuiGlobals.RAISED,
            borderWidth=(0.01, 0.01),
        )
        self._dialog.hide()

        self._frame = DirectGui.DirectScrolledFrame(
            parent=self._dialog,
            frameColor=(0.65, 0.65, 0.65, 1),
            frameSize=(-1, 1, -0.8, 0.93),
            canvasSize=(0, self._CANVAS_WIDTH, -1, 0),
            scrollBarWidth=0.04,
            relief=DirectGuiGlobals.SUNKEN,
        )
        self._bind_scroll(self._frame)

        self._audio_manager = audio_manager
        self._task_manager = task_manager
        self._edit_mode_selector = edit_mode_selector

        self._preview_sound: core.AudioSound = None
        self._selected_sound_index = -1
        self._stop_sound_callback: typing.Callable[[], None] = None
        self._selected_label: DirectGui.DirectButton = None
        self._clicked_label: DirectGui.DirectButton = None
        self._sound_selected: typing.Callable[[int], None] = None

        self._categorized_sound_names: typing.Dict[str, typing.List[int]] = defaultdict(
            lambda: []
        )
        for index, descriptor in self._sound_descriptors.items():
            sounds = self._categorized_sound_names[descriptor["category"]]
            sounds.append(index)

        self._labels: typing.Dict[int, DirectGui.DirectButton] = {}
        half_height = self._TEXT_FRAME_SCALE / (2 * constants.TEXT_SIZE)
        for sound_index, descriptor in self._sound_descriptors.items():
            text = f"{sound_index}. {descriptor['name']}"
            label = DirectGui.DirectButton(
                parent=self._canvas,
                frameSize=(
                    0,
                    self._DESCRIPTION_WIDTH / constants.TEXT_SIZE,
                    -half_height,
                    half_height,
                ),
                frameColor=(0, 0, 0, 0),
                scale=constants.TEXT_SIZE,
                text=text,
                text_align=core.TextNode.A_left,
                text_wordwrap=(self._DESCRIPTION_WIDTH) / constants.TEXT_SIZE,
            )
            self._bind_scroll(label)

            label["extraArgs"] = [label, sound_index, descriptor]
            label["command"] = self._select_sound
            self._labels[sound_index] = label

        self._show_category("misc")

        items = self._categorized_sound_names.keys()
        items = list(sorted(items))
        DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(-1, -0.9),
            items=items,
            scale=constants.TEXT_SIZE,
            text_align=core.TextNode.A_left,
            command=self._show_category,
        )

        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(0.8, -0.9),
            text="Ok",
            scale=constants.TEXT_SIZE,
            command=self._confirm,
        )
        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(0.92, -0.9),
            text="Cancel",
            scale=constants.TEXT_SIZE,
            command=self._hide,
        )
Ejemplo n.º 4
0
    def __init__(
        self,
        parent: core.NodePath,
        default_tile: int,
        properties: typing.Dict[str, Property],
        sound_browser: sound_view.SoundView,
        update_tile: typing.Callable[[int], None],
        canvas_height: float,
        frame_width: float,
        frame_height: float,
        alpha=1,
    ):
        self._canvas_height = canvas_height
        self._frame_width = frame_width
        self._frame_height = frame_height

        self._frame = DirectGui.DirectScrolledFrame(
            parent=parent,
            frameSize=(0, self._frame_width, 0.05, self._frame_height + 0.05),
            frameColor=(0.65, 0.65, 0.65, alpha),
            state=DirectGuiGlobals.NORMAL,
            scrollBarWidth=0.04,
            relief=DirectGuiGlobals.SUNKEN,
        )
        self._bind_scroll(self._frame)
        self._canvas = self._frame.getCanvas()
        self._default_tile = default_tile
        self._properties = properties
        self._sound_browser = sound_browser
        self._update_tile = update_tile
        self.get_current_tile: typing.Callable[[], int] = lambda: None

        property_list: _PROPERTY_LIST_TYPE = list(self._properties.items())
        property_count = len(property_list)
        columns = math.ceil(property_count / self._property_rows)

        self._frame["canvasSize"] = (
            0,
            columns * self._padded_property_width + 0.2,
            -self._canvas_height,
            0,
        )

        self._value_setters: typing.Dict[str, typing.Any] = {}
        for column in range(columns):
            for row in range(self._property_rows):
                index = column * self._property_rows + row
                if index >= property_count:
                    break

                name, descriptor = property_list[index]

                x = column * (
                    self._padded_property_width) + self._PROPERTY_PADDING / 4
                y = -(row + 1) * self._property_height

                label = DirectGui.DirectLabel(
                    parent=self._canvas,
                    pos=core.Vec3(x, y),
                    text=name,
                    scale=constants.TEXT_SIZE,
                    text_align=core.TextNode.A_left,
                    frameColor=(0, 0, 0, 0),
                )
                self._bind_scroll(label)

                label_size = label.node().get_frame() * constants.TEXT_SIZE
                label_width = (label_size[1] -
                               label_size[0]) + self._PROPERTY_PADDING
                width_left = (self._PROPERTY_WIDTH -
                              label_width) / constants.TEXT_SIZE

                if descriptor.property_type == Property.INTEGER_PROPERTY:
                    setter = DirectGui.DirectEntry(
                        parent=self._canvas,
                        pos=core.Vec3(x + label_width, y),
                        width=width_left,
                        frameColor=(1, 1, 1, 1),
                        relief=DirectGuiGlobals.SUNKEN,
                        scale=constants.TEXT_SIZE,
                        initialText=str(descriptor.value - descriptor.offset),
                    )
                elif descriptor.property_type == Property.BOOLEAN_PROPERTY:
                    setter = DirectGui.DirectCheckButton(
                        parent=self._canvas,
                        pos=core.Vec3(x + self._PROPERTY_WIDTH,
                                      y + constants.TEXT_SIZE / 2),
                        scale=constants.TEXT_SIZE,
                        indicatorValue=descriptor.value ^ descriptor.offset,
                    )
                elif descriptor.property_type == Property.SOUND_PROPERTY:
                    setter = DirectGui.DirectButton(
                        parent=self._canvas,
                        pos=core.Vec3(x + self._PROPERTY_WIDTH,
                                      y + constants.TEXT_SIZE / 2),
                        scale=constants.TEXT_SIZE,
                        text="Browse",
                        command=self._browse_sounds,
                        text_align=core.TextNode.A_right,
                    )
                    setter.set_python_tag("sound_index", descriptor.value)
                elif descriptor.property_type == Property.ENUM_PROPERTY:
                    items = list(descriptor.enum_values.keys())
                    setter = DirectGui.DirectOptionMenu(
                        parent=self._canvas,
                        pos=core.Vec3(x + label_width, y),
                        scale=constants.TEXT_SIZE,
                        items=items,
                    )
                    setter.set(
                        descriptor.reverse_enum_values[descriptor.value])
                    setter.set_python_tag("enum_values",
                                          descriptor.enum_values)
                else:
                    raise ValueError(
                        f"Invalid property type {descriptor.property_type}")

                self._bind_scroll(setter)
                self._value_setters[name] = setter

                setter["state"] = DirectGuiGlobals.NORMAL
                setter["extraArgs"] = [setter, descriptor]
                if descriptor.tile_link_type == Property.TILE_LINK_OFFSET:
                    self._setup_tile_link_offset_setter(setter, descriptor)