Plugin ready for Bevy 0.15

.github/workflows/release.yml

@@ -0,0 +1,158 @@
+name: Deploy
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Pass the version
+        required: true
+        type: string
+      release_info:
+        description: Information about release
+        required: true
+        type: string
+      dry_run:
+        description: Perform test without releasing
+        type: choice
+        required: true
+        default: "true"
+        options:
+          - "true"
+          - "false"  
+  push:
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]+"
+
+permissions:
+  contents: write
+
+jobs:
+  setup:
+    name: Prepare job settings
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.setup.outputs.version }}
+      dry_run: ${{ steps.setup.outputs.dry_run }}
+      info: ${{ steps.setup.outputs.info }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        if: ${{ github.event_name == 'push' }}
+      - name: Get the release version from the tag and info from commit
+        id: version_push
+        shell: bash
+        if: ${{ github.event_name == 'push' }}
+        run: |
+          echo version=${GITHUB_REF#refs/tags/} >> $GITHUB_OUTPUT
+          echo info=$(git tag -l --format='%(contents)' ${GITHUB_REF#refs/tags/}) >> $GITHUB_OUTPUT
+      - name: Get the release version from the input
+        id: version_dispatch
+        shell: bash
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        run: |
+          echo 
+          echo version=$(echo ${{ inputs.version }} | xargs) >> $GITHUB_OUTPUT
+          echo dry_run=$(echo ${{ inputs.dry_run }} | xargs) >> $GITHUB_OUTPUT
+          echo info="${{ inputs.release_info }}" >> $GITHUB_OUTPUT
+      - name: Setup
+        id: setup
+        shell: bash
+        run: |
+          echo version=$(if [ -n "${{ steps.version_dispatch.outputs.version }}" ]; then echo "${{ steps.version_dispatch.outputs.version }}"; else echo "${{ steps.version_push.outputs.version }}"; fi) >> $GITHUB_OUTPUT
+          echo dry_run=$(if [ -n "${{ steps.version_dispatch.outputs.dry_run }}" ]; then echo "${{ steps.version_dispatch.outputs.dry_run }}"; else echo "false"; fi) >> $GITHUB_OUTPUT
+          echo info=$(if [ -n "${{ steps.version_dispatch.outputs.info }}" ]; then echo "${{ steps.version_dispatch.outputs.info }}"; else echo "${{ steps.version_push.outputs.info }}"; fi) >> $GITHUB_OUTPUT
+      - name: Display settings
+        shell: bash
+        run: echo "Version ${{ steps.setup.outputs.version }}, Dry run- ${{ steps.setup.outputs.dry_run }}, info- ${{ steps.setup.outputs.info }}"
+      - name: Validate input
+        shell: bash
+        run: |
+          if [ -z "${{ steps.setup.outputs.version }}" ]; then exit 1; fi;
+          if [ -z "${{ steps.setup.outputs.dry_run }}" ]; then exit 1; fi;
+          if [ -z "${{ steps.setup.outputs.info }}" ]; then exit 1; fi;
+          if [[ "${{ steps.setup.outputs.version }}" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+).*?$ ]]; then echo "Valid version"; else echo "INVALID VERSION FORMAT!";exit 1; fi;
+  build-and-upload:
+    name: Build and upload
+    needs:
+      - setup
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - build: linux
+            os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ github.ref || github.run_id }}
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --verbose --release --target ${{ matrix.target }}
+      - name: Extract changelog content
+        id: extract_changelog
+        shell: bash
+        run: |
+          version="${{ needs.setup.outputs.version }}"
+          echo "${{ needs.setup.outputs.info }}" > changelog_output.txt
+          awk "/^## \\[$version\\]/ {flag=1; next} /^## \\[/ && flag {flag=0} flag" CHANGELOG.md >> changelog_output.txt
+      - name: Display extracted content
+        run: cat changelog_output.txt
+      - name: Release
+        if: ${{ needs.setup.outputs.dry_run == 'false'}}
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: changelog_output.txt
+  deploy-to-crates-io:
+    needs:
+      - setup
+      - build-and-upload
+    name: Deploy to crates.io
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ github.ref || github.run_id }}
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: taiki-e/cache-cargo-install-action@v2
+        with:
+          tool: cargo-release
+      - name: cargo publish dry run
+        if: ${{ needs.setup.outputs.dry_run == 'true'}}
+        run: cargo publish --dry-run
+      - name: cargo login
+        run: cargo login ${{ secrets.CRATES_IO_TOKEN }}
+      - name: "cargo release publish"
+        if: ${{ needs.setup.outputs.dry_run == 'false'}}
+        run: |-
+          cargo release \
+            publish \
+            --workspace \
+            --all-features \
+            --allow-branch HEAD \
+            --no-confirm \
+            --no-verify \
+            --execute

CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+## [0.3.0]
+
+## Added
+
+- scroll to bottom and top functions for `ScrollableContent` component.
+
+## Changed
+
+- Updated to Bevy 0.15
+
+## [0.2.0]
+
+## Changed
+
+- Updated to Bevy 0.14
+
 ## [0.1.0]
 
 - Initial version

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_simple_scroll_view"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 exclude = [".github/","wasm/", "record.gif"]
 categories = ["game-development", "gui"]
@@ -11,10 +11,14 @@ license = "MIT OR Apache-2.0"
 description = "Simple to use plugin implementing ScrollView into Bevy engine."
 
 [dependencies.bevy]
-version = "0.14"
+version = "0.15.0-rc.3"
 default-features = false
 features = ["bevy_ui", "bevy_asset", "bevy_text"]
 
 [dev-dependencies.bevy]
-version = "0.14"
+version = "0.15.0-rc.3"
 default-features = true
+
+[features]
+default = []
+extra_logs = []

examples/simple.rs

@@ -1,10 +1,10 @@
 use bevy::prelude::*;
 use bevy_simple_scroll_view::*;
 
-const CLR_1: Color = Color::rgb(0.168, 0.168, 0.168);
+const CLR_1: Color = Color::srgb(0.168, 0.168, 0.168);
-const CLR_2: Color = Color::rgb(0.109, 0.109, 0.109);
+const CLR_2: Color = Color::srgb(0.109, 0.109, 0.109);
-const CLR_3: Color = Color::rgb(0.569, 0.592, 0.647);
+const CLR_3: Color = Color::srgb(0.569, 0.592, 0.647);
-const CLR_4: Color = Color::rgb(0.902, 0.4, 0.004);
+const CLR_4: Color = Color::srgb(0.902, 0.4, 0.004);
 
 fn main() {
     App::new()
@@ -15,62 +15,66 @@ fn main() {
 }
 
 fn prepare(mut commands: Commands) {
-    commands.spawn(Camera2dBundle::default());
+    commands.spawn(Camera2d::default());
     commands
-        .spawn(NodeBundle {
+        .spawn((
-            style: Style {
+            BackgroundColor(CLR_1),
+            Node {
                 width: Val::Percent(100.0),
                 height: Val::Percent(100.0),
                 padding: UiRect::all(Val::Px(15.0)),
                 ..default()
             },
-            background_color: CLR_1.into(),
+        ))
-            ..default()
-        })
         .with_children(|p| {
-            p.spawn(ButtonBundle {
+            p.spawn(Node {
-                style: Style {
+                width: Val::Percent(20.0),
-                    margin: UiRect::all(Val::Px(15.0)),
+                margin: UiRect::all(Val::Px(10.0)),
-                    padding: UiRect::all(Val::Px(15.0)),
+                flex_direction: FlexDirection::Column,
-                    max_height: Val::Px(100.0),
-                    border: UiRect::all(Val::Px(3.0)),
-                    align_items: AlignItems::Center,
-                    ..default()
-                },
-                background_color: CLR_2.into(),
-                border_color: CLR_4.into(),
                 ..default()
             })
             .with_children(|p| {
-                p.spawn(TextBundle::from_section(
+                for btn_action in [ScrollButton::MoveToTop, ScrollButton::MoveToBottom] {
-                    "Reset scroll",
+                    p.spawn((
-                    TextStyle {
+                        Node {
-                        font_size: 25.0,
+                            margin: UiRect::all(Val::Px(15.0)),
-                        color: CLR_4,
+                            padding: UiRect::all(Val::Px(15.0)),
-                        ..default()
+                            max_height: Val::Px(100.0),
-                    },
+                            border: UiRect::all(Val::Px(3.0)),
-                ));
+                            align_items: AlignItems::Center,
+                            ..default()
+                        },
+                        BackgroundColor(CLR_2),
+                        BorderColor(CLR_4),
+                        Button,
+                        btn_action.clone(),
+                    ))
+                    .with_children(|p| {
+                        p.spawn((
+                            Text::new(format!("{:#?}", btn_action)),
+                            TextFont {
+                                font_size: 25.0,
+                                ..default()
+                            },
+                            TextColor(CLR_4),
+                        ));
+                    });
+                }
             });
             p.spawn((
-                NodeBundle {
+                Node {
-                    style: Style {
+                    width: Val::Percent(80.0),
-                        width: Val::Percent(80.0),
+                    margin: UiRect::all(Val::Px(15.0)),
-                        margin: UiRect::all(Val::Px(15.0)),
-                        ..default()
-                    },
-                    background_color: CLR_2.into(),
                     ..default()
                 },
+                BackgroundColor(CLR_2),
                 ScrollView::default(),
             ))
             .with_children(|p| {
                 p.spawn((
-                    NodeBundle {
+                    Node {
-                        style: Style {
+                        flex_direction: bevy::ui::FlexDirection::Column,
-                            flex_direction: bevy::ui::FlexDirection::Column,
+                        width: Val::Percent(100.0),
-                            width: Val::Percent(100.0),
-                            ..default()
-                        },
                         ..default()
                     },
                     ScrollableContent::default(),
@@ -78,29 +82,26 @@ fn prepare(mut commands: Commands) {
                 .with_children(|scroll_area| {
                     for i in 0..21 {
                         scroll_area
-                            .spawn(NodeBundle {
+                            .spawn((
-                                style: Style {
+                                Node {
                                     min_width: Val::Px(200.0),
                                     margin: UiRect::all(Val::Px(15.0)),
                                     border: UiRect::all(Val::Px(5.0)),
                                     padding: UiRect::all(Val::Px(30.0)),
                                     ..default()
                                 },
-                                border_color: CLR_3.into(),
+                                BorderColor(CLR_3),
-                                ..default()
+                            ))
-                            })
                             .with_children(|p| {
-                                p.spawn(
+                                p.spawn((
-                                    TextBundle::from_section(
+                                    Text::new(format!("Nr {}", i)),
-                                        format!("Nr {}", i),
+                                    TextFont {
-                                        TextStyle {
+                                        font_size: 25.0,
-                                            font_size: 25.0,
+                                        ..default()
-                                            color: CLR_3,
+                                    },
-                                            ..default()
+                                    TextColor(CLR_3),
-                                        },
+                                    TextLayout::new_with_justify(JustifyText::Center),
-                                    )
+                                ));
-                                    .with_text_justify(JustifyText::Center),
-                                );
                             });
                     }
                 });
@@ -108,15 +109,26 @@ fn prepare(mut commands: Commands) {
         });
 }
 
+#[derive(Component, PartialEq, Debug, Clone, Copy)]
+enum ScrollButton {
+    MoveToTop,
+    MoveToBottom,
+}
+
 fn reset_scroll(
-    q: Query<(&Button, &Interaction), Changed<Interaction>>,
+    q: Query<(&Interaction, &ScrollButton), (Changed<Interaction>, With<Button>)>,
     mut scrolls_q: Query<&mut ScrollableContent>,
 ) {
-    for (_, interaction) in q.iter() {
+    let Ok(mut scroll) = scrolls_q.get_single_mut() else {
-        if interaction == &Interaction::Pressed {
+        return;
-            for mut scroll in scrolls_q.iter_mut() {
+    };
-                scroll.pos_y = 0.0;
+    for (interaction, action) in q.iter() {
-            }
+        if interaction != &Interaction::Pressed {
+            continue;
+        }
+        match action {
+            ScrollButton::MoveToTop => scroll.scroll_to_top(),
+            ScrollButton::MoveToBottom => scroll.scroll_to_bottom(),
         }
     }
 }

src/lib.rs

@@ -26,6 +26,7 @@ impl Plugin for ScrollViewPlugin {
                 Update,
                 (
                     create_scroll_view,
+                    update_size,
                     input_mouse_pressed_move,
                     input_touch_pressed_move,
                     scroll_events,
@@ -38,6 +39,7 @@ impl Plugin for ScrollViewPlugin {
 
 /// Root component of scroll, it should have clipped style.
 #[derive(Component, Debug, Reflect)]
+#[require(Interaction)]
 pub struct ScrollView {
     /// Field which control speed of the scrolling.
     /// Could be negative number to implement invert scroll
@@ -47,7 +49,7 @@ pub struct ScrollView {
 impl Default for ScrollView {
     fn default() -> Self {
         Self {
-            scroll_speed: 200.0,
+            scroll_speed: 1200.0,
         }
     }
 }
@@ -58,68 +60,91 @@ impl Default for ScrollView {
 pub struct ScrollableContent {
     /// Scroll container offset to the `ScrollView`.
     pub pos_y: f32,
+    pub max_scroll: f32,
 }
 
-pub fn create_scroll_view(
+impl ScrollableContent {
-    mut commands: Commands,
+    pub fn scroll_to_top(&mut self) {
-    mut q: Query<(Entity, &mut Style), Added<ScrollView>>,
+        self.pos_y = 0.0;
-) {
+    }
-    for (e, mut style) in q.iter_mut() {
+    pub fn scroll_to_bottom(&mut self) {
+        self.pos_y = -self.max_scroll;
+    }
+    pub fn scroll_by(&mut self, value: f32) {
+        self.pos_y += value;
+        self.pos_y = self.pos_y.clamp(-self.max_scroll, 0.);
+    }
+}
+
+pub fn create_scroll_view(mut q: Query<&mut Node, Added<ScrollView>>) {
+    for mut style in q.iter_mut() {
         style.overflow = Overflow::clip();
         style.align_items = AlignItems::Start;
         style.align_self = AlignSelf::Stretch;
         style.flex_direction = FlexDirection::Row;
-        commands.entity(e).insert(Interaction::None);
     }
 }
 
 fn input_mouse_pressed_move(
     mut motion_evr: EventReader<MouseMotion>,
-    mut q: Query<(&Children, &Interaction, &Node), With<ScrollView>>,
+    mut q: Query<(&Children, &Interaction), With<ScrollView>>,
-    mut content_q: Query<(&mut ScrollableContent, &Node)>,
+    mut content_q: Query<&mut ScrollableContent>,
 ) {
     for evt in motion_evr.read() {
-        for (children, &interaction, node) in q.iter_mut() {
+        for (children, &interaction) in q.iter_mut() {
             if interaction != Interaction::Pressed {
                 continue;
             }
-            let container_height = node.size().y;
             for &child in children.iter() {
-                if let Ok(item) = content_q.get_mut(child) {
+                let Ok(mut scroll) = content_q.get_mut(child) else {
-                    let mut scroll = item.0;
+                    continue;
-                    let max_scroll = (item.1.size().y - container_height).max(0.0);
+                };
-                    info!("CONTAINER {}, max_scroll: {}",container_height,max_scroll);
+                scroll.scroll_by(evt.delta.y);
-                    scroll.pos_y += evt.delta.y;
-                    scroll.pos_y = scroll.pos_y.clamp(-max_scroll, 0.);
-                }
             }
         }
     }
 }
 
+fn update_size(
+    mut q: Query<(&Children, &ComputedNode), With<ScrollView>>,
+    mut content_q: Query<(&mut ScrollableContent, &ComputedNode), Changed<ComputedNode>>,
+) {
+    for (children, node) in q.iter_mut() {
+        let container_height = node.size().y;
+        for &child in children.iter() {
+            let Ok((mut scroll, node)) = content_q.get_mut(child) else {
+                continue;
+            };
+
+            scroll.max_scroll = (node.size().y - container_height).max(0.0);
+            #[cfg(feature = "extra_logs")]
+            info!(
+                "CONTAINER {}, max_scroll: {}",
+                container_height, scroll.max_scroll
+            );
+        }
+    }
+}
+
 fn input_touch_pressed_move(
     touches: Res<Touches>,
-    mut q: Query<(&Children, &Interaction, &Node), With<ScrollView>>,
+    mut q: Query<(&Children, &Interaction), With<ScrollView>>,
-    mut content_q: Query<(&mut ScrollableContent, &Node)>,
+    mut content_q: Query<&mut ScrollableContent>,
 ) {
     for t in touches.iter() {
         let Some(touch) = touches.get_pressed(t.id()) else {
             continue;
         };
 
-        for (children, &interaction, node) in q.iter_mut() {
+        for (children, &interaction) in q.iter_mut() {
             if interaction != Interaction::Pressed {
                 continue;
             }
-            let container_height = node.size().y;
             for &child in children.iter() {
-                if let Ok(item) = content_q.get_mut(child) {
+                let Ok(mut scroll) = content_q.get_mut(child) else {
-                    let mut scroll = item.0;
+                    continue;
-                    let max_scroll = (item.1.size().y - container_height).max(0.0);
+                };
-                    info!("CONTAINER {}, max_scroll: {}",container_height,max_scroll);
+                scroll.scroll_by(touch.delta().y);
-                    scroll.pos_y += touch.delta().y;
-                    scroll.pos_y = scroll.pos_y.clamp(-max_scroll, 0.);
-                }
             }
         }
     }
@@ -127,38 +152,36 @@ fn input_touch_pressed_move(
 
 fn scroll_events(
     mut scroll_evr: EventReader<MouseWheel>,
-    mut q: Query<(&Children, &Interaction, &ScrollView, &Node), With<ScrollView>>,
+    mut q: Query<(&Children, &Interaction, &ScrollView), With<ScrollView>>,
     time: Res<Time>,
-    mut content_q: Query<(&mut ScrollableContent, &Node)>,
+    mut content_q: Query<&mut ScrollableContent>,
 ) {
     use bevy::input::mouse::MouseScrollUnit;
     for ev in scroll_evr.read() {
-        for (children, &interaction, scroll_view, node) in q.iter_mut() {
+        for (children, &interaction, scroll_view) in q.iter_mut() {
+            if interaction != Interaction::Hovered {
+                continue;
+            }
             let y = match ev.unit {
                 MouseScrollUnit::Line => {
                     ev.y * time.delta().as_secs_f32() * scroll_view.scroll_speed
                 }
                 MouseScrollUnit::Pixel => ev.y,
             };
-            if interaction != Interaction::Hovered {
+            #[cfg(feature = "extra_logs")]
-                continue;
+            info!("Scroolling by {:#?}: {} movement", ev.unit, y);
-            }
-            let container_height = node.size().y;
 
             for &child in children.iter() {
-                if let Ok(item) = content_q.get_mut(child) {
+                let Ok(mut scroll) = content_q.get_mut(child) else {
-                    let y = y * time.delta().as_secs_f32() * scroll_view.scroll_speed;
+                    continue;
-                    let mut scroll = item.0;
+                };
-                    let max_scroll = (item.1.size().y - container_height).max(0.0);
+                scroll.scroll_by(y);
-                    scroll.pos_y += y;
-                    scroll.pos_y = scroll.pos_y.clamp(-max_scroll, 0.);
-                }
             }
         }
     }
 }
 
-fn scroll_update(mut q: Query<(&ScrollableContent, &mut Style), Changed<ScrollableContent>>) {
+fn scroll_update(mut q: Query<(&ScrollableContent, &mut Node), Changed<ScrollableContent>>) {
     for (scroll, mut style) in q.iter_mut() {
         style.top = Val::Px(scroll.pos_y);
     }