leyoda/cosmic-files
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rebase on new libcosmic and iced

Browse source
This commit is contained in:
Jeremy Soller 2024-02-09 07:09:51 -07:00
parent 88089fecb4
commit cb4bd84ea5
6 changed files with 611 additions and 654 deletions
Download patch file Download diff file Expand all files Collapse all files

15
src/app.rs
View file

@ -8,7 +8,7 @@ use cosmic::{
iced::{
event,
futures::{self, SinkExt},
keyboard::{Event as KeyEvent, KeyCode, Modifiers},
keyboard::{Event as KeyEvent, Key, Modifiers},
subscription::{self, Subscription},
window, Event, Length, Point,
},
@ -104,7 +104,7 @@ pub enum Message {
Config(Config),
Copy(Option<segmented_button::Entity>),
Cut(Option<segmented_button::Entity>),
Key(Modifiers, KeyCode),
Key(Modifiers, Key),
Modifiers(Modifiers),
MoveToTrash(Option<segmented_button::Entity>),
NewFile(Option<segmented_button::Entity>),
@ -564,10 +564,10 @@ impl Application for App {
Message::Cut(entity_opt) => {
log::warn!("TODO: CUT");
}
Message::Key(modifiers, key_code) => {
Message::Key(modifiers, key) => {
let entity = self.tab_model.active();
for (key_bind, action) in self.key_binds.iter() {
if key_bind.matches(modifiers, key_code) {
if key_bind.matches(modifiers, &key) {
return self.update(action.message(Some(entity)));
}
}
@ -937,10 +937,9 @@ impl Application for App {
let mut subscriptions = vec![
event::listen_with(|event, _status| match event {
Event::Keyboard(KeyEvent::KeyPressed {
key_code,
modifiers,
}) => Some(Message::Key(modifiers, key_code)),
Event::Keyboard(KeyEvent::KeyPressed { key, modifiers, .. }) => {
Some(Message::Key(modifiers, key))
}
Event::Keyboard(KeyEvent::ModifiersChanged(modifiers)) => {
Some(Message::Modifiers(modifiers))
}

47
src/key_bind.rs
View file

@ -1,4 +1,7 @@
use cosmic::iced::keyboard::{KeyCode, Modifiers};
use cosmic::{
iced::keyboard::{Key, Modifiers},
iced_core::keyboard::key::Named,
};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, fmt};
@ -15,12 +18,12 @@ pub enum Modifier {
#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
pub struct KeyBind {
pub modifiers: Vec<Modifier>,
pub key_code: KeyCode,
pub key: Key,
}
impl KeyBind {
pub fn matches(&self, modifiers: Modifiers, key_code: KeyCode) -> bool {
self.key_code == key_code
pub fn matches(&self, modifiers: Modifiers, key: &Key) -> bool {
key == &self.key
&& modifiers.logo() == self.modifiers.contains(&Modifier::Super)
&& modifiers.control() == self.modifiers.contains(&Modifier::Ctrl)
&& modifiers.alt() == self.modifiers.contains(&Modifier::Alt)
@ -33,7 +36,11 @@ impl fmt::Display for KeyBind {
for modifier in self.modifiers.iter() {
write!(f, "{:?} + ", modifier)?;
}
write!(f, "{:?}", self.key_code)
match &self.key {
Key::Character(c) => write!(f, "{}", c.to_uppercase()),
Key::Named(named) => write!(f, "{:?}", named),
other => write!(f, "{:?}", other),
}
}
}
@ -42,30 +49,30 @@ pub fn key_binds() -> HashMap<KeyBind, Action> {
let mut key_binds = HashMap::new();
macro_rules! bind {
([$($modifier:ident),+ $(,)?], $key_code:ident, $action:ident) => {{
([$($modifier:ident),+ $(,)?], $key:expr, $action:ident) => {{
key_binds.insert(
KeyBind {
modifiers: vec![$(Modifier::$modifier),+],
key_code: KeyCode::$key_code,
key: $key,
},
Action::$action,
);
}};
}
bind!([Ctrl], C, Copy);
bind!([Ctrl], X, Cut);
bind!([Alt], Right, HistoryNext);
bind!([Alt], Left, HistoryPrevious);
bind!([Alt], Up, LocationUp);
bind!([Ctrl], V, Paste);
bind!([Ctrl], A, SelectAll);
bind!([Ctrl], W, TabClose);
bind!([Ctrl], T, TabNew);
bind!([Ctrl], Tab, TabNext);
bind!([Ctrl, Shift], Tab, TabPrev);
bind!([Ctrl], Q, WindowClose);
bind!([Ctrl], N, WindowNew);
bind!([Ctrl], Key::Character("c".into()), Copy);
bind!([Ctrl], Key::Character("x".into()), Cut);
bind!([Alt], Key::Named(Named::ArrowRight), HistoryNext);
bind!([Alt], Key::Named(Named::ArrowLeft), HistoryPrevious);
bind!([Alt], Key::Named(Named::ArrowUp), LocationUp);
bind!([Ctrl], Key::Character("v".into()), Paste);
bind!([Ctrl], Key::Character("a".into()), SelectAll);
bind!([Ctrl], Key::Character("w".into()), TabClose);
bind!([Ctrl], Key::Character("t".into()), TabNew);
bind!([Ctrl], Key::Named(Named::Tab), TabNext);
bind!([Ctrl, Shift], Key::Named(Named::Tab), TabPrev);
bind!([Ctrl], Key::Character("q".into()), WindowClose);
bind!([Ctrl], Key::Character("n".into()), WindowNew);
key_binds
}

11
src/menu.rs
View file

@ -2,7 +2,7 @@
use cosmic::{
//TODO: export iced::widget::horizontal_rule in cosmic::widget
iced::{widget::horizontal_rule, Alignment, Background, Length},
iced::{widget::horizontal_rule, Alignment, Background, Border, Length},
theme,
widget::{
self,
@ -85,9 +85,12 @@ pub fn context_menu<'a>(entity: segmented_button::Entity, tab: &Tab) -> Element<
icon_color: Some(component.on.into()),
text_color: Some(component.on.into()),
background: Some(Background::Color(component.base.into())),
border_radius: 8.0.into(),
border_width: 1.0,
border_color: component.divider.into(),
border: Border {
radius: 8.0.into(),
width: 1.0,
color: component.divider.into(),
},
..Default::default()
}
}))
.width(Length::Fixed(240.0))

54
src/mouse_area.rs
View file

@ -4,13 +4,13 @@ use cosmic::iced_core::{
event::{self, Event},
layout, mouse, overlay, renderer, touch,
widget::{tree, Operation, OperationOutputWrapper, Tree},
{Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Widget},
Size, {Clipboard, Element, Layout, Length, Point, Rectangle, Shell, Widget},
};
/// Emit messages on mouse events.
#[allow(missing_debug_implementations)]
pub struct MouseArea<'a, Message, Renderer> {
content: Element<'a, Message, Renderer>,
pub struct MouseArea<'a, Message, Theme, Renderer> {
content: Element<'a, Message, Theme, Renderer>,
on_drag: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
on_press: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
on_release: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
@ -25,7 +25,7 @@ pub struct MouseArea<'a, Message, Renderer> {
on_forward_release: Option<Box<dyn Fn(Option<Point>) -> Message + 'a>>,
}
impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
impl<'a, Message, Theme, Renderer> MouseArea<'a, Message, Theme, Renderer> {
/// The message to emit when a drag is initiated.
#[must_use]
pub fn on_drag(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
@ -85,27 +85,27 @@ impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
self
}
/// The message to emit on a back button press.
/// The message to emit on a back button press.
#[must_use]
pub fn on_back_press(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
self.on_back_press = Some(Box::new(message));
self
}
/// The message to emit on a back button release.
#[must_use]
pub fn on_back_release(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
self.on_back_release = Some(Box::new(message));
self
}
/// The message to emit on a forward button press.
#[must_use]
pub fn on_forward_press(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
self.on_forward_press = Some(Box::new(message));
self
}
/// The message to emit on a forward button release.
#[must_use]
pub fn on_forward_release(mut self, message: impl Fn(Option<Point>) -> Message + 'a) -> Self {
@ -121,9 +121,9 @@ struct State {
drag_initiated: Option<Point>,
}
impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
impl<'a, Message, Theme, Renderer> MouseArea<'a, Message, Theme, Renderer> {
/// Creates a [`MouseArea`] with the given content.
pub fn new(content: impl Into<Element<'a, Message, Renderer>>) -> Self {
pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
MouseArea {
content: content.into(),
on_drag: None,
@ -142,7 +142,8 @@ impl<'a, Message, Renderer> MouseArea<'a, Message, Renderer> {
}
}
impl<'a, Message, Renderer> Widget<Message, Renderer> for MouseArea<'a, Message, Renderer>
impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
for MouseArea<'a, Message, Theme, Renderer>
where
Renderer: renderer::Renderer,
Message: Clone,
@ -163,12 +164,8 @@ where
tree.diff_children(std::slice::from_mut(&mut self.content));
}
fn width(&self) -> Length {
self.content.as_widget().width()
}
fn height(&self) -> Length {
self.content.as_widget().height()
fn size(&self) -> Size<Length> {
self.content.as_widget().size()
}
fn layout(
@ -249,7 +246,7 @@ where
&self,
tree: &Tree,
renderer: &mut Renderer,
theme: &Renderer::Theme,
theme: &Theme,
renderer_style: &renderer::Style,
layout: Layout<'_>,
cursor: mouse::Cursor,
@ -271,28 +268,31 @@ where
tree: &'b mut Tree,
layout: Layout<'_>,
renderer: &Renderer,
) -> Option<overlay::Element<'b, Message, Renderer>> {
) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
self.content
.as_widget_mut()
.overlay(&mut tree.children[0], layout, renderer)
}
}
impl<'a, Message, Renderer> From<MouseArea<'a, Message, Renderer>>
for Element<'a, Message, Renderer>
impl<'a, Message, Theme, Renderer> From<MouseArea<'a, Message, Theme, Renderer>>
for Element<'a, Message, Theme, Renderer>
where
Message: 'a + Clone,
Renderer: 'a + renderer::Renderer,
Theme: 'a,
{
fn from(area: MouseArea<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {
fn from(
area: MouseArea<'a, Message, Theme, Renderer>,
) -> Element<'a, Message, Theme, Renderer> {
Element::new(area)
}
}
/// Processes the given [`Event`] and updates the [`State`] of an [`MouseArea`]
/// accordingly.
fn update<Message: Clone, Renderer>(
widget: &mut MouseArea<'_, Message, Renderer>,
fn update<Message: Clone, Theme, Renderer>(
widget: &mut MouseArea<'_, Message, Theme, Renderer>,
event: &Event,
layout: Layout<'_>,
cursor: mouse::Cursor,
@ -372,7 +372,7 @@ fn update<Message: Clone, Renderer>(
return event::Status::Captured;
}
}
if let Some(message) = widget.on_back_release.as_ref() {
if let Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Back)) = event {
shell.publish(message(cursor.position_in(layout.bounds())));
@ -380,7 +380,7 @@ fn update<Message: Clone, Renderer>(
return event::Status::Captured;
}
}
if let Some(message) = widget.on_forward_press.as_ref() {
if let Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Forward)) = event {
shell.publish(message(cursor.position_in(layout.bounds())));
@ -388,7 +388,7 @@ fn update<Message: Clone, Renderer>(
return event::Status::Captured;
}
}
if let Some(message) = widget.on_forward_release.as_ref() {
if let Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Forward)) = event {
shell.publish(message(cursor.position_in(layout.bounds())));