eyes are a go

Cargo.toml

···
 [package]
-name = "cosmic-applet-template"
+name = "eyez"
 version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0"

i18n/en/cosmic_applet_template.ftl

···
-example-row = Example row
+example-row = Examplez row

justfile

···
-name := 'cosmic-applet-template'
-export APPID := 'com.example.CosmicAppletTemplate'
+name := 'eyez'
+export APPID := 'com.example.eyez'
 
 rootdir := ''
 prefix := '/usr'

mise.toml

···
+[tools]
+node = "latest"
+rust = "latest"

res/com.example.CosmicAppletTemplate.desktop res/com.example.eyez.desktop

···
 [Desktop Entry]
-Name=COSMIC Applet Template
-Exec=cosmic-applet-template %F
+Name=eyez applet
+Exec=eyez %F
 Terminal=false
 Type=Application
 StartupNotify=true
-Icon=com.example.CosmicAppletTemplate
+Icon=com.example.eyez
 Categories=COSMIC;Utility;
 Keywords=Folder;Manager;
 MimeType=inode/directory;

res/com.example.CosmicAppletTemplate.metainfo.xml res/com.example.eyez.metainfo.xml

···
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop-application">
-  <id>com.example.CosmicAppletTemplate</id>
+  <id>com.example.eyez</id>
   <metadata_license>CC0-1.0</metadata_license>
   <project_license>GPL-3.0-only</project_license>
   <project_group>COSMIC</project_group>
···
   <description>
     <p>A template for COSMIC applications</p>
   </description>
-  <launchable type="desktop-id">com.example.CosmicAppletTemplate.desktop</launchable>
-  <icon type="remote" height="256" width="256">https://raw.githubusercontent.com/edfloreshz/cosmic-applet-template/master/res/icons/hicolor/256x256/apps/com.example.CosmicAppletTemplate.svg</icon>
+  <launchable type="desktop-id">com.example.eyez.desktop</launchable>
+  <icon type="remote" height="256" width="256">https://raw.githubusercontent.com/edfloreshz/cosmic-applet-template/master/res/icons/hicolor/256x256/apps/com.example.eyez.svg</icon>
   <screenshots>
   </screenshots>
   <provides>

src/app.rs

···
 // SPDX-License-Identifier: GPL-3.0-only
 
-use cosmic::app::{Core, Task};
-use cosmic::iced::window::Id;
-use cosmic::iced::Limits;
-use cosmic::iced_winit::commands::popup::{destroy_popup, get_popup};
-use cosmic::widget::{self, settings};
-use cosmic::{Application, Element};
+use cosmic::{
+    app::{Core, Task},
+    iced::{
+        self,
+        widget::row,
+        Length, Color, Point, Subscription,
+        mouse, Border,
+    },
+    Element,
+};
 
-use crate::fl;
+use cosmic::Application;
 
 /// This is the struct that represents your application.
 /// It is used to define the data that will be used by your application.
-#[derive(Default)]
-pub struct YourApp {
+pub struct Eyez {
     /// Application state which is managed by the COSMIC runtime.
     core: Core,
-    /// The popup id.
-    popup: Option<Id>,
-    /// Example row toggler.
-    example_row: bool,
+    /// The cursor position.
+    cursor: Point,
 }
 
 /// This is the enum that contains all the possible variants that your application will need to transmit messages.
···
 /// If your application does not need to send messages, you can use an empty enum or `()`.
 #[derive(Debug, Clone)]
 pub enum Message {
-    TogglePopup,
-    PopupClosed(Id),
-    ToggleExampleRow(bool),
+    Event(iced::Event),
 }
+
 
 /// Implement the `Application` trait for your application.
 /// This is where you define the behavior of your application.
···
 /// - `Flags` is the data that your application needs to use before it starts.
 /// - `Message` is the enum that contains all the possible variants that your application will need to transmit messages.
 /// - `APP_ID` is the unique identifier of your application.
-impl Application for YourApp {
+impl Application for Eyez {
     type Executor = cosmic::executor::Default;
 
     type Flags = ();
 
     type Message = Message;
 
-    const APP_ID: &'static str = "com.example.CosmicAppletTemplate";
+    const APP_ID: &'static str = "com.example.CosmicEyez";
 
     fn core(&self) -> &Core {
         &self.core
···
     /// - `flags` is used to pass in any data that your application needs to use before it starts.
     /// - `Command` type is used to send messages to your application. `Command::none()` can be used to send no messages to your application.
     fn init(core: Core, _flags: Self::Flags) -> (Self, Task<Self::Message>) {
-        let app = YourApp {
+        let app = Eyez {
             core,
-            ..Default::default()
+            cursor: Point::default(),
         };
 
         (app, Task::none())
     }
 
-    fn on_close_requested(&self, id: Id) -> Option<Message> {
-        Some(Message::PopupClosed(id))
-    }
-
-    /// This is the main view of your application, it is the root of your widget tree.
-    ///
-    /// The `Element` type is used to represent the visual elements of your application,
-    /// it has a `Message` associated with it, which dictates what type of message it can send.
-    ///
-    /// To get a better sense of which widgets are available, check out the `widget` module.
     fn view(&self) -> Element<Self::Message> {
-        self.core
-            .applet
-            .icon_button("display-symbolic")
-            .on_press(Message::TogglePopup)
-            .into()
-    }
-
-    fn view_window(&self, _id: Id) -> Element<Self::Message> {
-        let content_list = widget::list_column()
-            .padding(5)
-            .spacing(0)
-            .add(settings::item(
-                fl!("example-row"),
-                widget::toggler(self.example_row).on_toggle(Message::ToggleExampleRow),
-            ));
-
-        self.core.applet.popup_container(content_list).into()
+        // Auto-size based on panel - scale down for panel display
+        let panel_scale = 0.6; // Reduce size by 40% for better panel fit
+        let eye_size = 50.0 * panel_scale;
+        let pupil_size = 20.0 * panel_scale;
+        
+        let draw_eye = move |eye_center: Point| {
+            // Calculate pupil position based on cursor
+            let dx = self.cursor.x - eye_center.x;
+            let dy = self.cursor.y - eye_center.y;
+            let distance = (dx * dx + dy * dy).sqrt();
+            let max_distance = (eye_size - pupil_size) / 2.0;
+            
+            let (offset_x, offset_y) = if distance <= max_distance {
+                (dx, dy)
+            } else {
+                let scale = max_distance / distance;
+                (dx * scale, dy * scale)
+            };
+            
+            // Create pupil with offset based on cursor position
+            let pupil = cosmic::widget::container(cosmic::widget::text(""))
+                .width(Length::Fixed(pupil_size))
+                .height(Length::Fixed(pupil_size))
+                .style(move |_theme: &cosmic::Theme| {
+                    cosmic::widget::container::Style {
+                        background: Some(Color::BLACK.into()),
+                        border: Border {
+                            radius: (pupil_size / 2.0).into(),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    }
+                });
+            
+            // Eye container with white background and black border
+            cosmic::widget::container(pupil)
+                .width(Length::Fixed(eye_size))
+                .height(Length::Fixed(eye_size))
+                .padding([
+                    (eye_size - pupil_size) / 2.0 + offset_y,
+                    (eye_size - pupil_size) / 2.0 - offset_x,
+                    (eye_size - pupil_size) / 2.0 - offset_y,
+                    (eye_size - pupil_size) / 2.0 + offset_x,
+                ])
+                .style(move |_theme: &cosmic::Theme| {
+                    cosmic::widget::container::Style {
+                        background: Some(Color::WHITE.into()),
+                        border: Border {
+                            radius: (eye_size / 2.0).into(),
+                            width: 2.0,
+                            color: Color::BLACK,
+                        },
+                        ..Default::default()
+                    }
+                })
+        };
+        
+        let eyes = row![
+            draw_eye(Point::new(eye_size / 2.0, eye_size / 2.0)),
+            draw_eye(Point::new(eye_size * 1.5 + 5.0, eye_size / 2.0)),
+        ]
+        .spacing((5.0 * panel_scale) as u16);
+        
+        self.core.applet.popup_container(eyes).into()
     }
 
     /// Application messages are handled here. The application state can be modified based on
···
     /// background thread managed by the application's executor.
     fn update(&mut self, message: Self::Message) -> Task<Self::Message> {
         match message {
-            Message::TogglePopup => {
-                return if let Some(p) = self.popup.take() {
-                    destroy_popup(p)
-                } else {
-                    let new_id = Id::unique();
-                    self.popup.replace(new_id);
-                    let mut popup_settings = self.core.applet.get_popup_settings(
-                        self.core.main_window_id().unwrap(),
-                        new_id,
-                        None,
-                        None,
-                        None,
-                    );
-                    popup_settings.positioner.size_limits = Limits::NONE
-                        .max_width(372.0)
-                        .min_width(300.0)
-                        .min_height(200.0)
-                        .max_height(1080.0);
-                    get_popup(popup_settings)
+            Message::Event(event) => {
+                if let iced::Event::Mouse(mouse::Event::CursorMoved { position }) = event {
+                    self.cursor = position;
                 }
             }
-            Message::PopupClosed(id) => {
-                if self.popup.as_ref() == Some(&id) {
-                    self.popup = None;
-                }
-            }
-            Message::ToggleExampleRow(toggled) => self.example_row = toggled,
         }
         Task::none()
     }
 
+    fn subscription(&self) -> Subscription<Self::Message> {
+        iced::event::listen().map(Message::Event)
+    }
+
     fn style(&self) -> Option<cosmic::iced_runtime::Appearance> {
         Some(cosmic::applet::style())
     }
-}
+}

src/main.rs

···
 // SPDX-License-Identifier: GPL-3.0-only
 
-use app::YourApp;
+use app::Eyez;
 /// The `app` module is used by convention to indicate the main component of our application.
 mod app;
 mod core;
···
 /// - `()` is the flags that your app needs to use before it starts.
 ///  If your app does not need any flags, you can pass in `()`.
 fn main() -> cosmic::iced::Result {
-    cosmic::applet::run::<YourApp>(())
+    cosmic::applet::run::<Eyez>(())
 }