Basic Drawable framework + cropping

Cargo.toml

@@ -30,3 +30,4 @@ gtk4-layer-shell = "0.2.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 xdg = "2.5"
+gdk4-x11 = "0.8.0"

README.md

@@ -24,7 +24,7 @@ were often only either for X11 *or* Wayland. `flakeshot` should close this gap b
 tool which should run on X11 as good as on Wayland.
 
 # Status
-`flakeshot` is still under heavy development and not considered useable.
+`flakeshot` already has basic screenshot capabilities including cropping. More features are currently being developed.
 
 <!-----------------------{ Links }---------------------------->
 

src/backend/x11.rs

@@ -56,7 +56,6 @@ pub fn create_screenshots() -> Result<Vec<(OutputInfo, image::DynamicImage)>, Er
     let mut images = Vec::with_capacity(setup.roots.len());
 
     for screen in &setup.roots {
-        let image = get_image(&conn, screen)?;
         let monitors = conn.randr_get_monitors(screen.root, true)?.reply()?;
 
         for monitor in &monitors.monitors {
@@ -65,6 +64,14 @@ pub fn create_screenshots() -> Result<Vec<(OutputInfo, image::DynamicImage)>, Er
                 "We currently support only one output for each monitor. Please create an issue if you encounter this assert."
             );
 
+            let image = get_image(
+                &conn,
+                screen,
+                monitor.x,
+                monitor.y,
+                monitor.width,
+                monitor.height,
+            )?;
             let monitor_info = {
                 let screen_resources = conn
                     .randr_get_screen_resources_current(screen.root)?
@@ -102,26 +109,30 @@ pub fn create_screenshots() -> Result<Vec<(OutputInfo, image::DynamicImage)>, Er
     Ok(images)
 }
 
-fn get_image(conn: &RustConnection, screen: &Screen) -> Result<DynamicImage, Error> {
+fn get_image(
+    conn: &RustConnection,
+    screen: &Screen,
+    x: i16,
+    y: i16,
+    width: u16,
+    height: u16,
+) -> Result<DynamicImage, Error> {
     use x11rb::protocol::xproto::ConnectionExt;
     const ALL_BITS: u32 = u32::MAX;
 
     let setup = &conn.setup();
-    let width_u16 = screen.width_in_pixels;
-    let height_u16 = screen.height_in_pixels;
-
-    let width_u32 = u32::from(width_u16);
-    let height_u32 = u32::from(height_u16);
+    let width_u32 = u32::from(width);
+    let height_u32 = u32::from(height);
 
     let (image_bytes, pixmap_format) = {
         let image_reply = conn
             .get_image(
                 ImageFormat::Z_PIXMAP,
                 screen.root,
-                0,
-                0,
-                width_u16,
-                height_u16,
+                x,
+                y,
+                width,
+                height,
                 ALL_BITS,
             )
             .map_err(Error::from)?

src/frontend/mod.rs

@@ -1,5 +1,3 @@
-pub mod file_chooser;
-pub mod main_window;
-pub mod screenshot_window;
+pub mod shape;
 pub mod ui;
-pub mod ui_manager;
+pub mod window;

src/frontend/shape/mod.rs

@@ -0,0 +1,2 @@
+pub mod point;
+pub mod rectangle;

src/frontend/shape/point.rs

@@ -0,0 +1,12 @@
+#[derive(Debug, Copy, Clone, Default)]
+pub struct Point {
+    pub x: f64,
+    pub y: f64,
+}
+
+impl Point {
+    pub fn add(&mut self, point: Point) {
+        self.x += point.x;
+        self.y += point.y;
+    }
+}

src/frontend/shape/rectangle.rs

@@ -0,0 +1,37 @@
+use super::point::Point;
+
+#[derive(Copy, Clone, Default)]
+pub struct Rectangle {
+    pub fst: Point,
+    pub snd: Point,
+}
+
+impl Rectangle {
+    pub fn with_size(width: f64, height: f64) -> Self {
+        Self {
+            fst: Point { x: 0.0, y: 0.0 },
+            snd: Point {
+                x: width,
+                y: height,
+            },
+        }
+    }
+
+    pub fn get_points_clockwise(&self) -> (Point, Point) {
+        let x_left = f64::min(self.fst.x, self.snd.x);
+        let x_right = f64::max(self.fst.x, self.snd.x);
+        let y_top = f64::min(self.fst.y, self.snd.y);
+        let y_bottom = f64::max(self.fst.y, self.snd.y);
+
+        (
+            Point {
+                x: x_left,
+                y: y_top,
+            },
+            Point {
+                x: x_right,
+                y: y_bottom,
+            },
+        )
+    }
+}

src/frontend/ui/canvas.rs

@@ -1,21 +1,30 @@
-use gtk4::cairo::{Context, Format, ImageSurface};
+use gtk4::cairo::{Context, Filter, Format, ImageSurface};
 use image::{DynamicImage, RgbaImage};
 
-use super::drawable::Drawable;
+pub trait CanvasDrawable {
+    fn draw(&self, ctx: &Context, surface: &ImageSurface);
+}
 
 pub struct Canvas {
     surface: ImageSurface,
-    drawables: Vec<Box<dyn Drawable>>,
+    original: ImageSurface,
 }
 
 impl Canvas {
     pub fn new(width: i32, height: i32) -> anyhow::Result<Self> {
         Ok(Canvas {
             surface: ImageSurface::create(Format::ARgb32, width, height)?,
-            drawables: vec![],
+            original: ImageSurface::create(Format::ARgb32, width, height)?,
         })
     }
 
+    pub fn from_original(&self) -> Self {
+        Canvas {
+            surface: self.original.clone(),
+            original: self.original.clone(),
+        }
+    }
+
     pub fn width(&self) -> i32 {
         self.surface.width()
     }
@@ -24,21 +33,35 @@ impl Canvas {
         self.surface.height()
     }
 
-    pub fn add_drawable(&mut self, drawable: Box<dyn Drawable>) {
-        self.drawables.push(drawable);
-    }
-
-    pub fn render(&self) -> anyhow::Result<()> {
+    pub fn clear(&mut self) -> anyhow::Result<()> {
         let ctx = Context::new(&self.surface)?;
+        ctx.set_source_surface(&self.original, 0.0, 0.0)?;
+        ctx.paint()?;
 
-        for drawable in &self.drawables {
-            drawable.draw(&ctx);
-        }
+        Ok(())
+    }
+
+    pub fn save(&mut self) -> anyhow::Result<()> {
+        let original_ctx = Context::new(&self.original)?;
+        original_ctx.set_source_surface(&self.surface, 0.0, 0.0)?;
+        original_ctx.paint()?;
 
         Ok(())
     }
 
-    pub fn stamp_image(&self, x: f64, y: f64, image: &DynamicImage) -> anyhow::Result<()> {
+    pub fn render_drawable(&mut self, drawable: &dyn CanvasDrawable) {
+        let ctx = Context::new(&self.surface).unwrap();
+        drawable.draw(&ctx, &self.surface);
+    }
+
+    pub fn stamp_image(
+        &self,
+        x: f64,
+        y: f64,
+        width: f64,
+        height: f64,
+        image: &DynamicImage,
+    ) -> anyhow::Result<()> {
         let ctx = Context::new(&self.surface)?;
 
         let mut image_bytes = Vec::from(image.as_bytes());
@@ -47,6 +70,7 @@ impl Canvas {
         for i in (0..image_bytes.len()).step_by(4) {
             image_bytes[i..i + 3].reverse();
         }
+
         let image_surface = ImageSurface::create_for_data(
             image_bytes,
             Format::ARgb32,
@@ -55,7 +79,9 @@ impl Canvas {
             Format::stride_for_width(Format::ARgb32, image.width())?,
         )?;
 
+        ctx.scale(width / image.width() as f64, height / image.height() as f64);
         ctx.set_source_surface(&image_surface, x, y)?;
+        ctx.source().set_filter(Filter::Best);
         ctx.paint()?;
 
         Ok(())

src/frontend/ui/drawable/mod.rs

@@ -1,5 +1,7 @@
-use gtk4::cairo::Context;
+use gtk4::cairo::{Context, ImageSurface};
 
 pub trait Drawable {
-    fn draw(&self, ctx: &Context);
+    fn draw_active(&self, ctx: &Context, surface: &ImageSurface);
+    fn draw_inactive(&self, ctx: &Context, surface: &ImageSurface);
+    fn draw_final(&self, ctx: &Context, surface: &ImageSurface);
 }

src/frontend/ui/mod.rs

@@ -1,3 +1,6 @@
 pub mod canvas;
 pub mod drawable;
+pub mod tool;
+pub mod tool_manager;
 pub mod toolbar;
+pub mod ui_manager;