s3rius/squeekboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into text_input_enable

Browse Source
This commit is contained in:
Dorota Czaplejewicz
2020-01-28 12:39:30 +00:00
parent 585ed5e97d ac360b610f
commit de8aaa1a47
20 changed files with 588 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/data.rs
View File

@ -22,7 +22,7 @@ use ::keyboard::{
};
use ::layout;
use ::layout::ArrangementKind;
use ::logging::PrintWarnings;
use ::logging;
use ::resources;
use ::util::c::as_str;
use ::util::hash_map_map;
@ -32,7 +32,7 @@ use ::xdg;
use serde::Deserialize;
use std::io::BufReader;
use std::iter::FromIterator;
use ::logging::WarningHandler;
use ::logging::Warn;
/// Gathers stuff defined in C or called by C
pub mod c {
@ -158,7 +158,7 @@ fn list_layout_sources(
fn load_layout_data(source: DataSource)
-> Result<::layout::LayoutData, LoadError>
{
let handler = PrintWarnings{};
let handler = logging::Print {};
match source {
DataSource::File(path) => {
Layout::from_file(path.clone())
@ -191,11 +191,13 @@ fn load_layout_data_with_fallback(
(
LoadError::BadData(Error::Missing(e)),
DataSource::File(file)
) => eprintln!( // TODO: print in debug logging level
) => log_print!(
logging::Level::Debug,
"Tried file {:?}, but it's missing: {}",
file, e
),
(e, source) => eprintln!(
(e, source) => log_print!(
logging::Level::Warning,
"Failed to load layout from {}: {}, skipping",
source, e
),
@ -334,7 +336,7 @@ impl Layout {
serde_yaml::from_reader(infile).map_err(Error::Yaml)
}
pub fn build<H: WarningHandler>(self, mut warning_handler: H)
pub fn build<H: logging::Handler>(self, mut warning_handler: H)
-> (Result<::layout::LayoutData, FormattingError>, H)
{
let button_names = self.views.values()
@ -472,7 +474,7 @@ impl Layout {
}
}
fn create_action<H: WarningHandler>(
fn create_action<H: logging::Handler>(
button_info: &HashMap<String, ButtonMeta>,
name: &str,
view_names: Vec<&String>,
@ -502,15 +504,18 @@ fn create_action<H: WarningHandler>(
(None, None, Some(text)) => SubmitData::Text(text.clone()),
(None, None, None) => SubmitData::Text(name.into()),
_ => {
warning_handler.handle(&format!(
"Button {} has more than one of (action, keysym, text)",
name
));
warning_handler.handle(
logging::Level::Warning,
&format!(
"Button {} has more than one of (action, keysym, text)",
name,
),
);
SubmitData::Text("".into())
},
};
fn filter_view_name<H: WarningHandler>(
fn filter_view_name<H: logging::Handler>(
button_name: &str,
view_name: String,
view_names: &Vec<&String>,
@ -519,10 +524,13 @@ fn create_action<H: WarningHandler>(
if view_names.contains(&&view_name) {
view_name
} else {
warning_handler.handle(&format!("Button {} switches to missing view {}",
button_name,
view_name,
));
warning_handler.handle(
logging::Level::Warning,
&format!("Button {} switches to missing view {}",
button_name,
view_name,
),
);
"base".into()
}
}
@ -562,27 +570,24 @@ fn create_action<H: WarningHandler>(
match keysym_valid(keysym.as_str()) {
true => keysym.clone(),
false => {
warning_handler.handle(&format!(
"Keysym name invalid: {}",
keysym,
));
warning_handler.handle(
logging::Level::Warning,
&format!(
"Keysym name invalid: {}",
keysym,
),
);
"space".into() // placeholder
},
}
)),
},
SubmitData::Text(text) => ::action::Action::Submit {
text: {
CString::new(text.clone())
.map_err(|e| {
warning_handler.handle(&format!(
"Text {} contains problems: {:?}",
text,
e
));
e
}).ok()
},
text: CString::new(text.clone()).or_warn(
warning_handler,
logging::Problem::Warning,
&format!("Text {} contains problems", text),
),
keys: text.chars().map(|codepoint| {
let codepoint_string = codepoint.to_string();
::action::KeySym(match keysym_valid(codepoint_string.as_str()) {
@ -596,7 +601,7 @@ fn create_action<H: WarningHandler>(
/// TODO: Since this will receive user-provided data,
/// all .expect() on them should be turned into soft fails
fn create_button<H: WarningHandler>(
fn create_button<H: logging::Handler>(
button_info: &HashMap<String, ButtonMeta>,
outlines: &HashMap<String, Outline>,
name: &str,
@ -620,14 +625,11 @@ fn create_button<H: WarningHandler>(
} else if let Some(text) = &button_meta.text {
::layout::Label::Text(
CString::new(text.as_str())
.unwrap_or_else(|e| {
warning_handler.handle(&format!(
"Text {} is invalid: {}",
text,
e,
));
CString::new("").unwrap()
})
.or_warn(
warning_handler,
logging::Problem::Warning,
&format!("Text {} is invalid", text),
).unwrap_or_else(|| CString::new("").unwrap())
)
} else {
::layout::Label::Text(cname.clone())
@ -638,7 +640,10 @@ fn create_button<H: WarningHandler>(
if outlines.contains_key(outline) {
outline.clone()
} else {
warning_handler.handle(&format!("Outline named {} does not exist! Using default for button {}", outline, name));
warning_handler.handle(
logging::Level::Warning,
&format!("Outline named {} does not exist! Using default for button {}", outline, name)
);
"default".into()
}
}
@ -647,12 +652,11 @@ fn create_button<H: WarningHandler>(
let outline = outlines.get(&outline_name)
.map(|outline| (*outline).clone())
.unwrap_or_else(|| {
warning_handler.handle(
&format!("No default outline defined! Using 1x1!")
);
Outline { width: 1f64, height: 1f64 }
});
.or_warn(
warning_handler,
logging::Problem::Warning,
"No default outline defined! Using 1x1!",
).unwrap_or(Outline { width: 1f64, height: 1f64 });
layout::Button {
name: cname,
@ -672,7 +676,7 @@ mod tests {
use super::*;
use std::error::Error as ErrorTrait;
use ::logging::PanicWarn;
use ::logging::ProblemPanic;
#[test]
fn test_parse_path() {
@ -742,7 +746,7 @@ mod tests {
fn test_layout_punctuation() {
let out = Layout::from_file(PathBuf::from("tests/layout_key1.yaml"))
.unwrap()
.build(PanicWarn).0
.build(ProblemPanic).0
.unwrap();
assert_eq!(
out.views["base"]
@ -757,7 +761,7 @@ mod tests {
fn test_layout_unicode() {
let out = Layout::from_file(PathBuf::from("tests/layout_key2.yaml"))
.unwrap()
.build(PanicWarn).0
.build(ProblemPanic).0
.unwrap();
assert_eq!(
out.views["base"]
@ -773,7 +777,7 @@ mod tests {
fn test_layout_unicode_multi() {
let out = Layout::from_file(PathBuf::from("tests/layout_key3.yaml"))
.unwrap()
.build(PanicWarn).0
.build(ProblemPanic).0
.unwrap();
assert_eq!(
out.views["base"]
@ -788,7 +792,7 @@ mod tests {
#[test]
fn parsing_fallback() {
assert!(Layout::from_resource(FALLBACK_LAYOUT_NAME)
.map(|layout| layout.build(PanicWarn).0.unwrap())
.map(|layout| layout.build(ProblemPanic).0.unwrap())
.is_ok()
);
}
@ -836,7 +840,7 @@ mod tests {
},
".",
Vec::new(),
&mut PanicWarn,
&mut ProblemPanic,
),
::action::Action::Submit {
text: Some(CString::new(".").unwrap()),
@ -849,7 +853,7 @@ mod tests {
fn test_layout_margins() {
let out = Layout::from_file(PathBuf::from("tests/layout_margins.yaml"))
.unwrap()
.build(PanicWarn).0
.build(ProblemPanic).0
.unwrap();
assert_eq!(
out.margins,

54
src/imservice.rs
View File

@ -5,13 +5,16 @@
use std::boxed::Box;
use std::ffi::CString;
use std::fmt;
use std::num::Wrapping;
use std::string::String;
use ::logging;
use ::util::c::into_cstring;
// Traits
use std::convert::TryFrom;
use ::logging::Warn;
/// Gathers stuff defined in C or called by C
@ -95,16 +98,20 @@ pub mod c {
let imservice = check_imservice(imservice, im).unwrap();
imservice.pending = IMProtocolState {
content_hint: {
ContentHint::from_bits(hint).unwrap_or_else(|| {
eprintln!("Warning: received invalid hint flags");
ContentHint::NONE
})
ContentHint::from_bits(hint)
.or_print(
logging::Problem::Warning,
"Received invalid hint flags",
)
.unwrap_or(ContentHint::NONE)
},
content_purpose: {
ContentPurpose::try_from(purpose).unwrap_or_else(|_e| {
eprintln!("Warning: Received invalid purpose value");
ContentPurpose::Normal
})
ContentPurpose::try_from(purpose)
.or_print(
logging::Problem::Warning,
"Received invalid purpose value",
)
.unwrap_or(ContentPurpose::Normal)
},
..imservice.pending.clone()
};
@ -119,10 +126,12 @@ pub mod c {
let imservice = check_imservice(imservice, im).unwrap();
imservice.pending = IMProtocolState {
text_change_cause: {
ChangeCause::try_from(cause).unwrap_or_else(|_e| {
eprintln!("Warning: received invalid cause value");
ChangeCause::InputMethod
})
ChangeCause::try_from(cause)
.or_print(
logging::Problem::Warning,
"Received invalid cause value",
)
.unwrap_or(ChangeCause::InputMethod)
},
..imservice.pending.clone()
};
@ -250,10 +259,17 @@ pub enum ContentPurpose {
Terminal = 13,
}
// Utilities from ::logging need a printable error type
pub struct UnrecognizedValue;
impl fmt::Display for UnrecognizedValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Unrecognized value")
}
}
impl TryFrom<u32> for ContentPurpose {
// There's only one way to fail: number not in protocol,
// so no special error type is needed
type Error = ();
type Error = UnrecognizedValue;
fn try_from(num: u32) -> Result<Self, Self::Error> {
use self::ContentPurpose::*;
match num {
@ -271,7 +287,7 @@ impl TryFrom<u32> for ContentPurpose {
11 => Ok(Time),
12 => Ok(Datetime),
13 => Ok(Terminal),
_ => Err(()),
_ => Err(UnrecognizedValue),
}
}
}
@ -284,14 +300,12 @@ pub enum ChangeCause {
}
impl TryFrom<u32> for ChangeCause {
// There's only one way to fail: number not in protocol,
// so no special error type is needed
type Error = ();
type Error = UnrecognizedValue;
fn try_from(num: u32) -> Result<Self, Self::Error> {
match num {
0 => Ok(ChangeCause::InputMethod),
1 => Ok(ChangeCause::Other),
_ => Err(())
_ => Err(UnrecognizedValue)
}
}
}

8
src/keyboard.rs
View File

@ -9,6 +9,7 @@ use std::rc::Rc;
use std::string::FromUtf8Error;
use ::action::Action;
use ::logging;
// Traits
use std::io::Write;
@ -129,7 +130,12 @@ pub fn generate_keymap(
for (name, state) in keystates.iter() {
match &state.action {
Action::Submit { text: _, keys } => {
if let 0 = keys.len() { eprintln!("Key {} has no keysyms", name); };
if let 0 = keys.len() {
log_print!(
logging::Level::Warning,
"Key {} has no keysyms", name,
);
};
for (named_keysym, keycode) in keys.iter().zip(&state.keycodes) {
write!(
buf,

34
src/layout.rs
View File

@ -20,17 +20,21 @@
use std::cell::RefCell;
use std::collections::{ HashMap, HashSet };
use std::ffi::CString;
use std::fmt;
use std::rc::Rc;
use std::vec::Vec;
use ::action::Action;
use ::drawing;
use ::keyboard::{ KeyState, PressType };
use ::logging;
use ::manager;
use ::submission::{ Submission, Timestamp };
use ::util::find_max_double;
// Traits
use std::borrow::Borrow;
use ::logging::Warn;
/// Gathers stuff defined in C or called by C
pub mod c {
@ -628,6 +632,12 @@ pub struct LayoutData {
#[derive(Debug)]
struct NoSuchView;
impl fmt::Display for NoSuchView {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "No such view")
}
}
// Unfortunately, changes are not atomic due to mutability :(
// An error will not be recoverable
// The usage of &mut on Rc<RefCell<KeyState>> doesn't mean anything special.
@ -793,9 +803,10 @@ mod seat {
fn try_set_view(layout: &mut Layout, view_name: String) {
layout.set_view(view_name.clone())
.map_err(|e|
eprintln!("Bad view {} ({:?}), ignoring", view_name, e)
).ok();
.or_print(
logging::Problem::Bug,
&format!("Bad view {}, ignoring", view_name),
);
}
/// A vessel holding an obligation to switch view.
@ -837,9 +848,10 @@ mod seat {
Action::LockView { lock: _, unlock: view } => {
new_view = Some(view.clone());
},
a => eprintln!(
"BUG: action {:?} was found inside locked keys",
a
a => log_print!(
logging::Level::Bug,
"Non-locking action {:?} was found inside locked keys",
a,
),
};
key.locked = false;
@ -858,7 +870,10 @@ mod seat {
rckey: &Rc<RefCell<KeyState>>,
) {
if !layout.pressed_keys.insert(::util::Pointer(rckey.clone())) {
eprintln!("Warning: key {:?} was already pressed", rckey);
log_print!(
logging::Level::Bug,
"Key {:?} was already pressed", rckey,
);
}
let mut key = rckey.borrow_mut();
submission.handle_press(&key, KeyState::get_id(rckey), time);
@ -936,7 +951,10 @@ mod seat {
}
}
},
Action::SetModifier(_) => eprintln!("Modifiers unsupported"),
Action::SetModifier(_) => log_print!(
logging::Level::Bug,
"Modifiers unsupported",
),
};
let pointer = ::util::Pointer(rckey.clone());

4
src/lib.rs
View File

@ -15,6 +15,9 @@ extern crate regex;
extern crate serde;
extern crate xkbcommon;
#[macro_use]
mod logging;
mod action;
pub mod data;
mod drawing;
@ -24,7 +27,6 @@ mod keyboard;
mod layout;
mod locale;
mod locale_config;
mod logging;
mod manager;
mod outputs;
mod popover;

88
src/locale.rs
View File

@ -1,24 +1,106 @@
/*! Locale-specific functions */
/*! Locale-specific functions.
*
* This file is intended as a library:
* it must pass errors upwards
* and panicking is allowed only when
* this code encounters an internal inconsistency.
*/
use std::cmp;
use std::ffi::CString;
use std::ffi::{ CStr, CString };
use std::fmt;
use std::os::raw::c_char;
use std::ptr;
use std::str::Utf8Error;
mod c {
use std::os::raw::c_char;
use super::*;
use std::os::raw::c_void;
#[allow(non_camel_case_types)]
pub type c_int = i32;
#[derive(Clone, Copy)]
#[repr(C)]
pub struct GnomeXkbInfo(*const c_void);
#[no_mangle]
extern "C" {
// from libc
pub fn strcoll(cs: *const c_char, ct: *const c_char) -> c_int;
// from gnome-desktop3
pub fn gnome_xkb_info_new() -> GnomeXkbInfo;
pub fn gnome_xkb_info_get_layout_info (
info: GnomeXkbInfo,
id: *const c_char,
display_name: *mut *const c_char,
short_name: *const *const c_char,
xkb_layout: *const *const c_char,
xkb_variant: *const *const c_char
) -> c_int;
pub fn g_object_unref(o: GnomeXkbInfo);
}
}
#[derive(Debug)]
pub enum Error {
StringConversion(Utf8Error),
NoInfo,
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
pub struct XkbInfo(c::GnomeXkbInfo);
impl XkbInfo {
pub fn new() -> XkbInfo {
XkbInfo(unsafe { c::gnome_xkb_info_new() })
}
pub fn get_display_name(&self, id: &str) -> Result<String, Error> {
let id = cstring_safe(id);
let id_ref = id.as_ptr();
let mut display_name: *const c_char = ptr::null();
let found = unsafe {
c::gnome_xkb_info_get_layout_info(
self.0,
id_ref,
&mut display_name as *mut *const c_char,
ptr::null(), ptr::null(), ptr::null(),
)
};
if found != 0 && !display_name.is_null() {
let display_name = unsafe { CStr::from_ptr(display_name) };
display_name.to_str()
.map(str::to_string)
.map_err(Error::StringConversion)
} else {
Err(Error::NoInfo)
}
}
}
impl Drop for XkbInfo {
fn drop(&mut self) {
unsafe { c::g_object_unref(self.0) }
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Translation<'a>(pub &'a str);
impl<'a> Translation<'a> {
pub fn to_owned(&'a self) -> OwnedTranslation {
OwnedTranslation(self.0.to_owned())
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct OwnedTranslation(pub String);
fn cstring_safe(s: &str) -> CString {
CString::new(s)
.unwrap_or(CString::new("").unwrap())

135
src/logging.rs
View File

@ -26,13 +26,15 @@
* 4. logging to an immutable destination type
*
* Same as above, except it can be parallelized.
* Logs being outputs, they get returned
* instead of being misleadingly passed back through arguments.
* It seems more difficult to pass the logger around,
* but this may be a solved problem from the area of functional programming.
*
* This library generally aims at the approach in 3.
* */
use std::error::Error;
use std::fmt::Display;
/// Levels are not in order.
pub enum Level {
@ -66,45 +68,134 @@ pub enum Level {
Debug,
}
/// Sugar for logging errors in results.
/// Approach 2.
pub trait Warn {
type Value;
fn ok_warn(self, msg: &str) -> Option<Self::Value>;
impl Level {
fn as_str(&self) -> &'static str {
match self {
Level::Panic => "Panic",
Level::Bug => "Bug",
Level::Error => "Error",
Level::Warning => "Warning",
Level::Surprise => "Surprise",
Level::Info => "Info",
Level::Debug => "Debug",
}
}
}
impl<T, E: Error> Warn for Result<T, E> {
impl From<Problem> for Level {
fn from(problem: Problem) -> Level {
use self::Level::*;
match problem {
Problem::Panic => Panic,
Problem::Bug => Bug,
Problem::Error => Error,
Problem::Warning => Warning,
Problem::Surprise => Surprise,
}
}
}
/// Only levels which indicate problems
/// To use with `Result::Err` handlers,
/// which are needed only when something went off the optimal path.
/// A separate type ensures that `Err`
/// can't end up misclassified as a benign event like `Info`.
pub enum Problem {
Panic,
Bug,
Error,
Warning,
Surprise,
}
/// Sugar for approach 2
// TODO: avoid, deprecate.
// Handler instances should be long lived, not one per call.
macro_rules! log_print {
($level:expr, $($arg:tt)*) => (::logging::print($level, &format!($($arg)*)))
}
/// Approach 2
pub fn print(level: Level, message: &str) {
Print{}.handle(level, message)
}
/// Sugar for logging errors in results.
pub trait Warn where Self: Sized {
type Value;
/// Approach 2.
fn or_print(self, level: Problem, message: &str) -> Option<Self::Value> {
self.or_warn(&mut Print {}, level.into(), message)
}
/// Approach 3.
fn or_warn<H: Handler>(
self,
handler: &mut H,
level: Problem,
message: &str,
) -> Option<Self::Value>;
}
impl<T, E: Display> Warn for Result<T, E> {
type Value = T;
fn ok_warn(self, msg: &str) -> Option<T> {
fn or_warn<H: Handler>(
self,
handler: &mut H,
level: Problem,
message: &str,
) -> Option<T> {
self.map_err(|e| {
eprintln!("{}: {}", msg, e);
handler.handle(level.into(), &format!("{}: {}", message, e));
e
}).ok()
}
}
impl<T> Warn for Option<T> {
type Value = T;
fn or_warn<H: Handler>(
self,
handler: &mut H,
level: Problem,
message: &str,
) -> Option<T> {
self.or_else(|| {
handler.handle(level.into(), message);
None
})
}
}
/// A mutable handler for text warnings.
/// Approach 3.
pub trait WarningHandler {
/// Handle a warning
fn handle(&mut self, warning: &str);
pub trait Handler {
/// Handle a log message
fn handle(&mut self, level: Level, message: &str);
}
/// Prints warnings to stderr
pub struct PrintWarnings;
/// Prints info to stdout, everything else to stderr
pub struct Print;
impl WarningHandler for PrintWarnings {
fn handle(&mut self, warning: &str) {
eprintln!("{}", warning);
impl Handler for Print {
fn handle(&mut self, level: Level, message: &str) {
match level {
Level::Info => println!("Info: {}", message),
l => eprintln!("{}: {}", l.as_str(), message),
}
}
}
/// Warning handler that will panic at any warning.
/// Warning handler that will panic
/// at any warning, error, surprise, bug, or panic.
/// Don't use except in tests
pub struct PanicWarn;
pub struct ProblemPanic;
impl WarningHandler for PanicWarn {
fn handle(&mut self, warning: &str) {
panic!("{}", warning);
impl Handler for ProblemPanic {
fn handle(&mut self, level: Level, message: &str) {
use self::Level::*;
match level {
Panic | Bug | Error | Warning | Surprise => panic!("{}", message),
l => Print{}.handle(l, message),
}
}
}

1
src/meson.build
View File

@ -36,6 +36,7 @@ cc = meson.get_compiler('c')
deps = [
# dependency('glib-2.0', version: '>=2.26.0'),
dependency('gio-2.0', version: '>=2.26.0'),
dependency('gnome-desktop-3.0', version: '>=3.0'),
dependency('gtk+-3.0', version: '>=3.0'),
dependency('libcroco-0.6'),
dependency('wayland-client', version: '>=1.14'),

51
src/outputs.rs
View File

@ -1,7 +1,10 @@
/*! Managing Wayland outputs */
use std::vec::Vec;
use ::logging;
// traits
use ::logging::Warn;
/// Gathers stuff defined in C or called by C
pub mod c {
@ -113,14 +116,11 @@ pub mod c {
_make: *const c_char, _model: *const c_char,
transform: i32,
) {
let transform = Transform::from_u32(transform as u32).unwrap_or_else(
|| {
eprintln!(
"Warning: received invalid wl_output.transform value"
);
Transform::Normal
}
);
let transform = Transform::from_u32(transform as u32)
.or_print(
logging::Problem::Warning,
"Received invalid wl_output.transform value",
).unwrap_or(Transform::Normal);
let outputs = outputs.clone_ref();
let mut collection = outputs.borrow_mut();
@ -129,7 +129,10 @@ pub mod c {
.map(|o| &mut o.pending);
match output_state {
Some(state) => { state.transform = Some(transform) },
None => eprintln!("Wayland error: Got mode on unknown output"),
None => log_print!(
logging::Level::Warning,
"Got geometry on unknown output",
),
};
}
@ -141,10 +144,12 @@ pub mod c {
height: i32,
_refresh: i32,
) {
let flags = Mode::from_bits(flags).unwrap_or_else(|| {
eprintln!("Warning: received invalid wl_output.mode flags");
Mode::NONE
});
let flags = Mode::from_bits(flags)
.or_print(
logging::Problem::Warning,
"Received invalid wl_output.mode flags",
).unwrap_or(Mode::NONE);
let outputs = outputs.clone_ref();
let mut collection = outputs.borrow_mut();
let output_state: Option<&mut OutputState>
@ -156,7 +161,10 @@ pub mod c {
state.current_mode = Some(super::Mode { width, height});
}
},
None => eprintln!("Wayland error: Got mode on unknown output"),
None => log_print!(
logging::Level::Warning,
"Got mode on unknown output",
),
};
}
@ -169,7 +177,10 @@ pub mod c {
let output = find_output_mut(&mut collection, wl_output);
match output {
Some(output) => { output.current = output.pending.clone(); }
None => eprintln!("Wayland error: Got done on unknown output"),
None => log_print!(
logging::Level::Warning,
"Got done on unknown output",
),
};
}
@ -185,7 +196,10 @@ pub mod c {
.map(|o| &mut o.pending);
match output_state {
Some(state) => { state.scale = factor; }
None => eprintln!("Wayland error: Got done on unknown output"),
None => log_print!(
logging::Level::Warning,
"Got scale on unknown output",
),
};
}
@ -258,7 +272,10 @@ pub mod c {
}
},
_ => {
eprintln!("Not enough info registered on output");
log_print!(
logging::Level::Surprise,
"Not enough info received on output",
);
0
},
}

132
src/popover.rs
View File

@ -4,8 +4,10 @@ use gio;
use gtk;
use std::ffi::CString;
use ::layout::c::{ Bounds, EekGtkKeyboard };
use ::locale::{ Translation, compare_current_locale };
use ::locale;
use ::locale::{ OwnedTranslation, Translation, compare_current_locale };
use ::locale_config::system_locale;
use ::logging;
use ::manager;
use ::resources;
@ -17,6 +19,7 @@ use glib::variant::ToVariant;
use gtk::PopoverExt;
use gtk::WidgetExt;
use std::io::Write;
use ::logging::Warn;
mod variants {
use glib;
@ -94,7 +97,7 @@ mod variants {
}
}
fn make_menu_builder(inputs: Vec<(&str, Translation)>) -> gtk::Builder {
fn make_menu_builder(inputs: Vec<(&str, OwnedTranslation)>) -> gtk::Builder {
let mut xml: Vec<u8> = Vec::new();
writeln!(
xml,
@ -194,6 +197,81 @@ fn get_current_layout(
}
}
/// Translates all provided layout names according to current locale,
/// for the purpose of display (i.e. errors will be caught and reported)
fn translate_layout_names(layouts: &Vec<LayoutId>) -> Vec<OwnedTranslation> {
// This procedure is rather ugly...
// Xkb lookup *must not* be applied to non-system layouts,
// so both translators can't be merged into one lookup table,
// therefore must be done in two steps.
// `XkbInfo` being temporary also means
// that its return values must be copied,
// forcing the use of `OwnedTranslation`.
enum Status {
/// xkb names should get all translated here
Translated(OwnedTranslation),
/// Builtin names need builtin translations
Remaining(String),
}
// Attempt to take all xkb names from gnome-desktop's xkb info.
let xkb_translator = locale::XkbInfo::new();
let translated_names = layouts.iter()
.map(|id| match id {
LayoutId::System { name, kind: _ } => {
xkb_translator.get_display_name(name)
.map(|s| Status::Translated(OwnedTranslation(s)))
.or_print(
logging::Problem::Surprise,
&format!("No display name for xkb layout {}", name),
).unwrap_or_else(|| Status::Remaining(name.clone()))
},
LayoutId::Local(name) => Status::Remaining(name.clone()),
});
// Non-xkb layouts and weird xkb layouts
// still need to be looked up in the internal database.
let builtin_translations = system_locale()
.map(|locale|
locale.tags_for("messages")
.next().unwrap() // guaranteed to exist
.as_ref()
.to_owned()
)
.or_print(logging::Problem::Surprise, "No locale detected")
.and_then(|lang| {
resources::get_layout_names(lang.as_str())
.or_print(
logging::Problem::Surprise,
&format!("No translations for locale {}", lang),
)
});
match builtin_translations {
Some(translations) => {
translated_names
.map(|status| match status {
Status::Remaining(name) => {
translations.get(name.as_str())
.unwrap_or(&Translation(name.as_str()))
.to_owned()
},
Status::Translated(t) => t,
})
.collect()
},
None => {
translated_names
.map(|status| match status {
Status::Remaining(name) => OwnedTranslation(name),
Status::Translated(t) => t,
})
.collect()
},
}
}
pub fn show(
window: EekGtkKeyboard,
position: Bounds,
@ -218,46 +296,21 @@ pub fn show(
.chain(overlay_layouts)
.collect();
let translations = system_locale()
.map(|locale|
locale.tags_for("messages")
.next().unwrap() // guaranteed to exist
.as_ref()
.to_owned()
)
.and_then(|lang| resources::get_layout_names(lang.as_str()));
let translated_names = all_layouts.iter()
.map(LayoutId::get_name);
let translated_names: Vec<Translation> = match translations {
Some(translations) => {
translated_names
.map(move |name| {
translations.get(name)
.map(|translation| translation.clone())
.unwrap_or(Translation(name))
})
.collect()
},
None => {
translated_names.map(|name| Translation(name))
.collect()
},
};
let translated_names = translate_layout_names(&all_layouts);
// sorted collection of human and machine names
let mut human_names: Vec<(Translation, LayoutId)> = translated_names
let mut human_names: Vec<(OwnedTranslation, LayoutId)> = translated_names
.into_iter()
.zip(all_layouts.clone().into_iter())
.collect();
human_names.sort_unstable_by(|(tr_a, _), (tr_b, _)| {
compare_current_locale(tr_a.0, tr_b.0)
compare_current_locale(&tr_a.0, &tr_b.0)
});
// GVariant doesn't natively support `enum`s,
// so the `choices` vector will serve as a lookup table.
let choices_with_translations: Vec<(String, (Translation, LayoutId))>
let choices_with_translations: Vec<(String, (OwnedTranslation, LayoutId))>
= human_names.into_iter()
.enumerate()
.map(|(i, human_entry)| {(
@ -268,7 +321,7 @@ pub fn show(
let builder = make_menu_builder(
choices_with_translations.iter()
.map(|(id, (translation, _))| (id.as_str(), translation.clone()))
.map(|(id, (translation, _))| (id.as_str(), (*translation).clone()))
.collect()
);
@ -308,10 +361,10 @@ pub fn show(
match state {
Some(v) => {
v.get::<String>()
.or_else(|| {
eprintln!("Variant is not string: {:?}", v);
None
})
.or_print(
logging::Problem::Bug,
&format!("Variant is not string: {:?}", v)
)
.map(|state| {
let (_id, layout) = choices.iter()
.find(
@ -323,7 +376,10 @@ pub fn show(
)
});
},
None => eprintln!("No variant selected"),
None => log_print!(
logging::Level::Debug,
"No variant selected",
),
};
menu_inner.popdown();
});

5
src/resources.rs
View File

@ -11,6 +11,7 @@ use std::iter::FromIterator;
// and what a convenience layout. "_wide" is not a layout,
// neither is "number"
const KEYBOARDS: &[(*const str, *const str)] = &[
// layouts
("us", include_str!("../data/keyboards/us.yaml")),
("us_wide", include_str!("../data/keyboards/us_wide.yaml")),
("de", include_str!("../data/keyboards/de.yaml")),
@ -24,6 +25,7 @@ const KEYBOARDS: &[(*const str, *const str)] = &[
("no", include_str!("../data/keyboards/no.yaml")),
("number", include_str!("../data/keyboards/number.yaml")),
("se", include_str!("../data/keyboards/se.yaml")),
// layout+overlay
("terminal", include_str!("../data/keyboards/terminal.yaml")),
// Overlays
("emoji", include_str!("../data/keyboards/emoji.yaml")),
@ -44,7 +46,8 @@ pub fn get_keyboard(needle: &str) -> Option<&'static str> {
}
const OVERLAY_NAMES: &[*const str] = &[
"emoji"
"emoji",
"terminal",
];
pub fn get_overlays() -> Vec<&'static str> {

2
src/server-main.c
View File

@ -67,9 +67,11 @@ on_name_lost (GDBusConnection *connection,
gpointer user_data)
{
// TODO: could conceivable continue working
// if intrnal changes stop sending dbus changes
(void)connection;
(void)name;
(void)user_data;
g_error("DBus unavailable, unclear how to continue.");
exit (1);
}

13
src/style.rs
View File

@ -16,9 +16,10 @@
* License along with this library. If not, see <http://www.gnu.org/licenses/>.Free
*/
/*! CSS data loading */
/*! CSS data loading. */
use std::env;
use ::logging;
use glib::object::ObjectExt;
use logging::Warn;
@ -83,7 +84,11 @@ fn get_theme_name(settings: &gtk::Settings) -> GtkTheme {
.map_err(|e| {
match &e {
env::VarError::NotPresent => {},
e => eprintln!("GTK_THEME variable invalid: {}", e),
// maybe TODO: forward this warning?
e => log_print!(
logging::Level::Surprise,
"GTK_THEME variable invalid: {}", e,
),
};
e
}).ok();
@ -93,13 +98,13 @@ fn get_theme_name(settings: &gtk::Settings) -> GtkTheme {
None => GtkTheme {
name: {
settings.get_property("gtk-theme-name")
.ok_warn("No theme name")
.or_print(logging::Problem::Surprise, "No theme name")
.and_then(|value| value.get::<String>())
.unwrap_or(DEFAULT_THEME_NAME.into())
},
variant: {
settings.get_property("gtk-application-prefer-dark-theme")
.ok_warn("No settings key")
.or_print(logging::Problem::Surprise, "No settings key")
.and_then(|value| value.get::<bool>())
.and_then(|dark_preferred| match dark_preferred {
true => Some("dark".into()),

19
src/tests.rs
View File

@ -1,17 +1,22 @@
/*! Testing functionality */
use ::data::Layout;
use ::logging;
use xkbcommon::xkb;
use ::logging::WarningHandler;
pub struct CountAndPrint(u32);
impl WarningHandler for CountAndPrint {
fn handle(&mut self, warning: &str) {
self.0 = self.0 + 1;
println!("{}", warning);
impl logging::Handler for CountAndPrint {
fn handle(&mut self, level: logging::Level, warning: &str) {
use logging::Level::*;
match level {
Panic | Bug | Error | Warning | Surprise => {
self.0 += 1;
},
_ => {}
}
logging::Print{}.handle(level, warning)
}
}
@ -34,7 +39,7 @@ fn check_layout(layout: Layout) {
let (layout, handler) = layout.build(handler);
if handler.0 > 0 {
println!("{} mistakes in layout", handler.0)
println!("{} problems while parsing layout", handler.0)
}
let layout = layout.expect("layout broken");

5
src/util.rs
View File

@ -190,6 +190,11 @@ impl<T> Borrow<Rc<T>> for Pointer<T> {
}
}
pub trait WarningHandler {
/// Handle a warning
fn handle(&mut self, warning: &str);
}
#[cfg(test)]
mod tests {
use super::*;