mslot
/
alacritty
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Normalize Log Message Strings 

The general style for errors, warnings and info messages is to start
with a capitalized letter and end without a period. The main exception
is when dealing with nouns that are clearer with special case handling,
e.g. "macOS failed to work" or "ioctl is borked".
This commit is contained in:
Nathan Lilienthal 2019-01-06 19:06:57 -05:00 committed by Christian Duerr
parent dfc30eeef5
commit 04707cbba6
21 changed files with 197 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Changed ### Changed
- Log messages are now consistent in style, and some have been removed
- Windows configuration location has been moved from %USERPROFILE%\alacritty.yml - Windows configuration location has been moved from %USERPROFILE%\alacritty.yml
to %APPDATA%\alacritty\alacritty.yml to %APPDATA%\alacritty\alacritty.yml
- Windows default shell is now PowerShell instead of cmd - Windows default shell is now PowerShell instead of cmd

2
copypasta/src/windows.rs
View File

@ -13,7 +13,7 @@ pub enum Error {
impl ::std::error::Error for Error { impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::Clipboard(..) => "error opening clipboard", Error::Clipboard(..) => "Error opening clipboard",
} }
} }
} }

12
copypasta/src/x11.rs
View File

@ -35,9 +35,9 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::Io(..) => "error calling xclip", Error::Io(..) => "Error calling xclip",
Error::Xclip(..) => "error reported by xclip", Error::Xclip(..) => "Error reported by xclip",
Error::Utf8(..) => "clipboard contents not utf8", Error::Utf8(..) => "Clipboard contents not utf8",
} }
} }
} }
@ -50,11 +50,11 @@ impl ::std::fmt::Display for Error {
io::ErrorKind::NotFound => { io::ErrorKind::NotFound => {
write!(f, "Please install `xclip` to enable clipboard support") write!(f, "Please install `xclip` to enable clipboard support")
}, },
_ => write!(f, "error calling xclip: {}", err), _ => write!(f, "Error calling xclip: {}", err),
} }
}, },
Error::Xclip(ref s) => write!(f, "error from xclip: {}", s), Error::Xclip(ref s) => write!(f, "Error from xclip: {}", s),
Error::Utf8(ref err) => write!(f, "error parsing xclip output: {}", err), Error::Utf8(ref err) => write!(f, "Error parsing xclip output: {}", err),
} }
} }
} }

11
font/src/darwin/mod.rs
View File

@ -101,9 +101,9 @@ pub enum Error {
impl ::std::error::Error for Error { impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::MissingGlyph(ref _c) => "couldn't find the requested glyph", Error::MissingGlyph(ref _c) => "Couldn't find the requested glyph",
Error::MissingFont(ref _desc) => "couldn't find the requested font", Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded", Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
} }
} }
} }
@ -129,7 +129,6 @@ impl ::Rasterize for Rasterizer {
type Err = Error; type Err = Error;
fn new(device_pixel_ratio: f32, use_thin_strokes: bool) -> Result<Rasterizer, Error> { fn new(device_pixel_ratio: f32, use_thin_strokes: bool) -> Result<Rasterizer, Error> {
info!("device_pixel_ratio: {}", device_pixel_ratio);
Ok(Rasterizer { Ok(Rasterizer {
fonts: HashMap::new(), fonts: HashMap::new(),
keys: HashMap::new(), keys: HashMap::new(),
@ -332,7 +331,7 @@ fn cascade_list_for_languages(
pub fn descriptors_for_family(family: &str) -> Vec<Descriptor> { pub fn descriptors_for_family(family: &str) -> Vec<Descriptor> {
let mut out = Vec::new(); let mut out = Vec::new();
info!("family: {}", family); trace!("Family: {}", family);
let ct_collection = match create_for_family(family) { let ct_collection = match create_for_family(family) {
Some(c) => c, Some(c) => c,
None => return out, None => return out,
@ -627,7 +626,7 @@ mod tests {
fn get_descriptors_and_build_font() { fn get_descriptors_and_build_font() {
let list = super::descriptors_for_family("Menlo"); let list = super::descriptors_for_family("Menlo");
assert!(!list.is_empty()); assert!(!list.is_empty());
info!("{:?}", list); println!("{:?}", list);
// Check to_font // Check to_font
let fonts = list.iter() let fonts = list.iter()

4
font/src/ft/fc/font_set.rs
View File

@ -63,7 +63,7 @@ impl<'a> IntoIterator for &'a FontSet {
(*self.as_ptr()).nfont as isize (*self.as_ptr()).nfont as isize
}; };
info!("num fonts = {}", num_fonts); trace!("Number of fonts is {}", num_fonts);
Iter { Iter {
font_set: self.deref(), font_set: self.deref(),
@ -81,7 +81,7 @@ impl<'a> IntoIterator for &'a FontSetRef {
(*self.as_ptr()).nfont as isize (*self.as_ptr()).nfont as isize
}; };
info!("num fonts = {}", num_fonts); trace!("Number of fonts is {}", num_fonts);
Iter { Iter {
font_set: self, font_set: self,

14
font/src/ft/mod.rs
View File

@ -117,7 +117,7 @@ impl ::Rasterize for FreeTypeRasterizer {
}, },
_ => { _ => {
// Fallback if font doesn't provide info about strikeout // Fallback if font doesn't provide info about strikeout
trace!("No strikeout data available for font, using fallback."); trace!("Using fallback strikeout metrics");
let strikeout_position = height as f32 / 2. + descent; let strikeout_position = height as f32 / 2. + descent;
(strikeout_position, underline_thickness) (strikeout_position, underline_thickness)
}, },
@ -267,7 +267,7 @@ impl FreeTypeRasterizer {
return Ok(Some(*key)); return Ok(Some(*key));
} }
trace!("got font path={:?}", path); trace!("Got font path={:?}", path);
let ft_face = self.library.new_face(&path, index)?; let ft_face = self.library.new_face(&path, index)?;
// Get available pixel sizes if font isn't scalable. // Get available pixel sizes if font isn't scalable.
@ -550,12 +550,12 @@ impl FreeTypeRasterizer {
// We've previously loaded this font, so don't // We've previously loaded this font, so don't
// load it again. // load it again.
Some(&key) => { Some(&key) => {
debug!("Hit for font {:?}; no need to load.", path); debug!("Hit for font {:?}; no need to load", path);
Ok(key) Ok(key)
}, },
None => { None => {
debug!("Miss for font {:?}; loading now.", path); debug!("Miss for font {:?}; loading now", path);
// Safe to unwrap the option since we've already checked for the path // Safe to unwrap the option since we've already checked for the path
// and index above. // and index above.
let key = self.face_from_pattern(&pattern)?.unwrap(); let key = self.face_from_pattern(&pattern)?.unwrap();
@ -604,9 +604,9 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::FreeType(ref err) => err.description(), Error::FreeType(ref err) => err.description(),
Error::MissingFont(ref _desc) => "couldn't find the requested font", Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded", Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
Error::MissingSizeMetrics => "tried to get size metrics from a face without a size", Error::MissingSizeMetrics => "Tried to get size metrics from a face without a size",
} }
} }
} }

2
font/src/lib.rs
View File

@ -132,7 +132,7 @@ impl FontDesc {
impl fmt::Display for FontDesc { impl fmt::Display for FontDesc {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "name '{}' and style '{}'", self.name, self.style) write!(f, "name {} and style {}", self.name, self.style)
} }
} }

8
font/src/rusttype/mod.rs
View File

@ -166,10 +166,10 @@ pub enum Error {
impl ::std::error::Error for Error { impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::MissingFont(ref _desc) => "couldn't find the requested font", Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::UnsupportedFont => "only TrueType fonts are supported", Error::UnsupportedFont => "Only TrueType fonts are supported",
Error::UnsupportedStyle => "the selected style is not supported by rusttype", Error::UnsupportedStyle => "The selected style is not supported by rusttype",
Error::MissingGlyph => "the selected font did not have the requested glyph", Error::MissingGlyph => "The selected font does not have the requested glyph",
} }
} }
} }

2
src/ansi.rs
View File

@ -445,7 +445,7 @@ impl Mode {
1049 => Mode::SwapScreenAndSetRestoreCursor, 1049 => Mode::SwapScreenAndSetRestoreCursor,
2004 => Mode::BracketedPaste, 2004 => Mode::BracketedPaste,
_ => { _ => {
trace!("[unhandled] mode={:?}", num); trace!("[unimplemented] primitive mode: {}", num);
return None return None
} }
}) })

108
src/config.rs
View File

@ -73,7 +73,7 @@ fn deserialize_duration_ms<'a, D>(deserializer: D) -> ::std::result::Result<Dura
match u64::deserialize(deserializer) { match u64::deserialize(deserializer) {
Ok(threshold_ms) => Ok(Duration::from_millis(threshold_ms)), Ok(threshold_ms) => Ok(Duration::from_millis(threshold_ms)),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(default_threshold_ms()) Ok(default_threshold_ms())
}, },
} }
@ -171,7 +171,7 @@ fn deserialize_visual_bell_duration<'a, D>(deserializer: D) -> ::std::result::Re
match u16::deserialize(deserializer) { match u16::deserialize(deserializer) {
Ok(duration) => Ok(duration), Ok(duration) => Ok(duration),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(0) Ok(0)
}, },
} }
@ -320,19 +320,19 @@ impl<'de> Deserialize<'de> for Decorations {
"none" => Ok(Decorations::None), "none" => Ok(Decorations::None),
"full" => Ok(Decorations::Full), "full" => Ok(Decorations::Full),
"true" => { "true" => {
error!("deprecated decorations boolean value, \ error!("Deprecated decorations boolean value, \
use one of transparent|buttonless|none|full instead; \ use one of transparent|buttonless|none|full instead; \
Falling back to \"full\""); falling back to \"full\"");
Ok(Decorations::Full) Ok(Decorations::Full)
}, },
"false" => { "false" => {
error!("deprecated decorations boolean value, \ error!("Deprecated decorations boolean value, \
use one of transparent|buttonless|none|full instead; \ use one of transparent|buttonless|none|full instead; \
Falling back to \"none\""); falling back to \"none\"");
Ok(Decorations::None) Ok(Decorations::None)
}, },
_ => { _ => {
error!("invalid decorations value: {}; Using default value", value); error!("Invalid decorations value: {}; using default value", value);
Ok(Decorations::Full) Ok(Decorations::Full)
} }
} }
@ -346,23 +346,23 @@ impl<'de> Deserialize<'de> for Decorations {
"none" => Ok(Decorations::None), "none" => Ok(Decorations::None),
"full" => Ok(Decorations::Full), "full" => Ok(Decorations::Full),
"true" => { "true" => {
error!("deprecated decorations boolean value, \ error!("Deprecated decorations boolean value, \
use one of none|full instead; \ use one of none|full instead; \
Falling back to \"full\""); falling back to \"full\"");
Ok(Decorations::Full) Ok(Decorations::Full)
}, },
"false" => { "false" => {
error!("deprecated decorations boolean value, \ error!("Deprecated decorations boolean value, \
use one of none|full instead; \ use one of none|full instead; \
Falling back to \"none\""); falling back to \"none\"");
Ok(Decorations::None) Ok(Decorations::None)
}, },
"transparent" | "buttonless" => { "transparent" | "buttonless" => {
error!("macos-only decorations value: {}; Using default value", value); error!("macOS-only decorations value: {}; using default value", value);
Ok(Decorations::Full) Ok(Decorations::Full)
}, },
_ => { _ => {
error!("invalid decorations value: {}; Using default value", value); error!("Invalid decorations value: {}; using default value", value);
Ok(Decorations::Full) Ok(Decorations::Full)
} }
} }
@ -406,7 +406,7 @@ fn deserialize_padding<'a, D>(deserializer: D) -> ::std::result::Result<Delta<u8
match Delta::deserialize(deserializer) { match Delta::deserialize(deserializer) {
Ok(delta) => Ok(delta), Ok(delta) => Ok(delta),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(default_padding()) Ok(default_padding())
}, },
} }
@ -557,7 +557,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
let vec = match Vec::<serde_yaml::Value>::deserialize(deserializer) { let vec = match Vec::<serde_yaml::Value>::deserialize(deserializer) {
Ok(vec) => vec, Ok(vec) => vec,
Err(err) => { Err(err) => {
error!("problem with config: {}; Using empty vector", err); error!("Problem with config: {}; using empty vector", err);
return Ok(Vec::new()); return Ok(Vec::new());
}, },
}; };
@ -568,7 +568,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
match T::deserialize(value) { match T::deserialize(value) {
Ok(binding) => bindings.push(binding), Ok(binding) => bindings.push(binding),
Err(err) => { Err(err) => {
error!("problem with config: {}; Skipping value", err); error!("Problem with config: {}; skipping value", err);
}, },
} }
} }
@ -586,7 +586,7 @@ fn deserialize_tabspaces<'a, D>(deserializer: D) -> ::std::result::Result<usize,
match usize::deserialize(deserializer) { match usize::deserialize(deserializer) {
Ok(value) => Ok(value), Ok(value) => Ok(value),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using `8`", err); error!("Problem with config: {}; using 8", err);
Ok(default_tabspaces()) Ok(default_tabspaces())
}, },
} }
@ -598,7 +598,7 @@ fn default_true_bool<'a, D>(deserializer: D) -> ::std::result::Result<bool, D::E
match bool::deserialize(deserializer) { match bool::deserialize(deserializer) {
Ok(value) => Ok(value), Ok(value) => Ok(value),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using `true`", err); error!("Problem with config: {}; using true", err);
Ok(true) Ok(true)
}, },
} }
@ -612,7 +612,7 @@ fn failure_default<'a, D, T>(deserializer: D)
match T::deserialize(deserializer) { match T::deserialize(deserializer) {
Ok(value) => Ok(value), Ok(value) => Ok(value),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(T::default()) Ok(T::default())
}, },
} }
@ -675,8 +675,8 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
Ok(lines) => { Ok(lines) => {
if lines > MAX_SCROLLBACK_LINES { if lines > MAX_SCROLLBACK_LINES {
error!( error!(
"problem with config: scrollback size is {}, but expected a maximum of {}; \ "Problem with config: scrollback size is {}, but expected a maximum of {}; \
Using {1} instead", using {1} instead",
lines, MAX_SCROLLBACK_LINES, lines, MAX_SCROLLBACK_LINES,
); );
Ok(MAX_SCROLLBACK_LINES) Ok(MAX_SCROLLBACK_LINES)
@ -685,7 +685,7 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
} }
}, },
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(default_scrolling_history()) Ok(default_scrolling_history())
}, },
} }
@ -697,7 +697,7 @@ fn deserialize_scrolling_multiplier<'a, D>(deserializer: D) -> ::std::result::Re
match u8::deserialize(deserializer) { match u8::deserialize(deserializer) {
Ok(lines) => Ok(lines), Ok(lines) => Ok(lines),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using default value", err); error!("Problem with config: {}; using default value", err);
Ok(default_scrolling_multiplier()) Ok(default_scrolling_multiplier())
}, },
} }
@ -739,7 +739,7 @@ impl<'a> de::Deserialize<'a> for ModsWrapper {
"Shift" => res.shift = true, "Shift" => res.shift = true,
"Alt" | "Option" => res.alt = true, "Alt" | "Option" => res.alt = true,
"Control" => res.ctrl = true, "Control" => res.ctrl = true,
_ => error!("unknown modifier {:?}", modifier), _ => error!("Unknown modifier {:?}", modifier),
} }
} }
@ -862,7 +862,7 @@ impl<'a> de::Deserialize<'a> for ModeWrapper {
"~AppCursor" => res.not_mode |= mode::TermMode::APP_CURSOR, "~AppCursor" => res.not_mode |= mode::TermMode::APP_CURSOR,
"AppKeypad" => res.mode |= mode::TermMode::APP_KEYPAD, "AppKeypad" => res.mode |= mode::TermMode::APP_KEYPAD,
"~AppKeypad" => res.not_mode |= mode::TermMode::APP_KEYPAD, "~AppKeypad" => res.not_mode |= mode::TermMode::APP_KEYPAD,
_ => error!("unknown mode {:?}", modifier), _ => error!("Unknown mode {:?}", modifier),
} }
} }
@ -1045,7 +1045,7 @@ impl<'a> de::Deserialize<'a> for RawBinding {
let scancode = val.as_u64().unwrap(); let scancode = val.as_u64().unwrap();
if scancode > u64::from(::std::u32::MAX) { if scancode > u64::from(::std::u32::MAX) {
return Err(<V::Error as Error>::custom(format!( return Err(<V::Error as Error>::custom(format!(
"invalid key binding, scancode too big: {}", "Invalid key binding, scancode too big: {}",
scancode scancode
))); )));
} }
@ -1225,9 +1225,9 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
Ok(index) => { Ok(index) => {
if index < 16 { if index < 16 {
error!( error!(
"problem with config: indexed_color's index is '{}', \ "Problem with config: indexed_color's index is {}, \
but a value bigger than 15 was expected; \ but a value bigger than 15 was expected; \
Ignoring setting", ignoring setting",
index index
); );
@ -1238,7 +1238,7 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
} }
}, },
Err(err) => { Err(err) => {
error!("problem with config: {}; Ignoring setting", err); error!("Problem with config: {}; ignoring setting", err);
// Return value out of range to ignore this color // Return value out of range to ignore this color
Ok(0) Ok(0)
@ -1293,7 +1293,7 @@ fn deserialize_optional_color<'a, D>(deserializer: D) -> ::std::result::Result<O
}, },
Ok(None) => Ok(None), Ok(None) => Ok(None),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using standard foreground color", err); error!("Problem with config: {}; using standard foreground color", err);
Ok(None) Ok(None)
}, },
} }
@ -1375,14 +1375,14 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
type Value = Rgb; type Value = Rgb;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Hex colors spec like 'ffaabb'") f.write_str("hex color like 0xff00ff")
} }
fn visit_str<E>(self, value: &str) -> ::std::result::Result<Rgb, E> fn visit_str<E>(self, value: &str) -> ::std::result::Result<Rgb, E>
where E: ::serde::de::Error where E: ::serde::de::Error
{ {
Rgb::from_str(&value[..]) Rgb::from_str(&value[..])
.map_err(|_| E::custom("failed to parse rgb; expect 0xrrggbb")) .map_err(|_| E::custom("failed to parse rgb; expected hex color like 0xff00ff"))
} }
} }
@ -1392,7 +1392,7 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
match rgb { match rgb {
Ok(rgb) => Ok(rgb), Ok(rgb) => Ok(rgb),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using color #ff00ff", err); error!("Problem with config: {}; using color #ff00ff", err);
Ok(Rgb { r: 255, g: 0, b: 255 }) Ok(Rgb { r: 255, g: 0, b: 255 })
}, },
} }
@ -1444,8 +1444,8 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
match *self { match *self {
Error::NotFound => "could not locate config file", Error::NotFound => "Couldn't locate config file",
Error::Empty => "empty config file", Error::Empty => "Empty config file",
Error::ReadingEnvHome(ref err) => err.description(), Error::ReadingEnvHome(ref err) => err.description(),
Error::Io(ref err) => err.description(), Error::Io(ref err) => err.description(),
Error::Yaml(ref err) => err.description(), Error::Yaml(ref err) => err.description(),
@ -1458,10 +1458,10 @@ impl ::std::fmt::Display for Error {
match *self { match *self {
Error::NotFound | Error::Empty => write!(f, "{}", ::std::error::Error::description(self)), Error::NotFound | Error::Empty => write!(f, "{}", ::std::error::Error::description(self)),
Error::ReadingEnvHome(ref err) => { Error::ReadingEnvHome(ref err) => {
write!(f, "could not read $HOME environment variable: {}", err) write!(f, "Couldn't read $HOME environment variable: {}", err)
}, },
Error::Io(ref err) => write!(f, "error reading config file: {}", err), Error::Io(ref err) => write!(f, "Error reading config file: {}", err),
Error::Yaml(ref err) => write!(f, "problem with config: {}", err), Error::Yaml(ref err) => write!(f, "Problem with config: {}", err),
} }
} }
} }
@ -1538,7 +1538,7 @@ impl Config {
if let Some(old_path) = old.as_ref().filter(|old| old.exists()) { if let Some(old_path) = old.as_ref().filter(|old| old.exists()) {
warn!( warn!(
"Found configuration at: '{}'. The file should be moved to the new location: '{}'.", "Found configuration at: {}; this file should be moved to the new location: {}",
old_path.to_string_lossy(), old_path.to_string_lossy(),
new.as_ref().map(|new| new.to_string_lossy()).unwrap(), new.as_ref().map(|new| new.to_string_lossy()).unwrap(),
); );
@ -1564,7 +1564,7 @@ impl Config {
pub fn write_defaults() -> io::Result<Cow<'static, Path>> { pub fn write_defaults() -> io::Result<Cow<'static, Path>> {
let mut path = dirs::config_dir() let mut path = dirs::config_dir()
.ok_or_else(|| { .ok_or_else(|| {
io::Error::new(io::ErrorKind::NotFound, "could not find profile directory") io::Error::new(io::ErrorKind::NotFound, "Couldn't find profile directory")
} }
)?; )?;
@ -1765,21 +1765,22 @@ impl Config {
fn print_deprecation_warnings(&mut self) { fn print_deprecation_warnings(&mut self) {
if self.dimensions.is_some() { if self.dimensions.is_some() {
warn!("{}", "Config `dimensions` is deprecated. \ warn!("Config dimensions is deprecated; \
Please use `window.dimensions` instead."); please use window.dimensions instead");
} }
if self.padding.is_some() { if self.padding.is_some() {
warn!("{}", "Config `padding` is deprecated. Please use `window.padding` instead."); warn!("Config padding is deprecated; \
please use window.padding instead");
} }
if self.mouse.faux_scrollback_lines.is_some() { if self.mouse.faux_scrollback_lines.is_some() {
warn!("{}", "Config `mouse.faux_scrollback_lines` is deprecated. \ warn!("Config mouse.faux_scrollback_lines is deprecated; \
Please use `mouse.faux_scrolling_lines` instead."); please use mouse.faux_scrolling_lines instead");
} }
if let Some(custom_cursor_colors) = self.custom_cursor_colors { if let Some(custom_cursor_colors) = self.custom_cursor_colors {
warn!("{}", "Config `custom_cursor_colors` is deprecated."); warn!("Config custom_cursor_colors is deprecated");
if !custom_cursor_colors { if !custom_cursor_colors {
self.colors.cursor.cursor = None; self.colors.cursor.cursor = None;
@ -1788,17 +1789,18 @@ impl Config {
} }
if self.cursor_style.is_some() { if self.cursor_style.is_some() {
warn!("{}", "Config `cursor_style` is deprecated. Please use `cursor.style` instead."); warn!("Config cursor_style is deprecated; \
please use cursor.style instead");
} }
if self.hide_cursor_when_typing.is_some() { if self.hide_cursor_when_typing.is_some() {
warn!("{}", "Config `hide_cursor_when_typing` is deprecated. \ warn!("Config hide_cursor_when_typing is deprecated; \
Please use `mouse.hide_when_typing` instead."); please use mouse.hide_when_typing instead");
} }
if self.unfocused_hollow_cursor.is_some() { if self.unfocused_hollow_cursor.is_some() {
warn!("{}", "Config `unfocused_hollow_cursor` is deprecated. \ warn!("Config unfocused_hollow_cursor is deprecated; \
Please use `cursor.unfocused_hollow` instead."); please use cursor.unfocused_hollow instead");
} }
} }
} }
@ -1899,7 +1901,7 @@ impl DeserializeSize for Size {
match size { match size {
Ok(size) => Ok(size), Ok(size) => Ok(size),
Err(err) => { Err(err) => {
error!("problem with config: {}; Using size 12", err); error!("Problem with config: {}; using size 12", err);
Ok(Size::new(12.)) Ok(Size::new(12.))
}, },
} }
@ -1949,7 +1951,7 @@ where
{ {
// This is necessary in order to get serde to complete deserialization of the configuration // This is necessary in order to get serde to complete deserialization of the configuration
let _ignored = bool::deserialize(deserializer); let _ignored = bool::deserialize(deserializer);
error!("The `scale_with_dpi` setting has been removed, \ error!("The scale_with_dpi setting has been removed, \
on X11 the WINIT_HIDPI_FACTOR environment variable can be used instead."); on X11 the WINIT_HIDPI_FACTOR environment variable can be used instead.");
Ok(None) Ok(None)
} }

9
src/display.rs
View File

@ -144,7 +144,7 @@ impl Display {
let mut window = Window::new(&options, config.window())?; let mut window = Window::new(&options, config.window())?;
let dpr = window.hidpi_factor(); let dpr = window.hidpi_factor();
info!("device_pixel_ratio: {}", dpr); info!("Device pixel ratio: {}", dpr);
// get window properties for initializing the other subsystems // get window properties for initializing the other subsystems
let mut viewport_size = window.inner_size_pixels() let mut viewport_size = window.inner_size_pixels()
@ -241,15 +241,16 @@ impl Display {
// Initialize glyph cache // Initialize glyph cache
let glyph_cache = { let glyph_cache = {
info!("Initializing glyph cache"); info!("Initializing glyph cache...");
let init_start = ::std::time::Instant::now(); let init_start = ::std::time::Instant::now();
let cache = let cache =
renderer.with_loader(|mut api| GlyphCache::new(rasterizer, &font, &mut api))?; renderer.with_loader(|mut api| GlyphCache::new(rasterizer, &font, &mut api))?;
let stop = init_start.elapsed(); let stop = init_start.elapsed();
let stop_f = stop.as_secs() as f64 + f64::from(stop.subsec_nanos()) / 1_000_000_000f64; let stop_f = stop.as_secs() as f64 +
info!("Finished initializing glyph cache in {}", stop_f); f64::from(stop.subsec_nanos()) / 1_000_000_000f64;
info!("... finished initializing glyph cache in {}s", stop_f);
cache cache
}; };

12
src/event_loop.rs
View File

@ -385,10 +385,10 @@ impl<T> EventLoop<T>
if let Err(err) = self.pty_read(&mut state, &mut buf, pipe.as_mut()) if let Err(err) = self.pty_read(&mut state, &mut buf, pipe.as_mut())
{ {
error!( error!(
"Event loop exitting due to error: {} [{}:{}]", "[{}:{}] Event loop exiting due to error: {}",
err,
file!(), file!(),
line!() line!(),
err
); );
break 'event_loop; break 'event_loop;
} }
@ -401,10 +401,10 @@ impl<T> EventLoop<T>
if event.readiness().is_writable() { if event.readiness().is_writable() {
if let Err(err) = self.pty_write(&mut state) { if let Err(err) = self.pty_write(&mut state) {
error!( error!(
"Event loop exitting due to error: {} [{}:{}]", "[{}:{}] Event loop exiting due to error: {}",
err,
file!(), file!(),
line!() line!(),
err
); );
break 'event_loop; break 'event_loop;
} }

4
src/grid/tests.rs
View File

@ -84,8 +84,6 @@ fn scroll_down() {
// Test that GridIterator works // Test that GridIterator works
#[test] #[test]
fn test_iter() { fn test_iter() {
info!("");
let mut grid = Grid::new(Line(5), Column(5), 0, 0); let mut grid = Grid::new(Line(5), Column(5), 0, 0);
for i in 0..5 { for i in 0..5 {
for j in 0..5 { for j in 0..5 {
@ -93,8 +91,6 @@ fn test_iter() {
} }
} }
info!("grid: {:?}", grid);
let mut iter = grid.iter_from(Point { let mut iter = grid.iter_from(Point {
line: 4, line: 4,
col: Column(0), col: Column(0),

14
src/input.rs
View File

@ -224,7 +224,7 @@ impl Action {
.and_then(|clipboard| clipboard.load_primary() ) .and_then(|clipboard| clipboard.load_primary() )
.map(|contents| { self.paste(ctx, &contents) }) .map(|contents| { self.paste(ctx, &contents) })
.unwrap_or_else(|err| { .unwrap_or_else(|err| {
error!("Error loading data from clipboard. {}", Red(err)); error!("Error loading data from clipboard: {}", Red(err));
}); });
}, },
Action::PasteSelection => { Action::PasteSelection => {
@ -234,19 +234,19 @@ impl Action {
.and_then(|clipboard| clipboard.load_selection() ) .and_then(|clipboard| clipboard.load_selection() )
.map(|contents| { self.paste(ctx, &contents) }) .map(|contents| { self.paste(ctx, &contents) })
.unwrap_or_else(|err| { .unwrap_or_else(|err| {
error!("Error loading data from clipboard. {}", Red(err)); error!("Error loading data from clipboard: {}", Red(err));
}); });
} }
}, },
Action::Command(ref program, ref args) => { Action::Command(ref program, ref args) => {
trace!("running command: {} {:?}", program, args); trace!("Running command {} with args {:?}", program, args);
match start_daemon(program, args) { match start_daemon(program, args) {
Ok(_) => { Ok(_) => {
debug!("spawned new proc"); debug!("Spawned new proc");
}, },
Err(err) => { Err(err) => {
warn!("couldn't run command: {}", err); warn!("Couldn't run command {}", err);
}, },
} }
}, },
@ -546,8 +546,8 @@ impl<'a, A: ActionContext + 'a> Processor<'a, A> {
args.push(text); args.push(text);
match start_daemon(launcher.program(), &args) { match start_daemon(launcher.program(), &args) {
Ok(_) => debug!("Launched: {} {:?}", launcher.program(), args), Ok(_) => debug!("Launched {} with args {:?}", launcher.program(), args),
Err(_) => warn!("Unable to launch: {} {:?}", launcher.program(), args), Err(_) => warn!("Unable to launch {} with args {:?}", launcher.program(), args),
} }
Some(()) Some(())

27
src/logging.rs
View File

@ -125,13 +125,26 @@ impl log::Log for Logger {
} }
fn log(&self, record: &log::Record<'_>) { fn log(&self, record: &log::Record<'_>) {
if self.enabled(record.metadata()) && record.target().starts_with("alacritty") { if self.enabled(record.metadata()) &&
let msg = format!( record.target().starts_with("alacritty")
"[{}] [{}] {}\n", {
time::now().strftime("%F %R").unwrap(), let now = time::strftime("%F %R", &time::now()).unwrap();
record.level(),
record.args() let msg = if record.level() >= Level::Trace {
); format!("[{}] [{}] [{}:{}] {}\n",
now,
record.level(),
record.file().unwrap_or("?"),
record.line()
.map(|l| l.to_string())
.unwrap_or("?".to_string()),
record.args())
} else {
format!("[{}] [{}] {}\n",
now,
record.level(),
record.args())
};
if let Ok(ref mut logfile) = self.logfile.lock() { if let Ok(ref mut logfile) = self.logfile.lock() {
let _ = logfile.write_all(msg.as_ref()); let _ = logfile.write_all(msg.as_ref());

10
src/main.rs
View File

@ -99,8 +99,8 @@ fn load_config(options: &cli::Options) -> Config {
Config::load_from(&*config_path).unwrap_or_else(|err| { Config::load_from(&*config_path).unwrap_or_else(|err| {
match err { match err {
ConfigError::Empty => info!("Config file {:?} is empty; Loading default", config_path), ConfigError::Empty => info!("Config file {:?} is empty; loading default", config_path),
_ => error!("Error: {}; Loading default config", err), _ => error!("Error: {}; loading default config", err),
} }
Config::default() Config::default()
@ -116,9 +116,9 @@ fn run(
options: &cli::Options, options: &cli::Options,
mut logger_proxy: LoggerProxy, mut logger_proxy: LoggerProxy,
) -> Result<(), Box<dyn Error>> { ) -> Result<(), Box<dyn Error>> {
info!("Welcome to Alacritty."); info!("Welcome to Alacritty");
if let Some(config_path) = config.path() { if let Some(config_path) = config.path() {
info!("Configuration loaded from {}", config_path.display()); info!("Configuration loaded from {:?}", config_path.display());
}; };
// Set environment variables // Set environment variables
@ -264,7 +264,7 @@ fn run(
#[cfg(windows)] #[cfg(windows)]
unsafe { FreeConsole(); } unsafe { FreeConsole(); }
info!("Goodbye."); info!("Goodbye");
if !options.persistent_logging && !config.persistent_logging() { if !options.persistent_logging && !config.persistent_logging() {
logger_proxy.delete_log(); logger_proxy.delete_log();

35
src/renderer/mod.rs
View File

@ -321,7 +321,7 @@ impl GlyphCache {
self.rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?; self.rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
let metrics = self.rasterizer.metrics(regular, size)?; let metrics = self.rasterizer.metrics(regular, size)?;
info!("Font size changed: {:?} [DPR: {}]", font.size, dpr); info!("Font size changed to {:?} with DPR of {}", font.size, dpr);
self.font_size = font.size; self.font_size = font.size;
self.font_key = regular; self.font_key = regular;
@ -816,26 +816,15 @@ impl QuadRenderer {
} }
pub fn reload_shaders(&mut self, size: PhysicalSize) { pub fn reload_shaders(&mut self, size: PhysicalSize) {
warn!("Reloading shaders ..."); warn!("Reloading shaders...");
let result = (TextShaderProgram::new(size), RectShaderProgram::new()); let result = (TextShaderProgram::new(size), RectShaderProgram::new());
let (program, rect_program) = match result { let (program, rect_program) = match result {
(Ok(program), Ok(rect_program)) => { (Ok(program), Ok(rect_program)) => {
warn!(" ... OK"); info!("... successfully reloaded shaders");
(program, rect_program) (program, rect_program)
} }
(Err(err), _) | (_, Err(err)) => { (Err(err), _) | (_, Err(err)) => {
match err { error!("{}", err);
ShaderCreationError::Io(err) => {
error!("Error reading shader file: {}", err);
}
ShaderCreationError::Compile(path, log) => {
error!("Error compiling shader at {:?}\n{}", path, log);
}
ShaderCreationError::Link(log) => {
error!("Error reloading shaders: {}", log);
}
}
return; return;
} }
}; };
@ -1234,7 +1223,7 @@ impl TextShaderProgram {
); );
let projection: [[f32; 4]; 4] = ortho.into(); let projection: [[f32; 4]; 4] = ortho.into();
info!("width: {}, height: {}", width, height); info!("Width: {}, Height: {}", width, height);
unsafe { unsafe {
gl::UniformMatrix4fv( gl::UniformMatrix4fv(
@ -1483,11 +1472,15 @@ impl ::std::error::Error for ShaderCreationError {
impl ::std::fmt::Display for ShaderCreationError { impl ::std::fmt::Display for ShaderCreationError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self { match *self {
ShaderCreationError::Io(ref err) => write!(f, "couldn't read shader: {}", err), ShaderCreationError::Io(ref err) => {
ShaderCreationError::Compile(ref _path, ref s) => { write!(f, "Couldn't read shader: {}", err)
write!(f, "failed compiling shader: {}", s) },
} ShaderCreationError::Compile(ref path, ref log) => {
ShaderCreationError::Link(ref s) => write!(f, "failed linking shader: {}", s), write!(f, "Failed compiling shader at {}: {}", path.display(), log)
},
ShaderCreationError::Link(ref log) => {
write!(f, "Failed linking shader: {}", log)
},
} }
} }
} }

100
src/term/mod.rs
View File

@ -1167,7 +1167,7 @@ impl Term {
/// Resize terminal to new dimensions /// Resize terminal to new dimensions
pub fn resize(&mut self, size : &SizeInfo) { pub fn resize(&mut self, size : &SizeInfo) {
debug!("Term::resize"); debug!("Resizing terminal");
// Bounds check; lots of math assumes width and height are > 0 // Bounds check; lots of math assumes width and height are > 0
if size.width as usize <= 2 * self.size_info.padding_x as usize || if size.width as usize <= 2 * self.size_info.padding_x as usize ||
@ -1224,7 +1224,7 @@ impl Term {
} }
} }
debug!("num_cols, num_lines = {}, {}", num_cols, num_lines); debug!("New num_cols is {} and num_lines is {}", num_cols, num_lines);
// Resize grids to new size // Resize grids to new size
self.grid.resize(num_lines, num_cols, &Cell::default()); self.grid.resize(num_lines, num_cols, &Cell::default());
@ -1276,7 +1276,7 @@ impl Term {
/// Expects origin to be in scroll range. /// Expects origin to be in scroll range.
#[inline] #[inline]
fn scroll_down_relative(&mut self, origin: Line, mut lines: Line) { fn scroll_down_relative(&mut self, origin: Line, mut lines: Line) {
trace!("scroll_down_relative: origin={}, lines={}", origin, lines); trace!("Scrolling down relative: origin={}, lines={}", origin, lines);
lines = min(lines, self.scroll_region.end - self.scroll_region.start); lines = min(lines, self.scroll_region.end - self.scroll_region.start);
lines = min(lines, self.scroll_region.end - origin); lines = min(lines, self.scroll_region.end - origin);
@ -1290,7 +1290,7 @@ impl Term {
/// Expects origin to be in scroll range. /// Expects origin to be in scroll range.
#[inline] #[inline]
fn scroll_up_relative(&mut self, origin: Line, lines: Line) { fn scroll_up_relative(&mut self, origin: Line, lines: Line) {
trace!("scroll_up_relative: origin={}, lines={}", origin, lines); trace!("Scrolling up relative: origin={}, lines={}", origin, lines);
let lines = min(lines, self.scroll_region.end - self.scroll_region.start); let lines = min(lines, self.scroll_region.end - self.scroll_region.start);
// Scroll from origin to bottom less number of lines // Scroll from origin to bottom less number of lines
@ -1354,7 +1354,7 @@ impl ansi::Handler for Term {
return; return;
} }
trace!("wrapping"); trace!("Wrapping input");
{ {
let location = Point { let location = Point {
@ -1434,7 +1434,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn dectest(&mut self) { fn dectest(&mut self) {
trace!("dectest"); trace!("Dectesting");
let mut template = self.cursor.template; let mut template = self.cursor.template;
template.c = 'E'; template.c = 'E';
@ -1444,7 +1444,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn goto(&mut self, line: Line, col: Column) { fn goto(&mut self, line: Line, col: Column) {
trace!("goto: line={}, col={}", line, col); trace!("Going to: line={}, col={}", line, col);
let (y_offset, max_y) = if self.mode.contains(mode::TermMode::ORIGIN) { let (y_offset, max_y) = if self.mode.contains(mode::TermMode::ORIGIN) {
(self.scroll_region.start, self.scroll_region.end - 1) (self.scroll_region.start, self.scroll_region.end - 1)
} else { } else {
@ -1458,13 +1458,13 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn goto_line(&mut self, line: Line) { fn goto_line(&mut self, line: Line) {
trace!("goto_line: {}", line); trace!("Going to line: {}", line);
self.goto(line, self.cursor.point.col) self.goto(line, self.cursor.point.col)
} }
#[inline] #[inline]
fn goto_col(&mut self, col: Column) { fn goto_col(&mut self, col: Column) {
trace!("goto_col: {}", col); trace!("Going to column: {}", col);
self.goto(self.cursor.point.line, col) self.goto(self.cursor.point.line, col)
} }
@ -1497,28 +1497,28 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn move_up(&mut self, lines: Line) { fn move_up(&mut self, lines: Line) {
trace!("move_up: {}", lines); trace!("Moving up: {}", lines);
let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0)); let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
self.goto(move_to, self.cursor.point.col) self.goto(move_to, self.cursor.point.col)
} }
#[inline] #[inline]
fn move_down(&mut self, lines: Line) { fn move_down(&mut self, lines: Line) {
trace!("move_down: {}", lines); trace!("Moving down: {}", lines);
let move_to = self.cursor.point.line + lines; let move_to = self.cursor.point.line + lines;
self.goto(move_to, self.cursor.point.col) self.goto(move_to, self.cursor.point.col)
} }
#[inline] #[inline]
fn move_forward(&mut self, cols: Column) { fn move_forward(&mut self, cols: Column) {
trace!("move_forward: {}", cols); trace!("Moving forward: {}", cols);
self.cursor.point.col = min(self.cursor.point.col + cols, self.grid.num_cols() - 1); self.cursor.point.col = min(self.cursor.point.col + cols, self.grid.num_cols() - 1);
self.input_needs_wrap = false; self.input_needs_wrap = false;
} }
#[inline] #[inline]
fn move_backward(&mut self, cols: Column) { fn move_backward(&mut self, cols: Column) {
trace!("move_backward: {}", cols); trace!("Moving backward: {}", cols);
self.cursor.point.col -= min(self.cursor.point.col, cols); self.cursor.point.col -= min(self.cursor.point.col, cols);
self.input_needs_wrap = false; self.input_needs_wrap = false;
} }
@ -1530,7 +1530,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn device_status<W: io::Write>(&mut self, writer: &mut W, arg: usize) { fn device_status<W: io::Write>(&mut self, writer: &mut W, arg: usize) {
trace!("device status: {}", arg); trace!("Reporting device status: {}", arg);
match arg { match arg {
5 => { 5 => {
let _ = writer.write_all(b"\x1b[0n"); let _ = writer.write_all(b"\x1b[0n");
@ -1545,21 +1545,21 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn move_down_and_cr(&mut self, lines: Line) { fn move_down_and_cr(&mut self, lines: Line) {
trace!("move_down_and_cr: {}", lines); trace!("Moving down and cr: {}", lines);
let move_to = self.cursor.point.line + lines; let move_to = self.cursor.point.line + lines;
self.goto(move_to, Column(0)) self.goto(move_to, Column(0))
} }
#[inline] #[inline]
fn move_up_and_cr(&mut self, lines: Line) { fn move_up_and_cr(&mut self, lines: Line) {
trace!("move_up_and_cr: {}", lines); trace!("Moving up and cr: {}", lines);
let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0)); let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
self.goto(move_to, Column(0)) self.goto(move_to, Column(0))
} }
#[inline] #[inline]
fn put_tab(&mut self, mut count: i64) { fn put_tab(&mut self, mut count: i64) {
trace!("put_tab: {}", count); trace!("Putting tab: {}", count);
while self.cursor.point.col < self.grid.num_cols() && count != 0 { while self.cursor.point.col < self.grid.num_cols() && count != 0 {
count -= 1; count -= 1;
@ -1587,7 +1587,7 @@ impl ansi::Handler for Term {
/// Backspace `count` characters /// Backspace `count` characters
#[inline] #[inline]
fn backspace(&mut self) { fn backspace(&mut self) {
trace!("backspace"); trace!("Backspace");
if self.cursor.point.col > Column(0) { if self.cursor.point.col > Column(0) {
self.cursor.point.col -= 1; self.cursor.point.col -= 1;
self.input_needs_wrap = false; self.input_needs_wrap = false;
@ -1597,7 +1597,7 @@ impl ansi::Handler for Term {
/// Carriage return /// Carriage return
#[inline] #[inline]
fn carriage_return(&mut self) { fn carriage_return(&mut self) {
trace!("carriage_return"); trace!("Carriage return");
self.cursor.point.col = Column(0); self.cursor.point.col = Column(0);
self.input_needs_wrap = false; self.input_needs_wrap = false;
} }
@ -1605,7 +1605,7 @@ impl ansi::Handler for Term {
/// Linefeed /// Linefeed
#[inline] #[inline]
fn linefeed(&mut self) { fn linefeed(&mut self) {
trace!("linefeed"); trace!("Linefeed");
let next = self.cursor.point.line + 1; let next = self.cursor.point.line + 1;
if next == self.scroll_region.end { if next == self.scroll_region.end {
self.scroll_up(Line(1)); self.scroll_up(Line(1));
@ -1617,14 +1617,14 @@ impl ansi::Handler for Term {
/// Set current position as a tabstop /// Set current position as a tabstop
#[inline] #[inline]
fn bell(&mut self) { fn bell(&mut self) {
trace!("bell"); trace!("Bell");
self.visual_bell.ring(); self.visual_bell.ring();
self.next_is_urgent = Some(true); self.next_is_urgent = Some(true);
} }
#[inline] #[inline]
fn substitute(&mut self) { fn substitute(&mut self) {
trace!("[unimplemented] substitute"); trace!("[unimplemented] Substitute");
} }
/// Run LF/NL /// Run LF/NL
@ -1660,7 +1660,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn set_horizontal_tabstop(&mut self) { fn set_horizontal_tabstop(&mut self) {
trace!("set_horizontal_tabstop"); trace!("Setting horizontal tabstop");
let column = self.cursor.point.col; let column = self.cursor.point.col;
self.tabs[column] = true; self.tabs[column] = true;
} }
@ -1679,7 +1679,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn insert_blank_lines(&mut self, lines: Line) { fn insert_blank_lines(&mut self, lines: Line) {
trace!("insert_blank_lines: {}", lines); trace!("Inserting blank {} lines", lines);
if self.scroll_region.contains_(self.cursor.point.line) { if self.scroll_region.contains_(self.cursor.point.line) {
let origin = self.cursor.point.line; let origin = self.cursor.point.line;
self.scroll_down_relative(origin, lines); self.scroll_down_relative(origin, lines);
@ -1688,7 +1688,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn delete_lines(&mut self, lines: Line) { fn delete_lines(&mut self, lines: Line) {
trace!("delete_lines: {}", lines); trace!("Deleting {} lines", lines);
if self.scroll_region.contains_(self.cursor.point.line) { if self.scroll_region.contains_(self.cursor.point.line) {
let origin = self.cursor.point.line; let origin = self.cursor.point.line;
self.scroll_up_relative(origin, lines); self.scroll_up_relative(origin, lines);
@ -1697,7 +1697,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn erase_chars(&mut self, count: Column) { fn erase_chars(&mut self, count: Column) {
trace!("erase_chars: {}, {}", count, self.cursor.point.col); trace!("Erasing chars: count={}, col={}", count, self.cursor.point.col);
let start = self.cursor.point.col; let start = self.cursor.point.col;
let end = min(start + count, self.grid.num_cols() - 1); let end = min(start + count, self.grid.num_cols() - 1);
@ -1737,7 +1737,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn move_backward_tabs(&mut self, count: i64) { fn move_backward_tabs(&mut self, count: i64) {
trace!("move_backward_tabs: {}", count); trace!("Moving backward {} tabs", count);
for _ in 0..count { for _ in 0..count {
let mut col = self.cursor.point.col; let mut col = self.cursor.point.col;
@ -1753,12 +1753,12 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn move_forward_tabs(&mut self, count: i64) { fn move_forward_tabs(&mut self, count: i64) {
trace!("[unimplemented] move_forward_tabs: {}", count); trace!("[unimplemented] Moving forward {} tabs", count);
} }
#[inline] #[inline]
fn save_cursor_position(&mut self) { fn save_cursor_position(&mut self) {
trace!("CursorSave"); trace!("Saving cursor position");
let cursor = if self.alt { let cursor = if self.alt {
&mut self.cursor_save_alt &mut self.cursor_save_alt
} else { } else {
@ -1770,7 +1770,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn restore_cursor_position(&mut self) { fn restore_cursor_position(&mut self) {
trace!("CursorRestore"); trace!("Restoring cursor position");
let source = if self.alt { let source = if self.alt {
&self.cursor_save_alt &self.cursor_save_alt
} else { } else {
@ -1784,7 +1784,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn clear_line(&mut self, mode: ansi::LineClearMode) { fn clear_line(&mut self, mode: ansi::LineClearMode) {
trace!("clear_line: {:?}", mode); trace!("Clearing line: {:?}", mode);
let mut template = self.cursor.template; let mut template = self.cursor.template;
template.flags ^= template.flags; template.flags ^= template.flags;
@ -1815,7 +1815,7 @@ impl ansi::Handler for Term {
/// Set the indexed color value /// Set the indexed color value
#[inline] #[inline]
fn set_color(&mut self, index: usize, color: Rgb) { fn set_color(&mut self, index: usize, color: Rgb) {
trace!("set_color[{}] = {:?}", index, color); trace!("Setting color[{}] = {:?}", index, color);
self.colors[index] = color; self.colors[index] = color;
self.color_modified[index] = true; self.color_modified[index] = true;
} }
@ -1823,7 +1823,7 @@ impl ansi::Handler for Term {
/// Reset the indexed color to original value /// Reset the indexed color to original value
#[inline] #[inline]
fn reset_color(&mut self, index: usize) { fn reset_color(&mut self, index: usize) {
trace!("reset_color[{}]", index); trace!("Reseting color[{}]", index);
self.colors[index] = self.original_colors[index]; self.colors[index] = self.original_colors[index];
self.color_modified[index] = false; self.color_modified[index] = false;
} }
@ -1835,13 +1835,13 @@ impl ansi::Handler for Term {
Clipboard::new() Clipboard::new()
.and_then(|mut clipboard| clipboard.store_primary(string)) .and_then(|mut clipboard| clipboard.store_primary(string))
.unwrap_or_else(|err| { .unwrap_or_else(|err| {
warn!("Error storing selection to clipboard. {}", err); warn!("Error storing selection to clipboard: {}", err);
}); });
} }
#[inline] #[inline]
fn clear_screen(&mut self, mode: ansi::ClearMode) { fn clear_screen(&mut self, mode: ansi::ClearMode) {
trace!("clear_screen: {:?}", mode); trace!("Clearing screen: {:?}", mode);
let mut template = self.cursor.template; let mut template = self.cursor.template;
template.flags ^= template.flags; template.flags ^= template.flags;
@ -1881,7 +1881,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn clear_tabs(&mut self, mode: ansi::TabulationClearMode) { fn clear_tabs(&mut self, mode: ansi::TabulationClearMode) {
trace!("clear_tabs: {:?}", mode); trace!("Clearing tabs: {:?}", mode);
match mode { match mode {
ansi::TabulationClearMode::Current => { ansi::TabulationClearMode::Current => {
let column = self.cursor.point.col; let column = self.cursor.point.col;
@ -1916,7 +1916,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn reverse_index(&mut self) { fn reverse_index(&mut self) {
trace!("reverse_index"); trace!("Reversing index");
// if cursor is at the top // if cursor is at the top
if self.cursor.point.line == self.scroll_region.start { if self.cursor.point.line == self.scroll_region.start {
self.scroll_down(Line(1)); self.scroll_down(Line(1));
@ -1928,7 +1928,7 @@ impl ansi::Handler for Term {
/// set a terminal attribute /// set a terminal attribute
#[inline] #[inline]
fn terminal_attribute(&mut self, attr: Attr) { fn terminal_attribute(&mut self, attr: Attr) {
trace!("Set Attribute: {:?}", attr); trace!("Setting attribute: {:?}", attr);
match attr { match attr {
Attr::Foreground(color) => self.cursor.template.fg = color, Attr::Foreground(color) => self.cursor.template.fg = color,
Attr::Background(color) => self.cursor.template.bg = color, Attr::Background(color) => self.cursor.template.bg = color,
@ -1959,7 +1959,7 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn set_mode(&mut self, mode: ansi::Mode) { fn set_mode(&mut self, mode: ansi::Mode) {
trace!("set_mode: {:?}", mode); trace!("Setting mode: {:?}", mode);
match mode { match mode {
ansi::Mode::SwapScreenAndSetRestoreCursor => { ansi::Mode::SwapScreenAndSetRestoreCursor => {
self.mode.insert(mode::TermMode::ALT_SCREEN); self.mode.insert(mode::TermMode::ALT_SCREEN);
@ -1991,15 +1991,15 @@ impl ansi::Handler for Term {
ansi::Mode::Origin => self.mode.insert(mode::TermMode::ORIGIN), ansi::Mode::Origin => self.mode.insert(mode::TermMode::ORIGIN),
ansi::Mode::DECCOLM => self.deccolm(), ansi::Mode::DECCOLM => self.deccolm(),
ansi::Mode::Insert => self.mode.insert(mode::TermMode::INSERT), // heh ansi::Mode::Insert => self.mode.insert(mode::TermMode::INSERT), // heh
_ => { ansi::Mode::BlinkingCursor => {
trace!(".. ignoring set_mode"); trace!("... unimplemented mode");
} }
} }
} }
#[inline] #[inline]
fn unset_mode(&mut self,mode: ansi::Mode) { fn unset_mode(&mut self,mode: ansi::Mode) {
trace!("unset_mode: {:?}", mode); trace!("Unsetting mode: {:?}", mode);
match mode { match mode {
ansi::Mode::SwapScreenAndSetRestoreCursor => { ansi::Mode::SwapScreenAndSetRestoreCursor => {
self.mode.remove(mode::TermMode::ALT_SCREEN); self.mode.remove(mode::TermMode::ALT_SCREEN);
@ -2031,15 +2031,15 @@ impl ansi::Handler for Term {
ansi::Mode::Origin => self.mode.remove(mode::TermMode::ORIGIN), ansi::Mode::Origin => self.mode.remove(mode::TermMode::ORIGIN),
ansi::Mode::DECCOLM => self.deccolm(), ansi::Mode::DECCOLM => self.deccolm(),
ansi::Mode::Insert => self.mode.remove(mode::TermMode::INSERT), ansi::Mode::Insert => self.mode.remove(mode::TermMode::INSERT),
_ => { ansi::Mode::BlinkingCursor => {
trace!(".. ignoring unset_mode"); trace!("... unimplemented mode");
} }
} }
} }
#[inline] #[inline]
fn set_scrolling_region(&mut self, region: Range<Line>) { fn set_scrolling_region(&mut self, region: Range<Line>) {
trace!("set scroll region: {:?}", region); trace!("Setting scrolling region: {:?}", region);
self.scroll_region.start = min(region.start, self.grid.num_lines()); self.scroll_region.start = min(region.start, self.grid.num_lines());
self.scroll_region.end = min(region.end, self.grid.num_lines()); self.scroll_region.end = min(region.end, self.grid.num_lines());
self.goto(Line(0), Column(0)); self.goto(Line(0), Column(0));
@ -2047,31 +2047,31 @@ impl ansi::Handler for Term {
#[inline] #[inline]
fn set_keypad_application_mode(&mut self) { fn set_keypad_application_mode(&mut self) {
trace!("set mode::TermMode::APP_KEYPAD"); trace!("Setting keypad application mode");
self.mode.insert(mode::TermMode::APP_KEYPAD); self.mode.insert(mode::TermMode::APP_KEYPAD);
} }
#[inline] #[inline]
fn unset_keypad_application_mode(&mut self) { fn unset_keypad_application_mode(&mut self) {
trace!("unset mode::TermMode::APP_KEYPAD"); trace!("Unsetting keypad application mode");
self.mode.remove(mode::TermMode::APP_KEYPAD); self.mode.remove(mode::TermMode::APP_KEYPAD);
} }
#[inline] #[inline]
fn configure_charset(&mut self, index: CharsetIndex, charset: StandardCharset) { fn configure_charset(&mut self, index: CharsetIndex, charset: StandardCharset) {
trace!("designate {:?} character set as {:?}", index, charset); trace!("Configuring charset {:?} as {:?}", index, charset);
self.cursor.charsets[index] = charset; self.cursor.charsets[index] = charset;
} }
#[inline] #[inline]
fn set_active_charset(&mut self, index: CharsetIndex) { fn set_active_charset(&mut self, index: CharsetIndex) {
trace!("Activate {:?} character set", index); trace!("Setting active charset {:?}", index);
self.active_charset = index; self.active_charset = index;
} }
#[inline] #[inline]
fn set_cursor_style(&mut self, style: Option<CursorStyle>) { fn set_cursor_style(&mut self, style: Option<CursorStyle>) {
trace!("set_cursor_style {:?}", style); trace!("Setting cursor style {:?}", style);
self.cursor_style = style; self.cursor_style = style;
} }
} }

2
src/tty/unix.rs
View File

@ -316,7 +316,7 @@ pub fn new<T: ToWinsize>(
pty pty
}, },
Err(err) => { Err(err) => {
die!("Command::spawn() failed: {}", err); die!("Failed to spawn command: {}", err);
} }
} }
} }

4
src/tty/windows/mod.rs
View File

@ -85,10 +85,10 @@ pub fn new<'a>(
window_id: Option<usize>, window_id: Option<usize>,
) -> Pty<'a> { ) -> Pty<'a> {
if let Some(pty) = conpty::new(config, options, size, window_id) { if let Some(pty) = conpty::new(config, options, size, window_id) {
info!("Using Conpty agent."); info!("Using Conpty agent");
pty pty
} else { } else {
info!("Using Winpty agent."); info!("Using Winpty agent");
winpty::new(config, options, size, window_id) winpty::new(config, options, size, window_id)
} }
} }

8
winpty/src/windows.rs
View File

@ -140,8 +140,8 @@ impl<'a> Drop for Config<'a> {
pub struct Winpty<'a>(&'a mut winpty_t); pub struct Winpty<'a>(&'a mut winpty_t);
impl<'a, 'b> Winpty<'a> { impl<'a, 'b> Winpty<'a> {
/// Starts the agent. This process will connect to the agent /// Starts the agent. This process will connect to the agent
/// over a control pipe, and the agent will open data pipes /// over a control pipe, and the agent will open data pipes
/// (e.g. CONIN and CONOUT). /// (e.g. CONIN and CONOUT).
pub fn open(cfg: &Config) -> Result<Self, Err<'b>> { pub fn open(cfg: &Config) -> Result<Self, Err<'b>> {
let mut err = null_mut() as *mut winpty_error_t; let mut err = null_mut() as *mut winpty_error_t;
@ -199,7 +199,7 @@ impl<'a, 'b> Winpty<'a> {
} }
/// Change the size of the Windows console window. /// Change the size of the Windows console window.
/// ///
/// cols & rows MUST be greater than 0 /// cols & rows MUST be greater than 0
pub fn set_size(&mut self, cols: u16, rows: u16) -> Result<(), Err> { pub fn set_size(&mut self, cols: u16, rows: u16) -> Result<(), Err> {
assert!(cols > 0 && rows > 0); assert!(cols > 0 && rows > 0);
@ -339,7 +339,7 @@ impl<'a> Drop for SpawnConfig<'a> {
} }
} }
} }
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
extern crate named_pipe; extern crate named_pipe;