#[cfg(feature = "unicode_support")]
-use bindgen;
use std::env;
+#[cfg(feature = "unicode_support")]
use std::path::PathBuf;
#[cfg(not(feature = "unicode_support"))]
}
#[cfg(not(feature = "unicode_support"))]
+#[allow(clippy::ptr_arg)]
fn string_to_text(
string: String,
- loaded_fonts: &mut Vec<(PathBuf, Font)>,
- ctx: &mut Context,
+ _loaded_fonts: &mut Vec<(PathBuf, Font)>,
+ _ctx: &mut Context,
) -> Text {
Text::new(TextFragment::from(string))
}
current_fragment.font = Some(font);
}
current_fragment.text.push(c);
- } else {
- if let Some(idx) = idx_opt {
- let font = loaded_fonts[idx].1;
- if let Some(current_font) = current_fragment.font {
- if current_font == font {
- current_fragment.text.push(c);
- } else {
- if !current_fragment.text.is_empty() {
- text.add(current_fragment);
- current_fragment = Default::default();
- }
- current_fragment.text.push(c);
- current_fragment.font = Some(font);
- }
- } else if current_fragment.text.is_empty() {
+ } else if let Some(idx) = idx_opt {
+ let font = loaded_fonts[idx].1;
+ if let Some(current_font) = current_fragment.font {
+ if current_font == font {
current_fragment.text.push(c);
- current_fragment.font = Some(font);
} else {
- text.add(current_fragment);
- current_fragment = Default::default();
-
+ if !current_fragment.text.is_empty() {
+ text.add(current_fragment);
+ current_fragment = Default::default();
+ }
current_fragment.text.push(c);
current_fragment.font = Some(font);
}
+ } else if current_fragment.text.is_empty() {
+ current_fragment.text.push(c);
+ current_fragment.font = Some(font);
} else {
- if !current_fragment.text.is_empty() && current_fragment.font.is_some() {
- text.add(current_fragment);
- current_fragment = Default::default();
- }
+ text.add(current_fragment);
+ current_fragment = Default::default();
+
current_fragment.text.push(c);
+ current_fragment.font = Some(font);
+ }
+ } else {
+ if !current_fragment.text.is_empty() && current_fragment.font.is_some() {
+ text.add(current_fragment);
+ current_fragment = Default::default();
}
+ current_fragment.text.push(c);
}
prev_is_ascii = false;
}
use crate::debug_log::{log, LogLevel, LogState};
-use std::io::{self, Read, Write};
+use std::fmt::Write;
+use std::io::{self, Read, Write as IOWrite};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
use std::str::FromStr;
use std::sync::atomic::{AtomicBool, Ordering};
state: Arc<RwLock<MPDHandlerState>>,
}
+type SelfThreadT = Option<Arc<Mutex<thread::JoinHandle<Result<(), String>>>>>;
+
pub struct MPDHandlerState {
art_data: Vec<u8>,
art_data_size: usize,
song_title_get_time: Instant,
song_pos_get_time: Instant,
song_length_get_time: Instant,
- self_thread: Option<Arc<Mutex<thread::JoinHandle<Result<(), String>>>>>,
+ self_thread: SelfThreadT,
dirty_flag: Arc<AtomicBool>,
pub stop_flag: Arc<AtomicBool>,
log_level: LogLevel,
Err(())
}
+ #[allow(dead_code)]
pub fn is_dirty(&self) -> Result<bool, ()> {
if let Ok(write_lock) = self.state.try_write() {
return Ok(write_lock.dirty_flag.swap(false, Ordering::Relaxed));
Err(())
}
+ #[allow(dead_code)]
pub fn force_get_current_song(&self) {
loop {
if let Ok(mut write_lock) = self.state.try_write() {
Ok(!read_handle.can_authenticate)
}
+ #[allow(dead_code)]
pub fn has_image_data(&self) -> Result<bool, ()> {
let read_handle = self.state.try_read().map_err(|_| ())?;
Ok(read_handle.is_art_data_ready())
MPDPlayState::Paused
};
write_handle.error_text.clear();
- write_handle
- .error_text
- .push_str(&format!("MPD has {:?}", got_mpd_state));
+ write!(&mut write_handle.error_text, "MPD has {:?}", got_mpd_state).ok();
log(
format!("MPD is {:?}", got_mpd_state),
LogState::Warning,
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(deref_nullptr)]
+ #![allow(clippy::redundant_static_lifetimes)]
include!(concat!(env!("OUT_DIR"), "/unicode_support_bindings.rs"));
}
}
}
+ #[allow(dead_code)]
pub fn get(&mut self) -> *mut bindgen::FcConfig {
self.config
}
}
impl FcCharSetWr {
+ #[allow(dead_code)]
pub fn new_with_str(s: &str) -> Result<Self, String> {
let charset;
unsafe {
i,
&mut value as *mut bindgen::FcValue,
) == bindgen::_FcResult_FcResultMatch
+ && value.type_ == bindgen::_FcType_FcTypeString
{
- if value.type_ == bindgen::_FcType_FcTypeString {
- let cs = CStr::from_ptr(value.u.s as *const i8);
- vec.push(
- cs.to_str()
- .map_err(|_| String::from("Failed to convert CStr to String"))?
- .to_owned(),
- );
- }
+ let cs = CStr::from_ptr(value.u.s as *const i8);
+ vec.push(
+ cs.to_str()
+ .map_err(|_| String::from("Failed to convert CStr to String"))?
+ .to_owned(),
+ );
}
}
}
}
}
+#[allow(dead_code)]
pub fn get_matching_font_from_str(s: &str) -> Result<PathBuf, String> {
let mut config = ffi::FcConfigWr::new()?;
let mut charset = ffi::FcCharSetWr::new_with_str(s)?;
pub struct FTOpenArgs {
args: FT_Open_Args,
+ // "args" has a pointer to the CString in "pathname", so it must be kept
+ #[allow(dead_code)]
pathname: Option<CString>,
}
);
let args = FT_Open_Args {
flags: FT_OPEN_PATHNAME,
- memory_base: 0 as *const u8,
+ memory_base: std::ptr::null::<u8>(),
memory_size: 0,
pathname: cstring.as_ptr() as *mut i8,
- stream: 0 as *mut FT_StreamRec_,
- driver: 0 as *mut FT_ModuleRec_,
+ stream: std::ptr::null_mut::<FT_StreamRec_>(),
+ driver: std::ptr::null_mut::<FT_ModuleRec_>(),
num_params: 0,
- params: 0 as *mut FT_Parameter_,
+ params: std::ptr::null_mut::<FT_Parameter_>(),
};
FTOpenArgs {
}
}
+ #[allow(dead_code)]
pub fn get_args(&self) -> FT_Open_Args {
self.args
}
pub fn new(library: &FTLibrary, args: &mut FTOpenArgs) -> Result<FTFaces, ()> {
let mut faces = FTFaces { faces: Vec::new() };
unsafe {
- let count;
let mut face: FT_Face = 0 as FT_Face;
// first get number of faces
let mut result = FT_Open_Face(
FT_Done_Face(face);
return Err(());
}
- count = (*face).num_faces;
+ let count = (*face).num_faces;
for i in 0..count {
result = FT_Open_Face(
projects / mpd_info_screen / commitdiff