diff --git a/docs/Configuration guide.md b/docs/Configuration guide.md
index c269106c..7caeaf55 100644
--- a/docs/Configuration guide.md	
+++ b/docs/Configuration guide.md	
@@ -332,6 +332,7 @@ For information on the `Script` type, and embedding scripts in strings, see [her
 | `show_if`             | [Dynamic Boolean](dynamic-values#dynamic-boolean)     | `null`        | Polls the script to check its exit code. If exit code is zero, the module is shown. For other codes, it is hidden. |
 | `transition_type`     | `slide_start` or `slide_end` or `crossfade` or `none` | `slide_start` | The transition animation to use when showing/hiding the widget.                                                    |
 | `transition_duration` | `integer`                                             | `250`         | The length of the transition animation to use when showing/hiding the widget.                                      |
+| `disable_popup`       | `boolean`                                             | `false`       | Prevents the popup from opening on-click for this widget.                                                          |
 
 #### Appearance
 
diff --git a/docs/modules/Custom.md b/docs/modules/Custom.md
index 298e0a3b..30dbc488 100644
--- a/docs/modules/Custom.md
+++ b/docs/modules/Custom.md
@@ -1,6 +1,11 @@
-Allows you to compose custom modules consisting of multiple widgets, including popups. 
+Allows you to compose custom modules consisting of multiple modules and widgets, including popups. 
 Labels can display dynamic content from scripts, and buttons can interact with the bar or execute commands on click.
 
+The module provides a set of utility widgets, such as containers, labels and buttons. 
+In addition to these, you can also add any native module. 
+Paired with the other custom modules such as Cairo, 
+this provides a powerful declarative interface for constructing your own interfaces.
+
 If you only intend to run a single script, prefer the [script](script) module, 
 or [label](label) if you only need a single text label.
 
@@ -13,6 +18,11 @@ or [label](label) if you only need a single text label.
 This module can be quite fiddly to configure as you effectively have to build a tree of widgets by hand.
 It is well worth looking at the examples.
 
+| Name    | Type                   | Default    | Description                              |
+|---------|------------------------|------------|------------------------------------------|
+| `bar`   | `(Module or Widget)[]` | `[]`    | Modules and widgets to add to the bar.   |
+| `popup` | `(Module or Widget)[]`               | `null`     | Modules and widgets to add to the popup. |
+
 ### `Widget`
 
 There are many widget types, each with their own config options. 
@@ -36,7 +46,7 @@ A container to place nested widgets inside.
 | Name          | Type                                                       | Default        | Description                                                       |
 |---------------|------------------------------------------------------------|----------------|-------------------------------------------------------------------|
 | `orientation` | `'horizontal'` or `'vertical'` (shorthand: `'h'` or `'v'`) | `'horizontal'` | Whether child widgets should be horizontally or vertically added. |
-| `widgets`     | `Widget[]`                                                 | `[]`           | List of widgets to add to this box.                               |
+| `widgets`     | `(Module or Widget)[]`                                     | `[]`           | List of widgets to add to this box.                               |
 
 #### Label
 
@@ -197,6 +207,7 @@ to help get your head around what's going on:
                 <button class="power-btn" label="" on_click="!reboot" />
             </box>
             <label name="uptime" label="Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" />
+            <clock disable_popup="true" />
         </box>
     </popup>
 </custom>
@@ -252,6 +263,10 @@ to help get your head around what's going on:
               "label": "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}",
               "name": "uptime",
               "type": "label"
+            },
+            {
+              "type": "clock",
+              "disable_popup": true
             }
           ]
         }
@@ -309,6 +324,10 @@ type = 'button'
 label = '''Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}'''
 name = 'uptime'
 type = 'label'
+
+[[end.popup.widgets]]
+type = 'clock'
+disable_popup = true
 ```
 
 </details>
@@ -345,6 +364,8 @@ end:
     - label: 'Uptime: {{30000:uptime -p | cut -d '' '' -f2-}}'
       name: uptime
       type: label
+    - type: clock
+      disable_popup: true
   type: custom
 ```
 
@@ -370,6 +391,7 @@ let {
                 ]
             }
             { type = "label" name = "uptime" label = "Uptime: {{30000:uptime -p | cut -d ' ' -f2-}}" }
+            { type = "clock" disable_popup = true }
         ]
     }
 
diff --git a/src/bar.rs b/src/bar.rs
index d91e0fc0..4363806c 100644
--- a/src/bar.rs
+++ b/src/bar.rs
@@ -1,7 +1,5 @@
 use crate::config::{BarConfig, BarPosition, MarginConfig, ModuleConfig};
-use crate::modules::{
-    create_module, set_widget_identifiers, wrap_widget, ModuleInfo, ModuleLocation,
-};
+use crate::modules::{BarModuleFactory, ModuleInfo, ModuleLocation};
 use crate::popup::Popup;
 use crate::Ironbar;
 use color_eyre::Result;
@@ -350,55 +348,10 @@ fn add_modules(
     ironbar: &Rc<Ironbar>,
     popup: &Rc<Popup>,
 ) -> Result<()> {
-    let orientation = info.bar_position.orientation();
-
-    macro_rules! add_module {
-        ($module:expr, $id:expr) => {{
-            let common = $module.common.take().expect("common config to exist");
-            let widget_parts = create_module(
-                *$module,
-                $id,
-                ironbar.clone(),
-                common.name.clone(),
-                &info,
-                &Rc::clone(&popup),
-            )?;
-            set_widget_identifiers(&widget_parts, &common);
-
-            let container = wrap_widget(&widget_parts.widget, common, orientation);
-            content.add(&container);
-        }};
-    }
+    let module_factory = BarModuleFactory::new(ironbar.clone(), popup.clone()).into();
 
     for config in modules {
-        let id = Ironbar::unique_id();
-        match config {
-            #[cfg(feature = "clipboard")]
-            ModuleConfig::Clipboard(mut module) => add_module!(module, id),
-            #[cfg(feature = "clock")]
-            ModuleConfig::Clock(mut module) => add_module!(module, id),
-            ModuleConfig::Custom(mut module) => add_module!(module, id),
-            #[cfg(feature = "focused")]
-            ModuleConfig::Focused(mut module) => add_module!(module, id),
-            ModuleConfig::Label(mut module) => add_module!(module, id),
-            #[cfg(feature = "launcher")]
-            ModuleConfig::Launcher(mut module) => add_module!(module, id),
-            #[cfg(feature = "music")]
-            ModuleConfig::Music(mut module) => add_module!(module, id),
-            #[cfg(feature = "notifications")]
-            ModuleConfig::Notifications(mut module) => add_module!(module, id),
-            ModuleConfig::Script(mut module) => add_module!(module, id),
-            #[cfg(feature = "sys_info")]
-            ModuleConfig::SysInfo(mut module) => add_module!(module, id),
-            #[cfg(feature = "tray")]
-            ModuleConfig::Tray(mut module) => add_module!(module, id),
-            #[cfg(feature = "upower")]
-            ModuleConfig::Upower(mut module) => add_module!(module, id),
-            #[cfg(feature = "volume")]
-            ModuleConfig::Volume(mut module) => add_module!(module, id),
-            #[cfg(feature = "workspaces")]
-            ModuleConfig::Workspaces(mut module) => add_module!(module, id),
-        }
+        config.create(&module_factory, content, info)?;
     }
 
     Ok(())
diff --git a/src/config/common.rs b/src/config/common.rs
index 3e3cc850..fd207cfd 100644
--- a/src/config/common.rs
+++ b/src/config/common.rs
@@ -27,6 +27,7 @@ pub struct CommonConfig {
     pub on_mouse_exit: Option<ScriptInput>,
 
     pub tooltip: Option<String>,
+    pub disable_popup: bool,
 }
 
 #[derive(Debug, Deserialize, Clone)]
diff --git a/src/config/mod.rs b/src/config/mod.rs
index a20572bc..52fcb8d6 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -27,7 +27,10 @@ use crate::modules::upower::UpowerModule;
 use crate::modules::volume::VolumeModule;
 #[cfg(feature = "workspaces")]
 use crate::modules::workspaces::WorkspacesModule;
+
+use crate::modules::{AnyModuleFactory, ModuleFactory, ModuleInfo};
 use cfg_if::cfg_if;
+use color_eyre::Result;
 use serde::Deserialize;
 use std::collections::HashMap;
 
@@ -64,6 +67,49 @@ pub enum ModuleConfig {
     Workspaces(Box<WorkspacesModule>),
 }
 
+impl ModuleConfig {
+    pub fn create(
+        self,
+        module_factory: &AnyModuleFactory,
+        container: &gtk::Box,
+        info: &ModuleInfo,
+    ) -> Result<()> {
+        macro_rules! create {
+            ($module:expr) => {
+                module_factory.create(*$module, container, info)
+            };
+        }
+
+        match self {
+            #[cfg(feature = "clipboard")]
+            Self::Clipboard(module) => create!(module),
+            #[cfg(feature = "clock")]
+            Self::Clock(module) => create!(module),
+            Self::Custom(module) => create!(module),
+            #[cfg(feature = "focused")]
+            Self::Focused(module) => create!(module),
+            Self::Label(module) => create!(module),
+            #[cfg(feature = "launcher")]
+            Self::Launcher(module) => create!(module),
+            #[cfg(feature = "music")]
+            Self::Music(module) => create!(module),
+            #[cfg(feature = "notifications")]
+            Self::Notifications(module) => create!(module),
+            Self::Script(module) => create!(module),
+            #[cfg(feature = "sys_info")]
+            Self::SysInfo(module) => create!(module),
+            #[cfg(feature = "tray")]
+            Self::Tray(module) => create!(module),
+            #[cfg(feature = "upower")]
+            Self::Upower(module) => create!(module),
+            #[cfg(feature = "volume")]
+            Self::Volume(module) => create!(module),
+            #[cfg(feature = "workspaces")]
+            Self::Workspaces(module) => create!(module),
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Clone)]
 pub enum BarEntryConfig {
     Single(BarConfig),
diff --git a/src/ipc/server.rs b/src/ipc/server.rs
index 931a4fa8..776efe1d 100644
--- a/src/ipc/server.rs
+++ b/src/ipc/server.rs
@@ -172,7 +172,7 @@ impl Ipc {
                         popup.hide();
 
                         let data = popup
-                            .cache
+                            .container_cache
                             .borrow()
                             .iter()
                             .find(|(_, value)| value.name == name)
@@ -209,7 +209,7 @@ impl Ipc {
                         popup.hide();
 
                         let data = popup
-                            .cache
+                            .container_cache
                             .borrow()
                             .iter()
                             .find(|(_, value)| value.name == name)
diff --git a/src/macros.rs b/src/macros.rs
index e5fd195e..cabc8a02 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,3 +1,31 @@
+/// Provides implementations of methods required by the `Module` trait
+/// which cannot be included as part of the trait.
+///
+/// This removes the need to add the same boilerplate method definitions
+/// to every module implementation.
+///
+/// # Usage:
+///
+/// ```rs
+/// impl Module for ClockModule {
+///    type SendMessage = DateTime<Local>;
+///    type ReceiveMessage = ();
+///
+///    module_impl!("clock");
+/// }
+#[macro_export]
+macro_rules! module_impl {
+    ($name:literal) => {
+        fn name() -> &'static str {
+            $name
+        }
+
+        fn take_common(&mut self) -> $crate::config::CommonConfig {
+            self.common.take().expect("common config to exist")
+        }
+    };
+}
+
 /// Sends a message on an asynchronous `Sender` using `send()`
 /// Panics if the message cannot be sent.
 ///
diff --git a/src/modules/clipboard.rs b/src/modules/clipboard.rs
index 9749df68..6d53e401 100644
--- a/src/modules/clipboard.rs
+++ b/src/modules/clipboard.rs
@@ -5,7 +5,7 @@ use crate::image::new_icon_button;
 use crate::modules::{
     Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, PopupButton, WidgetContext,
 };
-use crate::{glib_recv, spawn, try_send};
+use crate::{glib_recv, module_impl, spawn, try_send};
 use glib::Propagation;
 use gtk::gdk_pixbuf::Pixbuf;
 use gtk::gio::{Cancellable, MemoryInputStream};
@@ -65,9 +65,7 @@ impl Module<Button> for ClipboardModule {
     type SendMessage = ControllerEvent;
     type ReceiveMessage = UIEvent;
 
-    fn name() -> &'static str {
-        "clipboard"
-    }
+    module_impl!("clipboard");
 
     fn spawn_controller(
         &self,
@@ -137,7 +135,7 @@ impl Module<Button> for ClipboardModule {
 
         let rx = context.subscribe();
         let popup = self
-            .into_popup(context.controller_tx, rx, info)
+            .into_popup(context.controller_tx.clone(), rx, context, info)
             .into_popup_parts(vec![&button]);
 
         Ok(ModuleParts::new(button, popup))
@@ -147,6 +145,7 @@ impl Module<Button> for ClipboardModule {
         self,
         tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box>
     where
diff --git a/src/modules/clock.rs b/src/modules/clock.rs
index d41ddf93..9978716c 100644
--- a/src/modules/clock.rs
+++ b/src/modules/clock.rs
@@ -13,7 +13,7 @@ use crate::gtk_helpers::IronbarGtkExt;
 use crate::modules::{
     Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, PopupButton, WidgetContext,
 };
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct ClockModule {
@@ -71,9 +71,7 @@ impl Module<Button> for ClockModule {
     type SendMessage = DateTime<Local>;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "clock"
-    }
+    module_impl!("clock");
 
     fn spawn_controller(
         &self,
@@ -120,7 +118,12 @@ impl Module<Button> for ClockModule {
         });
 
         let popup = self
-            .into_popup(context.controller_tx.clone(), context.subscribe(), info)
+            .into_popup(
+                context.controller_tx.clone(),
+                context.subscribe(),
+                context,
+                info,
+            )
             .into_popup_parts(vec![&button]);
 
         Ok(ModuleParts::new(button, popup))
@@ -130,6 +133,7 @@ impl Module<Button> for ClockModule {
         self,
         _tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box> {
         let container = gtk::Box::new(Orientation::Vertical, 0);
diff --git a/src/modules/custom/mod.rs b/src/modules/custom/mod.rs
index b6e97b9f..440c8e9c 100644
--- a/src/modules/custom/mod.rs
+++ b/src/modules/custom/mod.rs
@@ -9,14 +9,15 @@ use self::image::ImageWidget;
 use self::label::LabelWidget;
 use self::r#box::BoxWidget;
 use self::slider::SliderWidget;
-use crate::config::CommonConfig;
+use crate::config::{CommonConfig, ModuleConfig};
 use crate::modules::custom::button::ButtonWidget;
 use crate::modules::custom::progress::ProgressWidget;
 use crate::modules::{
-    wrap_widget, Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
+    wrap_widget, AnyModuleFactory, BarModuleFactory, Module, ModuleInfo, ModuleParts, ModulePopup,
+    ModuleUpdateEvent, PopupButton, PopupModuleFactory, WidgetContext,
 };
 use crate::script::Script;
-use crate::{send_async, spawn};
+use crate::{module_impl, send_async, spawn};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::{Button, IconTheme, Orientation};
@@ -40,11 +41,18 @@ pub struct CustomModule {
 #[derive(Debug, Deserialize, Clone)]
 pub struct WidgetConfig {
     #[serde(flatten)]
-    widget: Widget,
+    widget: WidgetOrModule,
     #[serde(flatten)]
     common: CommonConfig,
 }
 
+#[derive(Debug, Deserialize, Clone)]
+#[serde(untagged)]
+pub enum WidgetOrModule {
+    Widget(Widget),
+    Module(ModuleConfig),
+}
+
 #[derive(Debug, Deserialize, Clone)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum Widget {
@@ -58,10 +66,12 @@ pub enum Widget {
 
 #[derive(Clone)]
 struct CustomWidgetContext<'a> {
+    info: &'a ModuleInfo<'a>,
     tx: &'a mpsc::Sender<ExecEvent>,
     bar_orientation: Orientation,
     icon_theme: &'a IconTheme,
     popup_buttons: Rc<RefCell<Vec<Button>>>,
+    module_factory: AnyModuleFactory,
 }
 
 trait CustomWidget {
@@ -114,6 +124,19 @@ fn try_get_orientation(orientation: &str) -> Result<Orientation> {
     }
 }
 
+impl WidgetOrModule {
+    fn add_to(self, parent: &gtk::Box, context: &CustomWidgetContext, common: CommonConfig) {
+        match self {
+            WidgetOrModule::Widget(widget) => widget.add_to(parent, context, common),
+            WidgetOrModule::Module(config) => {
+                if let Err(err) = config.create(&context.module_factory, parent, context.info) {
+                    error!("{err:?}");
+                }
+            }
+        }
+    }
+}
+
 impl Widget {
     /// Creates this widget and adds it to the parent container
     fn add_to(self, parent: &gtk::Box, context: &CustomWidgetContext, common: CommonConfig) {
@@ -151,9 +174,7 @@ impl Module<gtk::Box> for CustomModule {
     type SendMessage = ();
     type ReceiveMessage = ExecEvent;
 
-    fn name() -> &'static str {
-        "custom"
-    }
+    module_impl!("custom");
 
     fn spawn_controller(
         &self,
@@ -191,7 +212,7 @@ impl Module<gtk::Box> for CustomModule {
 
     fn into_widget(
         self,
-        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
+        mut context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         info: &ModuleInfo,
     ) -> Result<ModuleParts<gtk::Box>> {
         let orientation = info.bar_position.orientation();
@@ -200,10 +221,13 @@ impl Module<gtk::Box> for CustomModule {
         let popup_buttons = Rc::new(RefCell::new(Vec::new()));
 
         let custom_context = CustomWidgetContext {
+            info,
             tx: &context.controller_tx,
             bar_orientation: orientation,
             icon_theme: info.icon_theme,
             popup_buttons: popup_buttons.clone(),
+            module_factory: BarModuleFactory::new(context.ironbar.clone(), context.popup.clone())
+                .into(),
         };
 
         self.bar.clone().into_iter().for_each(|widget| {
@@ -212,8 +236,22 @@ impl Module<gtk::Box> for CustomModule {
                 .add_to(&container, &custom_context, widget.common);
         });
 
+        for button in popup_buttons.borrow().iter() {
+            button.ensure_popup_id();
+        }
+
+        context.button_id = popup_buttons
+            .borrow()
+            .first()
+            .map_or(usize::MAX, |button| button.popup_id());
+
         let popup = self
-            .into_popup(context.controller_tx.clone(), context.subscribe(), info)
+            .into_popup(
+                context.controller_tx.clone(),
+                context.subscribe(),
+                context,
+                info,
+            )
             .into_popup_parts_owned(popup_buttons.take());
 
         Ok(ModuleParts {
@@ -226,6 +264,7 @@ impl Module<gtk::Box> for CustomModule {
         self,
         tx: mpsc::Sender<Self::ReceiveMessage>,
         _rx: broadcast::Receiver<Self::SendMessage>,
+        context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         info: &ModuleInfo,
     ) -> Option<gtk::Box>
     where
@@ -235,10 +274,17 @@ impl Module<gtk::Box> for CustomModule {
 
         if let Some(popup) = self.popup {
             let custom_context = CustomWidgetContext {
+                info,
                 tx: &tx,
                 bar_orientation: info.bar_position.orientation(),
                 icon_theme: info.icon_theme,
                 popup_buttons: Rc::new(RefCell::new(vec![])),
+                module_factory: PopupModuleFactory::new(
+                    context.ironbar,
+                    context.popup,
+                    context.button_id,
+                )
+                .into(),
             };
 
             for widget in popup {
diff --git a/src/modules/focused.rs b/src/modules/focused.rs
index 8c32c2bf..f132b646 100644
--- a/src/modules/focused.rs
+++ b/src/modules/focused.rs
@@ -3,7 +3,7 @@ use crate::config::{CommonConfig, TruncateMode};
 use crate::gtk_helpers::IronbarGtkExt;
 use crate::image::ImageProvider;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 use color_eyre::Result;
 use gtk::prelude::*;
 use gtk::Label;
@@ -50,9 +50,7 @@ impl Module<gtk::Box> for FocusedModule {
     type SendMessage = Option<(String, String)>;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "focused"
-    }
+    module_impl!("focused");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/label.rs b/src/modules/label.rs
index ce6cc21e..dde6f46a 100644
--- a/src/modules/label.rs
+++ b/src/modules/label.rs
@@ -1,7 +1,7 @@
 use crate::config::CommonConfig;
 use crate::dynamic_value::dynamic_string;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, try_send};
+use crate::{glib_recv, module_impl, try_send};
 use color_eyre::Result;
 use gtk::prelude::*;
 use gtk::Label;
@@ -29,9 +29,7 @@ impl Module<Label> for LabelModule {
     type SendMessage = String;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "label"
-    }
+    module_impl!("label");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/launcher/mod.rs b/src/modules/launcher/mod.rs
index 41a7931f..2d315575 100644
--- a/src/modules/launcher/mod.rs
+++ b/src/modules/launcher/mod.rs
@@ -7,7 +7,7 @@ use super::{Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, Wid
 use crate::clients::wayland::{self, ToplevelEvent};
 use crate::config::CommonConfig;
 use crate::desktop_file::find_desktop_file;
-use crate::{arc_mut, glib_recv, lock, send_async, spawn, try_send, write_lock};
+use crate::{arc_mut, glib_recv, lock, module_impl, send_async, spawn, try_send, write_lock};
 use color_eyre::{Help, Report};
 use gtk::prelude::*;
 use gtk::{Button, Orientation};
@@ -80,9 +80,7 @@ impl Module<gtk::Box> for LauncherModule {
     type SendMessage = LauncherUpdate;
     type ReceiveMessage = ItemEvent;
 
-    fn name() -> &'static str {
-        "launcher"
-    }
+    module_impl!("launcher");
 
     fn spawn_controller(
         &self,
@@ -401,7 +399,7 @@ impl Module<gtk::Box> for LauncherModule {
 
         let rx = context.subscribe();
         let popup = self
-            .into_popup(context.controller_tx, rx, info)
+            .into_popup(context.controller_tx.clone(), rx, context, info)
             .into_popup_parts(vec![]); // since item buttons are dynamic, they pass their geometry directly
 
         Ok(ModuleParts {
@@ -414,6 +412,7 @@ impl Module<gtk::Box> for LauncherModule {
         self,
         controller_tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box> {
         const MAX_WIDTH: i32 = 250;
diff --git a/src/modules/mod.rs b/src/modules/mod.rs
index 67a7f215..f768f61e 100644
--- a/src/modules/mod.rs
+++ b/src/modules/mod.rs
@@ -54,6 +54,8 @@ pub enum ModuleLocation {
     Center,
     Right,
 }
+
+#[derive(Clone)]
 pub struct ModuleInfo<'a> {
     pub app: &'a Application,
     pub location: ModuleLocation,
@@ -85,10 +87,16 @@ where
 {
     pub id: usize,
     pub ironbar: Rc<Ironbar>,
+    pub popup: Rc<Popup>,
     pub tx: mpsc::Sender<ModuleUpdateEvent<TSend>>,
     pub update_tx: broadcast::Sender<TSend>,
     pub controller_tx: mpsc::Sender<TReceive>,
 
+    // TODO: Don't like this - need some serious refactoring to deal with it
+    //  This is a hack to be able to pass data from module -> popup creation
+    //  for custom widget only.
+    pub button_id: usize,
+
     _update_rx: broadcast::Receiver<TSend>,
 }
 
@@ -122,6 +130,32 @@ impl<W: IsA<Widget>> ModuleParts<W> {
     fn new(widget: W, popup: Option<ModulePopupParts>) -> Self {
         Self { widget, popup }
     }
+
+    pub fn setup_identifiers(&self, common: &CommonConfig) {
+        if let Some(ref name) = common.name {
+            self.widget.set_widget_name(name);
+
+            if let Some(ref popup) = self.popup {
+                popup.container.set_widget_name(&format!("popup-{name}"));
+            }
+        }
+
+        if let Some(ref class) = common.class {
+            // gtk counts classes with spaces as the same class
+            for part in class.split(' ') {
+                self.widget.style_context().add_class(part);
+            }
+
+            if let Some(ref popup) = self.popup {
+                for part in class.split(' ') {
+                    popup
+                        .container
+                        .style_context()
+                        .add_class(&format!("popup-{part}"));
+                }
+            }
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -150,11 +184,24 @@ impl ModulePopup for Option<gtk::Box> {
 }
 
 pub trait PopupButton {
+    fn ensure_popup_id(&self) -> usize;
     fn try_popup_id(&self) -> Option<usize>;
     fn popup_id(&self) -> usize;
 }
 
 impl PopupButton for Button {
+    /// Gets the popup ID associated with this button,
+    /// or creates a new one if it does not exist.
+    fn ensure_popup_id(&self) -> usize {
+        if let Some(id) = self.try_popup_id() {
+            id
+        } else {
+            let id = Ironbar::unique_id();
+            self.set_tag("popup-id", id);
+            id
+        }
+    }
+
     /// Gets the popup ID associated with this button, if there is one.
     /// Will return `None` if this is not a popup button.
     fn try_popup_id(&self) -> Option<usize> {
@@ -201,165 +248,290 @@ where
         self,
         _tx: mpsc::Sender<Self::ReceiveMessage>,
         _rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box>
     where
         Self: Sized,
+        <Self as Module<W>>::SendMessage: Clone,
     {
         None
     }
+
+    fn take_common(&mut self) -> CommonConfig;
 }
 
-/// Creates a module and sets it up.
-/// This setup includes widget/popup content and event channels.
-pub fn create_module<TModule, TWidget, TSend, TRec>(
-    module: TModule,
-    id: usize,
-    ironbar: Rc<Ironbar>,
-    name: Option<String>,
-    info: &ModuleInfo,
-    popup: &Rc<Popup>,
-) -> Result<ModuleParts<TWidget>>
-where
-    TModule: Module<TWidget, SendMessage = TSend, ReceiveMessage = TRec>,
-    TWidget: IsA<Widget>,
-    TSend: Debug + Clone + Send + 'static,
-{
-    let (ui_tx, ui_rx) = mpsc::channel::<ModuleUpdateEvent<TSend>>(64);
-    let (controller_tx, controller_rx) = mpsc::channel::<TRec>(64);
+pub trait ModuleFactory {
+    fn create<TModule, TWidget, TSend, TRev>(
+        &self,
+        mut module: TModule,
+        container: &gtk::Box,
+        info: &ModuleInfo,
+    ) -> Result<()>
+    where
+        TModule: Module<TWidget, SendMessage = TSend, ReceiveMessage = TRev>,
+        TWidget: IsA<Widget>,
+        TSend: Debug + Clone + Send + 'static,
+    {
+        let id = Ironbar::unique_id();
+        let common = module.take_common();
+
+        let (ui_tx, ui_rx) = mpsc::channel::<ModuleUpdateEvent<TSend>>(64);
+        let (controller_tx, controller_rx) = mpsc::channel::<TRev>(64);
+
+        let (tx, rx) = broadcast::channel(64);
+
+        let context = WidgetContext {
+            id,
+            ironbar: self.ironbar().clone(),
+            popup: self.popup().clone(),
+            tx: ui_tx,
+            update_tx: tx.clone(),
+            controller_tx,
+            _update_rx: rx,
+            button_id: usize::MAX, // hack :(
+        };
+
+        module.spawn_controller(info, &context, controller_rx)?;
+
+        let module_name = TModule::name();
+        let instance_name = common
+            .name
+            .clone()
+            .unwrap_or_else(|| module_name.to_string());
+
+        let module_parts = module.into_widget(context, info)?;
+        module_parts.widget.add_class("widget");
+        module_parts.widget.add_class(module_name);
+
+        if let Some(popup_content) = module_parts.popup.clone() {
+            popup_content
+                .container
+                .style_context()
+                .add_class(&format!("popup-{module_name}"));
+
+            self.popup()
+                .register_content(id, instance_name, popup_content);
+        }
 
-    let (tx, rx) = broadcast::channel(64);
+        self.setup_receiver(tx, ui_rx, module_name, id, common.disable_popup);
 
-    let context = WidgetContext {
-        id,
-        ironbar,
-        tx: ui_tx,
-        update_tx: tx.clone(),
-        controller_tx,
-        _update_rx: rx,
-    };
+        module_parts.setup_identifiers(&common);
 
-    module.spawn_controller(info, &context, controller_rx)?;
+        let ev_container = wrap_widget(
+            &module_parts.widget,
+            common,
+            info.bar_position.orientation(),
+        );
+        container.add(&ev_container);
 
-    let module_name = TModule::name();
-    let instance_name = name.unwrap_or_else(|| module_name.to_string());
+        Ok(())
+    }
 
-    let module_parts = module.into_widget(context, info)?;
-    module_parts.widget.add_class("widget");
-    module_parts.widget.add_class(module_name);
+    fn setup_receiver<TSend>(
+        &self,
+        tx: broadcast::Sender<TSend>,
+        rx: mpsc::Receiver<ModuleUpdateEvent<TSend>>,
+        name: &'static str,
+        id: usize,
+        disable_popup: bool,
+    ) where
+        TSend: Debug + Clone + Send + 'static;
+
+    fn ironbar(&self) -> &Rc<Ironbar>;
+    fn popup(&self) -> &Rc<Popup>;
+}
 
-    if let Some(popup_content) = module_parts.popup.clone() {
-        popup_content
-            .container
-            .style_context()
-            .add_class(&format!("popup-{module_name}"));
+#[derive(Clone)]
+pub struct BarModuleFactory {
+    ironbar: Rc<Ironbar>,
+    popup: Rc<Popup>,
+}
 
-        popup.register_content(id, instance_name, popup_content);
+impl BarModuleFactory {
+    pub fn new(ironbar: Rc<Ironbar>, popup: Rc<Popup>) -> Self {
+        Self { ironbar, popup }
     }
+}
 
-    setup_receiver(tx, ui_rx, popup.clone(), module_name, id);
+impl ModuleFactory for BarModuleFactory {
+    fn setup_receiver<TSend>(
+        &self,
+        tx: broadcast::Sender<TSend>,
+        rx: mpsc::Receiver<ModuleUpdateEvent<TSend>>,
+        name: &'static str,
+        id: usize,
+        disable_popup: bool,
+    ) where
+        TSend: Debug + Clone + Send + 'static,
+    {
+        let popup = self.popup.clone();
+        glib_recv_mpsc!(rx, ev => {
+            match ev {
+                ModuleUpdateEvent::Update(update) => {
+                    send!(tx, update);
+                }
+                ModuleUpdateEvent::TogglePopup(button_id) if !disable_popup => {
+                    debug!("Toggling popup for {} [#{}] (button id: {button_id})", name, id);
+                    if popup.is_visible() && popup.current_widget().unwrap_or_default() == id {
+                        popup.hide();
+                    } else {
+                        popup.show(id, button_id);
+                    }
+                }
+                ModuleUpdateEvent::OpenPopup(button_id) if !disable_popup => {
+                    debug!("Opening popup for {} [#{}] (button id: {button_id})", name, id);
+                    popup.hide();
+                    popup.show(id, button_id);
+                }
+                #[cfg(feature = "launcher")]
+                ModuleUpdateEvent::OpenPopupAt(geometry) if !disable_popup => {
+                    debug!("Opening popup for {} [#{}]", name, id);
 
-    Ok(module_parts)
+                    popup.hide();
+                    popup.show_at(id, geometry);
+                }
+                ModuleUpdateEvent::ClosePopup if !disable_popup => {
+                    debug!("Closing popup for {} [#{}]", name, id);
+                    popup.hide();
+                },
+                _ => {}
+            }
+        });
+    }
+
+    fn ironbar(&self) -> &Rc<Ironbar> {
+        &self.ironbar
+    }
+
+    fn popup(&self) -> &Rc<Popup> {
+        &self.popup
+    }
 }
 
-/// Sets up the bridge channel receiver
-/// to pick up events from the controller, widget or popup.
-///
-/// Handles opening/closing popups
-/// and communicating update messages between controllers and widgets/popups.
-fn setup_receiver<TSend>(
-    tx: broadcast::Sender<TSend>,
-    rx: mpsc::Receiver<ModuleUpdateEvent<TSend>>,
+#[derive(Clone)]
+pub struct PopupModuleFactory {
+    ironbar: Rc<Ironbar>,
     popup: Rc<Popup>,
-    name: &'static str,
-    id: usize,
-) where
-    TSend: Debug + Clone + Send + 'static,
-{
-    // some rare cases can cause the popup to incorrectly calculate its size on first open.
-    // we can fix that by just force re-rendering it on its first open.
-    let mut has_popup_opened = false;
-
-    glib_recv_mpsc!(rx, ev => {
-        match ev {
-            ModuleUpdateEvent::Update(update) => {
-                send!(tx, update);
-            }
-            ModuleUpdateEvent::TogglePopup(button_id) => {
-                debug!("Toggling popup for {} [#{}]", name, id);
-                if popup.is_visible() {
-                    popup.hide();
-                } else {
-                    popup.show(id, button_id);
+    button_id: usize,
+}
+
+impl PopupModuleFactory {
+    pub fn new(ironbar: Rc<Ironbar>, popup: Rc<Popup>, button_id: usize) -> Self {
+        Self {
+            ironbar,
+            popup,
+            button_id,
+        }
+    }
+}
 
-                    // force re-render on initial open to try and fix size issue
-                    if !has_popup_opened {
+impl ModuleFactory for PopupModuleFactory {
+    fn setup_receiver<TSend>(
+        &self,
+        tx: broadcast::Sender<TSend>,
+        rx: mpsc::Receiver<ModuleUpdateEvent<TSend>>,
+        name: &'static str,
+        id: usize,
+        disable_popup: bool,
+    ) where
+        TSend: Debug + Clone + Send + 'static,
+    {
+        let popup = self.popup.clone();
+        let button_id = self.button_id;
+        glib_recv_mpsc!(rx, ev => {
+            match ev {
+                ModuleUpdateEvent::Update(update) => {
+                    send!(tx, update);
+                }
+                ModuleUpdateEvent::TogglePopup(_) if !disable_popup => {
+                    debug!("Toggling popup for {} [#{}] (button id: {button_id})", name, id);
+                    if popup.is_visible() && popup.current_widget().unwrap_or_default() == id {
+                        popup.hide();
+                    } else {
                         popup.show(id, button_id);
-                        has_popup_opened = true;
                     }
                 }
-            }
-            ModuleUpdateEvent::OpenPopup(button_id) => {
-                debug!("Opening popup for {} [#{}]", name, id);
-                popup.hide();
-                popup.show(id, button_id);
-
-                // force re-render on initial open to try and fix size issue
-                if !has_popup_opened {
+                ModuleUpdateEvent::OpenPopup(_) if !disable_popup => {
+                    debug!("Opening popup for {} [#{}] (button id: {button_id})", name, id);
+                    popup.hide();
                     popup.show(id, button_id);
-                    has_popup_opened = true;
                 }
-            }
-            #[cfg(feature = "launcher")]
-            ModuleUpdateEvent::OpenPopupAt(geometry) => {
-                debug!("Opening popup for {} [#{}]", name, id);
-
-                popup.hide();
-                popup.show_at(id, geometry);
+                #[cfg(feature = "launcher")]
+                ModuleUpdateEvent::OpenPopupAt(geometry) if !disable_popup => {
+                    debug!("Opening popup for {} [#{}]", name, id);
 
-                // force re-render on initial open to try and fix size issue
-                if !has_popup_opened {
+                    popup.hide();
                     popup.show_at(id, geometry);
-                    has_popup_opened = true;
                 }
+                ModuleUpdateEvent::ClosePopup if !disable_popup => {
+                    debug!("Closing popup for {} [#{}]", name, id);
+                    popup.hide();
+                },
+                _ => {}
             }
-            ModuleUpdateEvent::ClosePopup => {
-                debug!("Closing popup for {} [#{}]", name, id);
-                popup.hide();
-            }
-        }
-    });
+        });
+    }
+
+    fn ironbar(&self) -> &Rc<Ironbar> {
+        &self.ironbar
+    }
+
+    fn popup(&self) -> &Rc<Popup> {
+        &self.popup
+    }
 }
 
-pub fn set_widget_identifiers<TWidget: IsA<Widget>>(
-    widget_parts: &ModuleParts<TWidget>,
-    common: &CommonConfig,
-) {
-    if let Some(ref name) = common.name {
-        widget_parts.widget.set_widget_name(name);
+#[derive(Clone)]
+pub enum AnyModuleFactory {
+    Bar(BarModuleFactory),
+    Popup(PopupModuleFactory),
+}
 
-        if let Some(ref popup) = widget_parts.popup {
-            popup.container.set_widget_name(&format!("popup-{name}"));
+impl ModuleFactory for AnyModuleFactory {
+    fn setup_receiver<TSend>(
+        &self,
+        tx: broadcast::Sender<TSend>,
+        rx: mpsc::Receiver<ModuleUpdateEvent<TSend>>,
+        name: &'static str,
+        id: usize,
+        disable_popup: bool,
+    ) where
+        TSend: Debug + Clone + Send + 'static,
+    {
+        match self {
+            AnyModuleFactory::Bar(bar) => bar.setup_receiver(tx, rx, name, id, disable_popup),
+            AnyModuleFactory::Popup(popup) => popup.setup_receiver(tx, rx, name, id, disable_popup),
         }
     }
 
-    if let Some(ref class) = common.class {
-        // gtk counts classes with spaces as the same class
-        for part in class.split(' ') {
-            widget_parts.widget.style_context().add_class(part);
+    fn ironbar(&self) -> &Rc<Ironbar> {
+        match self {
+            AnyModuleFactory::Bar(bar) => bar.ironbar(),
+            AnyModuleFactory::Popup(popup) => popup.ironbar(),
         }
+    }
 
-        if let Some(ref popup) = widget_parts.popup {
-            for part in class.split(' ') {
-                popup
-                    .container
-                    .style_context()
-                    .add_class(&format!("popup-{part}"));
-            }
+    fn popup(&self) -> &Rc<Popup> {
+        match self {
+            AnyModuleFactory::Bar(bar) => bar.popup(),
+            AnyModuleFactory::Popup(popup) => popup.popup(),
         }
     }
 }
 
+impl From<BarModuleFactory> for AnyModuleFactory {
+    fn from(value: BarModuleFactory) -> Self {
+        Self::Bar(value)
+    }
+}
+
+impl From<PopupModuleFactory> for AnyModuleFactory {
+    fn from(value: PopupModuleFactory) -> Self {
+        Self::Popup(value)
+    }
+}
+
 /// Takes a widget and adds it into a new `gtk::EventBox`.
 /// The event box container is returned.
 pub fn wrap_widget<W: IsA<Widget>>(
diff --git a/src/modules/music/mod.rs b/src/modules/music/mod.rs
index eb093da3..3e9604ca 100644
--- a/src/modules/music/mod.rs
+++ b/src/modules/music/mod.rs
@@ -22,7 +22,7 @@ use crate::modules::PopupButton;
 use crate::modules::{
     Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
 };
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 
 pub use self::config::MusicModule;
 use self::config::PlayerType;
@@ -87,9 +87,7 @@ impl Module<Button> for MusicModule {
     type SendMessage = ControllerEvent;
     type ReceiveMessage = PlayerCommand;
 
-    fn name() -> &'static str {
-        "music"
-    }
+    module_impl!("music");
 
     fn spawn_controller(
         &self,
@@ -255,7 +253,7 @@ impl Module<Button> for MusicModule {
 
         let rx = context.subscribe();
         let popup = self
-            .into_popup(context.controller_tx, rx, info)
+            .into_popup(context.controller_tx.clone(), rx, context, info)
             .into_popup_parts(vec![&button]);
 
         Ok(ModuleParts::new(button, popup))
@@ -265,6 +263,7 @@ impl Module<Button> for MusicModule {
         self,
         tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         info: &ModuleInfo,
     ) -> Option<gtk::Box> {
         let icon_theme = info.icon_theme;
diff --git a/src/modules/notifications.rs b/src/modules/notifications.rs
index 232b5863..6f8fea87 100644
--- a/src/modules/notifications.rs
+++ b/src/modules/notifications.rs
@@ -2,7 +2,7 @@ use crate::clients::swaync;
 use crate::config::CommonConfig;
 use crate::gtk_helpers::IronbarGtkExt;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 use gtk::prelude::*;
 use gtk::{Align, Button, Label, Overlay};
 use serde::Deserialize;
@@ -97,9 +97,7 @@ impl Module<Overlay> for NotificationsModule {
     type SendMessage = swaync::Event;
     type ReceiveMessage = UiEvent;
 
-    fn name() -> &'static str {
-        "notifications"
-    }
+    module_impl!("notifications");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/script.rs b/src/modules/script.rs
index b5d485bf..0f834900 100644
--- a/src/modules/script.rs
+++ b/src/modules/script.rs
@@ -1,7 +1,7 @@
 use crate::config::CommonConfig;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
 use crate::script::{OutputStream, Script, ScriptMode};
-use crate::{glib_recv, spawn, try_send};
+use crate::{glib_recv, module_impl, spawn, try_send};
 use color_eyre::{Help, Report, Result};
 use gtk::prelude::*;
 use gtk::Label;
@@ -48,9 +48,7 @@ impl Module<Label> for ScriptModule {
     type SendMessage = String;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "script"
-    }
+    module_impl!("script");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs
index c815110d..c6a9f664 100644
--- a/src/modules/sysinfo.rs
+++ b/src/modules/sysinfo.rs
@@ -1,7 +1,7 @@
 use crate::config::CommonConfig;
 use crate::gtk_helpers::IronbarGtkExt;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, send_async, spawn};
+use crate::{glib_recv, module_impl, send_async, spawn};
 use color_eyre::Result;
 use gtk::prelude::*;
 use gtk::Label;
@@ -116,9 +116,7 @@ impl Module<gtk::Box> for SysInfoModule {
     type SendMessage = HashMap<String, String>;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "sysinfo"
-    }
+    module_impl!("sysinfo");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/tray/mod.rs b/src/modules/tray/mod.rs
index f311a3d0..f677272d 100644
--- a/src/modules/tray/mod.rs
+++ b/src/modules/tray/mod.rs
@@ -6,7 +6,7 @@ use crate::clients::tray;
 use crate::config::CommonConfig;
 use crate::modules::tray::diff::get_diffs;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, lock, send_async, spawn};
+use crate::{glib_recv, lock, module_impl, send_async, spawn};
 use color_eyre::{Report, Result};
 use gtk::{prelude::*, PackDirection};
 use gtk::{IconTheme, MenuBar};
@@ -57,9 +57,7 @@ impl Module<MenuBar> for TrayModule {
     type SendMessage = Event;
     type ReceiveMessage = ActivateRequest;
 
-    fn name() -> &'static str {
-        "tray"
-    }
+    module_impl!("tray");
 
     fn spawn_controller(
         &self,
diff --git a/src/modules/upower.rs b/src/modules/upower.rs
index f2b976a2..8d1e53b7 100644
--- a/src/modules/upower.rs
+++ b/src/modules/upower.rs
@@ -15,7 +15,7 @@ use crate::modules::PopupButton;
 use crate::modules::{
     Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, WidgetContext,
 };
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 
 const DAY: i64 = 24 * 60 * 60;
 const HOUR: i64 = 60 * 60;
@@ -54,9 +54,7 @@ impl Module<gtk::Button> for UpowerModule {
     type SendMessage = UpowerProperties;
     type ReceiveMessage = ();
 
-    fn name() -> &'static str {
-        "upower"
-    }
+    module_impl!("upower");
 
     fn spawn_controller(
         &self,
@@ -211,7 +209,7 @@ impl Module<gtk::Button> for UpowerModule {
 
         let rx = context.subscribe();
         let popup = self
-            .into_popup(context.controller_tx, rx, info)
+            .into_popup(context.controller_tx.clone(), rx, context, info)
             .into_popup_parts(vec![&button]);
 
         Ok(ModuleParts::new(button, popup))
@@ -221,6 +219,7 @@ impl Module<gtk::Button> for UpowerModule {
         self,
         _tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box>
     where
diff --git a/src/modules/volume.rs b/src/modules/volume.rs
index bb33337a..f11fa605 100644
--- a/src/modules/volume.rs
+++ b/src/modules/volume.rs
@@ -4,7 +4,7 @@ use crate::gtk_helpers::IronbarGtkExt;
 use crate::modules::{
     Module, ModuleInfo, ModuleParts, ModulePopup, ModuleUpdateEvent, PopupButton, WidgetContext,
 };
-use crate::{glib_recv, lock, send_async, spawn, try_send};
+use crate::{glib_recv, lock, module_impl, send_async, spawn, try_send};
 use glib::Propagation;
 use gtk::pango::EllipsizeMode;
 use gtk::prelude::*;
@@ -99,9 +99,7 @@ impl Module<Button> for VolumeModule {
     type SendMessage = Event;
     type ReceiveMessage = Update;
 
-    fn name() -> &'static str {
-        "volume"
-    }
+    module_impl!("volume");
 
     fn spawn_controller(
         &self,
@@ -208,7 +206,12 @@ impl Module<Button> for VolumeModule {
         }
 
         let popup = self
-            .into_popup(context.controller_tx.clone(), context.subscribe(), info)
+            .into_popup(
+                context.controller_tx.clone(),
+                context.subscribe(),
+                context,
+                info,
+            )
             .into_popup_parts(vec![&button]);
 
         Ok(ModuleParts::new(button, popup))
@@ -218,6 +221,7 @@ impl Module<Button> for VolumeModule {
         self,
         tx: mpsc::Sender<Self::ReceiveMessage>,
         rx: tokio::sync::broadcast::Receiver<Self::SendMessage>,
+        _context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         _info: &ModuleInfo,
     ) -> Option<gtk::Box>
     where
diff --git a/src/modules/workspaces.rs b/src/modules/workspaces.rs
index 0d310193..bd978575 100644
--- a/src/modules/workspaces.rs
+++ b/src/modules/workspaces.rs
@@ -2,7 +2,7 @@ use crate::clients::compositor::{Visibility, Workspace, WorkspaceClient, Workspa
 use crate::config::CommonConfig;
 use crate::image::new_icon_button;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, send_async, spawn, try_send};
+use crate::{glib_recv, module_impl, send_async, spawn, try_send};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::{Button, IconTheme};
@@ -144,9 +144,7 @@ impl Module<gtk::Box> for WorkspacesModule {
     type SendMessage = WorkspaceUpdate;
     type ReceiveMessage = String;
 
-    fn name() -> &'static str {
-        "workspaces"
-    }
+    module_impl!("workspaces");
 
     fn spawn_controller(
         &self,
diff --git a/src/popup.rs b/src/popup.rs
index 1f24248b..0a85a7f6 100644
--- a/src/popup.rs
+++ b/src/popup.rs
@@ -12,7 +12,7 @@ use tracing::{debug, trace};
 use crate::config::BarPosition;
 use crate::gtk_helpers::{IronbarGtkExt, WidgetGeometry};
 use crate::modules::{ModuleInfo, ModulePopupParts, PopupButton};
-use crate::Ironbar;
+use crate::rc_mut;
 
 #[derive(Debug, Clone)]
 pub struct PopupCacheValue {
@@ -23,7 +23,8 @@ pub struct PopupCacheValue {
 #[derive(Debug, Clone)]
 pub struct Popup {
     pub window: ApplicationWindow,
-    pub cache: Rc<RefCell<HashMap<usize, PopupCacheValue>>>,
+    pub container_cache: Rc<RefCell<HashMap<usize, PopupCacheValue>>>,
+    pub button_cache: Rc<RefCell<Vec<Button>>>,
     monitor: Monitor,
     pos: BarPosition,
     current_widget: Rc<RefCell<Option<(usize, usize)>>>,
@@ -106,10 +107,11 @@ impl Popup {
 
         Self {
             window: win,
-            cache: Rc::new(RefCell::new(HashMap::new())),
+            container_cache: rc_mut!(HashMap::new()),
+            button_cache: rc_mut!(vec![]),
             monitor: module_info.monitor.clone(),
             pos,
-            current_widget: Rc::new(RefCell::new(None)),
+            current_widget: rc_mut!(None),
         }
     }
 
@@ -117,8 +119,7 @@ impl Popup {
         debug!("Registered popup content for #{}", key);
 
         for button in &content.buttons {
-            let id = Ironbar::unique_id();
-            button.set_tag("popup-id", id);
+            button.ensure_popup_id();
         }
 
         let orientation = self.pos.orientation();
@@ -126,7 +127,8 @@ impl Popup {
         let window = self.window.clone();
 
         let current_widget = self.current_widget.clone();
-        let cache = self.cache.clone();
+        let cache = self.container_cache.clone();
+        let button_cache = self.button_cache.clone();
 
         content
             .container
@@ -135,11 +137,9 @@ impl Popup {
                     trace!("Resized:  {}x{}", rect.width(), rect.height());
 
                     if let Some((widget_id, button_id)) = *current_widget.borrow() {
-                        if let Some(PopupCacheValue { content, .. }) =
-                            cache.borrow().get(&widget_id)
-                        {
+                        if let Some(PopupCacheValue { .. }) = cache.borrow().get(&widget_id) {
                             Self::set_position(
-                                &content.buttons,
+                                &button_cache.borrow(),
                                 button_id,
                                 orientation,
                                 &monitor,
@@ -150,7 +150,11 @@ impl Popup {
                 }
             });
 
-        self.cache
+        self.button_cache
+            .borrow_mut()
+            .append(&mut content.buttons.clone());
+
+        self.container_cache
             .borrow_mut()
             .insert(key, PopupCacheValue { name, content });
     }
@@ -158,16 +162,17 @@ impl Popup {
     pub fn show(&self, widget_id: usize, button_id: usize) {
         self.clear_window();
 
-        if let Some(PopupCacheValue { content, .. }) = self.cache.borrow().get(&widget_id) {
+        if let Some(PopupCacheValue { content, .. }) = self.container_cache.borrow().get(&widget_id)
+        {
             *self.current_widget.borrow_mut() = Some((widget_id, button_id));
 
-            content.container.style_context().add_class("popup");
+            content.container.add_class("popup");
             self.window.add(&content.container);
 
             self.window.show();
 
             Self::set_position(
-                &content.buttons,
+                &self.button_cache.borrow(),
                 button_id,
                 self.pos.orientation(),
                 &self.monitor,
@@ -179,8 +184,9 @@ impl Popup {
     pub fn show_at(&self, widget_id: usize, geometry: WidgetGeometry) {
         self.clear_window();
 
-        if let Some(PopupCacheValue { content, .. }) = self.cache.borrow().get(&widget_id) {
-            content.container.style_context().add_class("popup");
+        if let Some(PopupCacheValue { content, .. }) = self.container_cache.borrow().get(&widget_id)
+        {
+            content.container.add_class("popup");
             self.window.add(&content.container);
 
             self.window.show();