feat: implement some features

Author: LeadcodeDev

Cargo.lock

@@ -34,7 +34,7 @@ ratatui = "0.29"
 crossterm = "0.28"
 
 # Image encoding (for single-frame PNG export)
-image = { version = "0.25", default-features = false, features = ["png"] }
+image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp"] }
 
 # Parallelism
 rayon = "1"
@@ -68,3 +68,6 @@ notify = "7"
 
 # HTTP client (blocking, for Iconify API)
 ureq = "3"
+
+# QR code generation
+qrcode = "0.14"

Cargo.toml

@@ -68,6 +68,7 @@ impl Widget for Counter {
         let weight = match font_weight {
             FontWeight::Bold => skia_safe::font_style::Weight::BOLD,
             FontWeight::Normal => skia_safe::font_style::Weight::NORMAL,
+            FontWeight::Weight(w) => skia_safe::font_style::Weight::from(w as i32),
         };
         let skia_font_style = FontStyle::new(weight, skia_safe::font_style::Width::NORMAL, slant);
 
@@ -144,6 +145,7 @@ impl Widget for Counter {
         let skia_font_style = match font_weight {
             FontWeight::Bold => FontStyle::bold(),
             FontWeight::Normal => FontStyle::normal(),
+            FontWeight::Weight(w) => FontStyle::new(skia_safe::font_style::Weight::from(w as i32), skia_safe::font_style::Width::NORMAL, skia_safe::font_style::Slant::Upright),
         };
         let typeface = fm
             .match_family_style(font_family, skia_font_style)

src/components/counter.rs

@@ -184,11 +184,11 @@ impl Widget for Flex {
 pub(crate) fn resolve_size_constraints(size: &Option<FlexSize>, constraints: &Constraints) -> Constraints {
     let w = size.as_ref().and_then(|s| match &s.width {
         SizeDimension::Fixed(v) => Some(*v),
-        SizeDimension::Auto(_) => None,
+        SizeDimension::Percent(_) | SizeDimension::Auto => None,
     });
     let h = size.as_ref().and_then(|s| match &s.height {
         SizeDimension::Fixed(v) => Some(*v),
-        SizeDimension::Auto(_) => None,
+        SizeDimension::Percent(_) | SizeDimension::Auto => None,
     });
     Constraints {
         min_width: w.unwrap_or(constraints.min_width),

src/components/flex.rs

@@ -7,6 +7,8 @@ pub mod gif;
 pub mod grid;
 pub mod icon;
 pub mod image;
+pub mod progress;
+pub mod qrcode;
 pub mod shape;
 pub mod stack;
 pub mod svg;

src/components/mod.rs

@@ -0,0 +1,41 @@
+use anyhow::Result;
+use skia_safe::{Canvas, PaintStyle, Rect, RRect};
+
+use crate::engine::renderer::{color4f_from_hex, paint_from_hex};
+use crate::schema::ProgressBarLayer;
+
+pub fn render_progress_bar(canvas: &Canvas, layer: &ProgressBarLayer) -> Result<()> {
+    let x = layer.position.x;
+    let y = layer.position.y;
+    let w = layer.width;
+    let h = layer.height;
+    let radius = layer.border_radius;
+    let progress = layer.progress.clamp(0.0, 1.0) as f32;
+
+    // Background
+    let mut bg_paint = skia_safe::Paint::new(color4f_from_hex(&layer.background_color), None);
+    bg_paint.set_style(PaintStyle::Fill);
+    bg_paint.set_anti_alias(true);
+
+    let bg_rect = Rect::from_xywh(x, y, w, h);
+    let bg_rrect = RRect::new_rect_xy(bg_rect, radius, radius);
+    canvas.draw_rrect(bg_rrect, &bg_paint);
+
+    // Fill (progress)
+    if progress > 0.001 {
+        let mut fill_paint = paint_from_hex(&layer.fill_color);
+        fill_paint.set_style(PaintStyle::Fill);
+        fill_paint.set_anti_alias(true);
+
+        let fill_w = w * progress;
+        let fill_rect = Rect::from_xywh(x, y, fill_w, h);
+
+        // Clip to the rounded background shape to prevent fill from exceeding bounds
+        canvas.save();
+        canvas.clip_rrect(bg_rrect, skia_safe::ClipOp::Intersect, true);
+        canvas.draw_rect(fill_rect, &fill_paint);
+        canvas.restore();
+    }
+
+    Ok(())
+}

src/components/progress.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use skia_safe::{Canvas, PaintStyle, Rect};
+
+use crate::engine::renderer::color4f_from_hex;
+use crate::schema::QrCodeLayer;
+
+pub fn render_qr_code(canvas: &Canvas, layer: &QrCodeLayer) -> Result<()> {
+    use qrcode::QrCode;
+
+    let code = QrCode::new(layer.content.as_bytes())
+        .map_err(|e| anyhow::anyhow!("QR code generation failed: {}", e))?;
+
+    let modules = code.to_colors();
+    let module_count = code.width() as f32;
+    let module_size = layer.size / module_count;
+
+    let x = layer.position.x;
+    let y = layer.position.y;
+
+    // Background
+    let mut bg_paint = skia_safe::Paint::new(color4f_from_hex(&layer.background_color), None);
+    bg_paint.set_style(PaintStyle::Fill);
+    canvas.draw_rect(Rect::from_xywh(x, y, layer.size, layer.size), &bg_paint);
+
+    // Foreground modules
+    let mut fg_paint = skia_safe::Paint::new(color4f_from_hex(&layer.foreground_color), None);
+    fg_paint.set_style(PaintStyle::Fill);
+    fg_paint.set_anti_alias(false); // Sharp edges for QR
+
+    for (idx, &color) in modules.iter().enumerate() {
+        if color == qrcode::Color::Dark {
+            let col = (idx % code.width()) as f32;
+            let row = (idx / code.width()) as f32;
+            let rect = Rect::from_xywh(
+                x + col * module_size,
+                y + row * module_size,
+                module_size,
+                module_size,
+            );
+            canvas.draw_rect(rect, &fg_paint);
+        }
+    }
+
+    Ok(())
+}

src/components/qrcode.rs

@@ -135,6 +135,7 @@ fn render_shape_text(
     let font_style = match text.font_weight {
         FontWeight::Bold => skia_safe::FontStyle::bold(),
         FontWeight::Normal => skia_safe::FontStyle::normal(),
+        FontWeight::Weight(w) => skia_safe::FontStyle::new(skia_safe::font_style::Weight::from(w as i32), skia_safe::font_style::Width::NORMAL, skia_safe::font_style::Slant::Upright),
     };
 
     let typeface = fm

src/components/shape.rs

@@ -48,6 +48,7 @@ impl Widget for Text {
         let weight = match font_weight {
             FontWeight::Bold => skia_safe::font_style::Weight::BOLD,
             FontWeight::Normal => skia_safe::font_style::Weight::NORMAL,
+            FontWeight::Weight(w) => skia_safe::font_style::Weight::from(w as i32),
         };
         let skia_font_style = FontStyle::new(weight, skia_safe::font_style::Width::NORMAL, slant);
 
@@ -194,6 +195,7 @@ impl Widget for Text {
         let weight = match font_weight {
             FontWeight::Bold => skia_safe::font_style::Weight::BOLD,
             FontWeight::Normal => skia_safe::font_style::Weight::NORMAL,
+            FontWeight::Weight(w) => skia_safe::font_style::Weight::from(w as i32),
         };
         let skia_font_style = FontStyle::new(weight, skia_safe::font_style::Width::NORMAL, slant);
         let typeface = fm

src/components/text.rs

@@ -9,7 +9,7 @@ use symphonia::core::probe::Hint;
 
 use crate::schema::AudioTrack;
 
-const TARGET_SAMPLE_RATE: u32 = 44100;
+const TARGET_SAMPLE_RATE: u32 = 48000;
 const TARGET_CHANNELS: u32 = 2;
 
 /// Decode an audio file into PCM i16 samples (stereo, 44100Hz, interleaved)
@@ -122,10 +122,16 @@ pub fn mix_audio_tracks(tracks: &[AudioTrack], total_duration: f64) -> Result<Op
                 break;
             }
 
-            let mut sample = resampled[i] * track.volume;
+            let frame = i / TARGET_CHANNELS as usize;
+            let current_time = track.start + (frame as f64 / TARGET_SAMPLE_RATE as f64);
+            let vol = if !track.volume_keyframes.is_empty() {
+                interpolate_volume_keyframes(&track.volume_keyframes, current_time)
+            } else {
+                track.volume
+            };
+            let mut sample = resampled[i] * vol;
 
             // Apply fade in
-            let frame = i / TARGET_CHANNELS as usize;
             if fade_in_samples > 0.0 && (frame as f64) < fade_in_samples {
                 sample *= frame as f32 / fade_in_samples as f32;
             }
@@ -152,6 +158,33 @@ pub fn mix_audio_tracks(tracks: &[AudioTrack], total_duration: f64) -> Result<Op
     Ok(Some(pcm_bytes))
 }
 
+/// Interpolate volume at a given time using volume keyframes with easing
+fn interpolate_volume_keyframes(keyframes: &[crate::schema::VolumeKeyframe], time: f64) -> f32 {
+    if keyframes.is_empty() {
+        return 1.0;
+    }
+    if time <= keyframes[0].time {
+        return keyframes[0].volume;
+    }
+    if time >= keyframes.last().unwrap().time {
+        return keyframes.last().unwrap().volume;
+    }
+    for i in 0..keyframes.len() - 1 {
+        let kf0 = &keyframes[i];
+        let kf1 = &keyframes[i + 1];
+        if time >= kf0.time && time <= kf1.time {
+            let duration = kf1.time - kf0.time;
+            if duration < 1e-9 {
+                return kf1.volume;
+            }
+            let t = (time - kf0.time) / duration;
+            let progress = crate::engine::animator::ease(t, &kf0.easing);
+            return kf0.volume + (kf1.volume - kf0.volume) * progress as f32;
+        }
+    }
+    keyframes.last().unwrap().volume
+}
+
 fn to_stereo(samples: &[f32], channels: u32) -> Vec<f32> {
     match channels {
         1 => {