leyoda/libcosmic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

focus windows using launcher IPC

Browse source
This commit is contained in:
Ashley Wulber 2021-11-30 16:15:06 -05:00 • committed by Jeremy Soller
parent 19f003f942
commit 54b762dbab
18 changed files with 350 additions and 276 deletions
Download patch file Download diff file Expand all files Collapse all files

5
examples/gtklauncher/README.md
View file

@ -1,5 +0,0 @@
# ListView: Applications Launcher
This example shows how to create a `gtk::ListView` and fill it with applications data from `gio::AppInfo` with the possibility to open an application when an item of the list is activated.
![Screenshot](screenshot.png)

39
examples/gtklauncher/application_row/mod.rs
View file

@ -1,39 +0,0 @@
use gtk4 as gtk;
mod imp;
use gtk::prelude::*;
use gtk::subclass::prelude::*;
use gtk::{gio, glib};
glib::wrapper! {
pub struct ApplicationRow(ObjectSubclass<imp::ApplicationRow>)
@extends gtk::Widget, gtk::Box;
}
impl Default for ApplicationRow {
fn default() -> Self {
Self::new()
}
}
impl ApplicationRow {
pub fn new() -> Self {
glib::Object::new(&[]).expect("Failed to create ApplicationRow")
}
pub fn set_app_info(&self, app_info: &gio::AppInfo) {
let self_ = imp::ApplicationRow::from_instance(self);
self_.name.set_text(&app_info.name());
if let Some(desc) = app_info.description() {
self_.description.set_text(&desc);
}
if let Some(icon) = app_info.icon() {
self_.image.set_from_gicon(&icon);
}
}
pub fn set_shortcut(&self, indx: u32) {
let self_ = imp::ApplicationRow::from_instance(self);
self_.shortcut.set_text(&format!("Ctrl + {}", indx));
}
}

34
examples/gtklauncher/main.rs
View file

@ -1,34 +0,0 @@
mod application_row;
mod window;
use gtk::gdk::Display;
use gtk::prelude::*;
use gtk4 as gtk;
use window::Window;
fn main() {
let application = gtk::Application::new(
Some("com.github.gtk-rs.examples.apps_launcher"),
Default::default(),
);
application.connect_activate(|app| {
let provider = gtk::CssProvider::new();
provider.load_from_data(include_bytes!("style.css"));
gtk::StyleContext::add_provider_for_display(
&Display::default().expect("Error initializing gtk css provider."),
&provider,
gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
);
new_build_ui(app);
});
application.run();
}
fn new_build_ui(app: &gtk::Application) {
// Create a new custom window and show it
let window = Window::new(app);
window.show();
}

BIN
examples/gtklauncher/screenshot.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 86 KiB

15
examples/gtklauncher/style.css
View file

@ -1,15 +0,0 @@
description {
line-height: 1.5em;
background-image: none;
background-color: red;
}
row.row1 {
background-image: none;
background-color: black;
}
shortcut {
background-image: none;
background-color: green;
}

84
examples/launcher/application_object/imp.rs
View file

@ -1,7 +1,4 @@
use glib::{
types::Type, FromVariant, ParamFlags, ParamSpec, ParamSpecObject, ToVariant, Value, Variant,
VariantTy,
};
use glib::{FromVariant, ParamFlags, ParamSpec, ToVariant, Value, Variant, VariantTy};
use gtk4::glib;
use gtk4::prelude::*;
use gtk4::subclass::prelude::*;
@ -21,7 +18,7 @@ pub struct ApplicationObject {
// The central trait for subclassing a GObject
#[glib::object_subclass]
impl ObjectSubclass for ApplicationObject {
const NAME: &'static str = "LibCosmicLauncherApplicationObject";
const NAME: &'static str = "ApplicationObject";
type Type = super::ApplicationObject;
type ParentType = glib::Object;
}
@ -31,6 +28,20 @@ impl ObjectImpl for ApplicationObject {
fn properties() -> &'static [ParamSpec] {
static PROPERTIES: Lazy<Vec<ParamSpec>> = Lazy::new(|| {
vec![
ParamSpec::new_uint(
// Name
"id",
// Nickname
"id",
// Short description
"ID of application in launcher search result",
0,
u32::MAX,
// Default value
0,
// The property can be read and written to
ParamFlags::READWRITE,
),
ParamSpec::new_string(
// Name
"name",
@ -102,6 +113,10 @@ impl ObjectImpl for ApplicationObject {
fn set_property(&self, _obj: &Self::Type, _id: usize, value: &Value, pspec: &ParamSpec) {
match pspec.name() {
"id" => {
let id = value.get().expect("The value needs to be of type `u32`.");
self.data.borrow_mut().0.id = id;
}
"name" => {
let name = value
.get()
@ -115,46 +130,44 @@ impl ObjectImpl for ApplicationObject {
self.data.borrow_mut().0.description = description;
}
"icon" => {
let icon = <Option<(i32, String)>>::from_variant(
let icon = <(i32, String)>::from_variant(
&value
.get::<Variant>()
.expect("The icon needs to be a Variant"),
)
.expect("The icon variant needs to be an Option<(i32, String)>");
if let Some(icon) = icon {
self.data.borrow_mut().0.icon = match icon {
(i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
(i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
_ => None,
};
} else {
self.data.borrow_mut().0.icon = None;
}
.expect("The icon variant needs to be an (i32, String)");
self.data.borrow_mut().0.icon = match icon {
(i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
(i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
(i_type, name) => {
println!("Failed to set icon. {} {}", i_type, name);
None
}
};
}
"categoryicon" => {
let icon = <Option<(i32, String)>>::from_variant(
let icon = <(i32, String)>::from_variant(
&value
.get::<Variant>()
.expect("The icon needs to be a Variant"),
)
.expect("The icon variant needs to be an Option<(i32, String)>");
if let Some(icon) = icon {
self.data.borrow_mut().0.icon = match icon {
(i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
(i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
_ => None,
};
} else {
self.data.borrow_mut().0.icon = None;
}
self.data.borrow_mut().0.category_icon = match icon {
(i_type, name) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
(i_type, name) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
(i_type, name) => {
println!("Failed to set icon. {} {}", i_type, name);
None
}
};
}
"window" => {
unimplemented!()
@ -165,8 +178,9 @@ impl ObjectImpl for ApplicationObject {
fn property(&self, _obj: &Self::Type, _id: usize, pspec: &ParamSpec) -> Value {
match pspec.name() {
"id" => self.data.borrow().0.id.to_value(),
"name" => self.data.borrow().0.name.to_value(),
"description" => self.data.borrow().0.name.to_value(),
"description" => self.data.borrow().0.description.to_value(),
"icon" => match &self.data.borrow().0.icon {
Some(pop_launcher::IconSource::Name(icon_name)) => {
(pop_launcher::IconSource::Name as i32, icon_name.to_string())

46
examples/launcher/application_object/mod.rs
View file

@ -1,9 +1,9 @@
mod imp;
use gdk4::glib::Object;
use glib::ObjectExt;
use glib::ToVariant;
use gtk4::glib;
use std::cell::RefCell;
use std::rc::Rc;
glib::wrapper! {
pub struct ApplicationObject(ObjectSubclass<imp::ApplicationObject>);
@ -11,8 +11,46 @@ glib::wrapper! {
impl ApplicationObject {
pub fn new(application_search_result: &pop_launcher::SearchResult) -> Self {
Object::new(&[("name", &application_search_result.name)])
.expect("Failed to create `ApplicationObject`.")
let self_: Self = Object::new(&[
("id", &application_search_result.id),
("name", &application_search_result.name),
("description", &application_search_result.description),
])
.expect("Failed to create `ApplicationObject`.");
if let Some(icon) = &application_search_result.icon {
if let Err(e) = self_.set_property(
"icon",
match icon {
pop_launcher::IconSource::Name(name) => {
(pop_launcher::IconSource::Name as i32, name.to_string()).to_variant()
}
pop_launcher::IconSource::Mime(name) => {
(pop_launcher::IconSource::Mime as i32, name.to_string()).to_variant()
}
},
) {
println!("failed to set icon property");
dbg!(e);
};
}
if let Some(icon) = &application_search_result.category_icon {
if let Err(e) = self_.set_property(
"categoryicon",
match icon {
pop_launcher::IconSource::Name(name) => {
(pop_launcher::IconSource::Name as i32, name.to_string()).to_variant()
}
pop_launcher::IconSource::Mime(name) => {
(pop_launcher::IconSource::Mime as i32, name.to_string()).to_variant()
}
},
) {
println!("failed to set category icon property");
dbg!(e);
};
}
self_
}
}

7
examples/gtklauncher/application_row/application_row.ui → examples/launcher/application_row/application_row.ui
View file

@ -6,7 +6,12 @@
<property name="margin-start">4</property>
<property name="margin-end">4</property>
<property name="hexpand">true</property>
<child>
<child>
<object class="GtkImage" id="categoryimage">
<property name="pixel-size">20</property>
</object>
</child>
<child>
<object class="GtkImage" id="image">
<property name="margin-top">4</property>
<property name="margin-bottom">4</property>

2
examples/gtklauncher/application_row/imp.rs → examples/launcher/application_row/imp.rs
View file

@ -16,6 +16,8 @@ pub struct ApplicationRow {
pub shortcut: TemplateChild<gtk::Label>,
#[template_child]
pub image: TemplateChild<gtk::Image>,
#[template_child]
pub categoryimage: TemplateChild<gtk::Image>,
}
#[glib::object_subclass]

79
examples/launcher/application_row/mod.rs Normal file
View file

@ -0,0 +1,79 @@
use crate::icon_source;
use glib::FromVariant;
use glib::Variant;
use gtk4 as gtk;
mod imp;
use crate::ApplicationObject;
use gtk::glib;
use gtk::prelude::*;
use gtk::subclass::prelude::*;
glib::wrapper! {
pub struct ApplicationRow(ObjectSubclass<imp::ApplicationRow>)
@extends gtk::Widget, gtk::Box;
}
impl Default for ApplicationRow {
fn default() -> Self {
Self::new()
}
}
impl ApplicationRow {
pub fn new() -> Self {
glib::Object::new(&[]).expect("Failed to create ApplicationRow")
}
pub fn set_app_info(&self, app_obj: ApplicationObject) {
let self_ = imp::ApplicationRow::from_instance(self);
if let Ok(name) = app_obj.property("name") {
self_.name.set_text(
&name
.get::<String>()
.expect("Property name needs to be a String."),
);
}
if let Ok(desc) = app_obj.property("description") {
self_.description.set_text(
&desc
.get::<String>()
.expect("Property description needs to be a String."),
);
}
if let Ok(icon) = app_obj.property("icon") {
if let Ok(icon) = icon.get::<Variant>() {
let icon = match <(i32, String)>::from_variant(&icon) {
Some((i_type, name)) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
Some((i_type, name)) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
_ => None,
};
icon_source(&self_.image, &icon);
}
}
if let Ok(icon) = app_obj.property("categoryicon") {
if let Ok(icon) = icon.get::<Variant>() {
let icon = match <(i32, String)>::from_variant(&icon) {
Some((i_type, name)) if i_type == pop_launcher::IconSource::Name as i32 => {
Some(pop_launcher::IconSource::Name(name.into()))
}
Some((i_type, name)) if i_type == pop_launcher::IconSource::Mime as i32 => {
Some(pop_launcher::IconSource::Mime(name.into()))
}
_ => None,
};
icon_source(&self_.categoryimage, &icon);
}
}
}
pub fn set_shortcut(&self, indx: u32) {
let self_ = imp::ApplicationRow::from_instance(self);
self_.shortcut.set_text(&format!("Ctrl + {}", indx));
}
}

0
examples/launcher/launcher_row/imp.rs
View file

40
examples/launcher/launcher_row/launcher_row.ui
View file

@ -1,40 +0,0 @@
?xml version="1.0" encoding="UTF-8"?>
<interface>
<template class="ApplicationRow" parent="GtkBox">
<property name="orientation">horizontal</property>
<property name="spacing">12</property>
<child>
<object class="GtkImage" id="image">
<property name="margin-top">6</property>
<property name="margin-bottom">6</property>
<property name="margin-start">6</property>
<property name="margin-end">6</property>
<property name="pixel-size">48</property>
</object>
</child>
<child>
<object class="GtkBox">
<property name="orientation">vertical</property>
<property name="margin-top">6</property>
<property name="margin-bottom">6</property>
<child>
<object class="GtkLabel" id="name">
<property name="halign">start</property>
<style>
<class name="title-4" />
</style>
</object>
</child>
<child>
<object class="GtkLabel" id="description">
<property name="halign">start</property>
<property name="wrap">True</property>
<style>
<class name="body" />
</style>
</object>
</child>
</object>
</child>
</template>
</interface>

0
examples/launcher/launcher_row/mod.rs
View file

264
examples/launcher/main.rs
View file

@ -1,18 +1,22 @@
mod application_object;
mod application_row;
use gio::DesktopAppInfo;
use gtk4 as gtk;
use gtk4::SliceListModel;
use cascade::cascade;
use gtk::gio;
use gtk::prelude::*;
use gtk::{
glib, Application, ApplicationWindow, Label, ListView, PolicyType, ScrolledWindow,
SignalListItemFactory, SingleSelection,
};
use gtk::{glib, ListView, SignalListItemFactory, SingleSelection};
use libcosmic::x;
use std::{cell::RefCell, rc::Rc};
use pop_launcher_service::IpcClient;
use postage::mpsc::Sender;
use postage::prelude::*;
use self::application_object::ApplicationObject;
use self::ipc::LauncherIpc;
mod ipc;
use self::application_row::ApplicationRow;
const NUM_LAUNCHER_ITEMS: u8 = 10;
fn icon_source(icon: &gtk::Image, source: &Option<pop_launcher::IconSource>) {
match source {
@ -28,22 +32,50 @@ fn icon_source(icon: &gtk::Image, source: &Option<pop_launcher::IconSource>) {
}
}
fn main() {
let launcher = Rc::new(RefCell::new(
LauncherIpc::new().expect("failed to connect to launcher service"),
));
enum Event {
Response(pop_launcher::Response),
Search(String),
Activate(u32),
}
fn spawn_launcher(mut tx: Sender<Event>) -> IpcClient {
let (launcher, responses) =
pop_launcher_service::IpcClient::new().expect("failed to connect to launcher service");
glib::MainContext::default().spawn_local(async move {
use futures::StreamExt;
futures::pin_mut!(responses);
while let Some(event) = responses.next().await {
let _ = tx.send(Event::Response(event)).await;
}
});
launcher
}
fn main() {
let app = gtk::Application::builder()
.application_id("com.system76.Launcher")
.build();
app.connect_activate(move |app| {
let (tx, mut rx) = postage::mpsc::channel(1);
let mut launcher = spawn_launcher(tx.clone());
//quit shortcut
app.set_accels_for_action("win.quit", &["<primary>W", "Escape"]);
//launch shortcuts
for i in 1..10 {
app.set_accels_for_action(&format!("win.launch{}", i), &[&format!("<primary>{}", i)]);
}
let window = gtk::ApplicationWindow::builder()
.application(app)
.decorated(false)
.default_width(480)
.default_width(600)
.default_height(440)
.title("Launcher")
.resizable(false)
.build();
let vbox = gtk::Box::new(gtk::Orientation::Vertical, 16);
@ -57,14 +89,11 @@ fn main() {
search.set_placeholder_text(Some(" Type to search apps, or type '?' for more options."));
vbox.append(&search);
let listbox = gtk::ListBox::new();
//vbox.append(&listbox);
let model = gio::ListStore::new(ApplicationObject::static_type());
let factory = SignalListItemFactory::new();
factory.connect_setup(move |_, list_item| {
let label = Label::new(None);
list_item.set_child(Some(&label))
let row = ApplicationRow::new();
list_item.set_child(Some(&row))
});
factory.connect_bind(move |_, list_item| {
let application_object = list_item
@ -72,98 +101,85 @@ fn main() {
.expect("The item has to exist.")
.downcast::<ApplicationObject>()
.expect("The item has to be an `ApplicationObject`");
let name = application_object
.property("name")
.expect("Property name of the wrong type or does not exist!")
.get::<String>()
.expect("Property name needs to be a String.");
let label = list_item
let row = list_item
.child()
.expect("The child has to exist.")
.downcast::<Label>()
.expect("The child has to be a `label`");
label.set_label(&name);
.expect("The list item child needs to exist.")
.downcast::<ApplicationRow>()
.expect("The list item type needs to be `ApplicationRow`");
if list_item.position() < 9 {
row.set_shortcut(list_item.position() + 1);
}
row.set_app_info(application_object);
});
let selection_model = SingleSelection::new(Some(&model));
let slice_model = SliceListModel::new(Some(&model), 0, NUM_LAUNCHER_ITEMS.into());
let selection_model = SingleSelection::new(Some(&slice_model));
let list_view = ListView::new(Some(&selection_model), Some(&factory));
vbox.append(&list_view);
let scroll = cascade! {
gtk::ScrolledWindow::new();
..set_min_content_height(400);
..set_max_content_height(700);
..set_propagate_natural_height(true);
..set_vexpand(true);
..set_policy(gtk::PolicyType::Never, gtk::PolicyType::Automatic);
};
scroll.set_child(Some(&list_view));
vbox.append(&scroll);
for i in 1..10 {
let action_launchi = gio::SimpleAction::new(&format!("launch{}", i), None);
window.add_action(&action_launchi);
action_launchi.connect_activate(
glib::clone!(@weak list_view, @strong tx => move |_action, _parameter| {
println!("acitvating... {}", i);
let model = list_view.model().unwrap();
let app_info = model.item(i - 1);
if app_info.is_none() {
println!("oops no app for this row...");
return;
}
if let Ok(id)= app_info.unwrap().property("id") {
let id = id.get::<u32>().expect("App ID must be u32");
let mut tx = tx.clone();
glib::MainContext::default().spawn_local(async move {
let _ = tx.send(Event::Activate(id)).await;
});
}
}),
);
}
list_view.connect_activate(glib::clone!(@strong tx => move |list_view, i| {
println!("acitvating... {}", i + 1);
let model = list_view.model().unwrap();
let app_info = model.item(i);
if app_info.is_none() {
println!("oops no app for this row...");
return;
}
if let Ok(id)= app_info.unwrap().property("id") {
let id = id.get::<u32>().expect("App ID must be u32");
let mut tx = tx.clone();
glib::MainContext::default().spawn_local(async move {
let _ = tx.send(Event::Activate(id)).await;
});
}
}));
{
let launcher = launcher.clone();
let search_changed = move |search: &gtk::Entry| {
let model_len = model.n_items();
//TODO: is this the best way to clear a listbox?
//while let Some(child) = listbox.last_child() {
// listbox.remove(&child);
//}
let search_changed = glib::clone!(@strong tx => move |search: &gtk::Entry| {
let search = search.text().to_string();
let response_res = launcher
.borrow_mut()
.request(pop_launcher::Request::Search(search.text().to_string()));
println!("{:#?}", response_res);
let num_items = 9;
if let Ok(pop_launcher::Response::Update(results)) = response_res {
let new_results: Vec<glib::Object> = results
[0..std::cmp::min(results.len(), num_items)]
.iter()
.map(|result| ApplicationObject::new(result).upcast())
.collect();
model.splice(0, model_len, &new_results[..]);
// for (i, result) in results[0..std::cmp::min(results.len(), num_items)]
// .iter()
// .enumerate()
// {
// dbg!(result);
// // Limit to 9 results
// // if i >= 9 {
// // break 'result_loop;
// // }
// let row = gtk::ListBoxRow::new();
// listbox.append(&row);
// // Select first row
// if i == 0 {
// listbox.select_row(Some(&row));
// }
// let hbox = gtk::Box::new(gtk::Orientation::Horizontal, 8);
// hbox.set_margin_start(8);
// hbox.set_margin_end(8);
// hbox.set_margin_top(8);
// hbox.set_margin_bottom(8);
// row.set_child(Some(&hbox));
// let category_icon = gtk::Image::new();
// category_icon.set_pixel_size(16);
// icon_source(&category_icon, &result.category_icon);
// hbox.append(&category_icon);
// let icon = gtk::Image::new();
// icon.set_pixel_size(32);
// icon_source(&icon, &result.icon);
// hbox.append(&icon);
// let labels = gtk::Box::new(gtk::Orientation::Vertical, 4);
// hbox.append(&labels);
// let name = gtk::Label::new(Some(&result.name));
// name.set_halign(gtk::Align::Start);
// labels.append(&name);
// let description = gtk::Label::new(Some(&result.description));
// description.set_halign(gtk::Align::Start);
// labels.append(&description);
// }
}
};
search.connect_changed(search_changed.clone());
let mut tx = tx.clone();
glib::MainContext::default().spawn_local(async move {
let _ = tx.send(Event::Search(search)).await;
});
});
search_changed(&search);
search.connect_changed(search_changed);
}
// Setting the window to dialog type must happen between realize and show. Dialog windows
@ -183,8 +199,54 @@ fn main() {
println!("failed to get X11 window");
}
});
let action_quit = gio::SimpleAction::new("quit", None);
action_quit.connect_activate(glib::clone!(@weak window => move |_, _| {
window.close();
}));
window.add_action(&action_quit);
window.connect_is_active_notify(|win| {
if !win.is_active() {
win.close();
}
});
window.show();
glib::MainContext::default().spawn_local(async move {
while let Some(event) = rx.recv().await {
match event {
Event::Search(search) => {
let _ = launcher.send(pop_launcher::Request::Search(search)).await;
}
Event::Activate(index) => {
let _ = launcher.send(pop_launcher::Request::Activate(index)).await;
}
Event::Response(event) => {
if let pop_launcher::Response::Update(results) = event {
let model_len = model.n_items();
dbg!(&results);
let new_results: Vec<glib::Object> = results
[0..std::cmp::min(results.len(), NUM_LAUNCHER_ITEMS.into())]
.iter()
.map(|result| ApplicationObject::new(result).upcast())
.collect();
model.splice(0, model_len, &new_results[..]);
} else if let pop_launcher::Response::DesktopEntry {
path,
gpu_preference: _gpu_preference, // TODO use GPU preference when launching app
} = event
{
let app_info =
DesktopAppInfo::new(&path.file_name().expect("desktop entry path needs to be a valid filename").to_string_lossy())
.expect("failed to create a Desktop App info for launching the application.");
app_info
.launch(&[], Some(&window.display().app_launch_context().clone())).expect("failed to launch the application.");
}
}
}
}
})
});
app.run();

0
examples/gtklauncher/window/imp.rs → examples/launcher/window/imp.rs
View file

0
examples/gtklauncher/window/mod.rs → examples/launcher/window/mod.rs
View file

0
examples/gtklauncher/window/window.ui → examples/launcher/window/window.ui
View file