organize use statements

macos-click-through
Keith Simmons 3 years ago
parent 3c2250ed24
commit 5c4026c4a4

@ -6,6 +6,7 @@ use std::{
process::Stdio, process::Stdio,
}; };
use nvim_rs::{error::LoopError, neovim::Neovim, Handler};
use tokio::{ use tokio::{
io::split, io::split,
net::{TcpStream, ToSocketAddrs}, net::{TcpStream, ToSocketAddrs},
@ -13,8 +14,6 @@ use tokio::{
spawn, spawn,
task::JoinHandle, task::JoinHandle,
}; };
use nvim_rs::{error::LoopError, neovim::Neovim, Handler};
use tokio_util::compat::TokioAsyncReadCompatExt; use tokio_util::compat::TokioAsyncReadCompatExt;
use crate::bridge::{TxWrapper, WrapTx}; use crate::bridge::{TxWrapper, WrapTx};

@ -1,7 +1,8 @@
use std::convert::TryInto; use std::{
use std::error; convert::TryInto,
use std::fmt; error,
use std::fmt::Debug; fmt::{self, Debug},
};
use log::debug; use log::debug;
use rmpv::Value; use rmpv::Value;

@ -4,14 +4,15 @@ use nvim_rs::{Handler, Neovim};
use rmpv::Value; use rmpv::Value;
use tokio::task; use tokio::task;
use super::events::parse_redraw_event;
#[cfg(windows)] #[cfg(windows)]
use super::ui_commands::{ParallelCommand, UiCommand}; use crate::bridge::ui_commands::{ParallelCommand, UiCommand};
use crate::bridge::TxWrapper; use crate::{
use crate::editor::EditorCommand; bridge::{events::parse_redraw_event, TxWrapper},
use crate::error_handling::ResultPanicExplanation; editor::EditorCommand,
use crate::event_aggregator::EVENT_AGGREGATOR; error_handling::ResultPanicExplanation,
use crate::settings::SETTINGS; event_aggregator::EVENT_AGGREGATOR,
settings::SETTINGS,
};
#[derive(Clone)] #[derive(Clone)]
pub struct NeovimHandler {} pub struct NeovimHandler {}

@ -4,19 +4,18 @@ mod handler;
mod tx_wrapper; mod tx_wrapper;
mod ui_commands; mod ui_commands;
use std::path::Path; use std::{path::Path, process::Stdio, sync::Arc};
use std::process::Stdio;
use std::sync::Arc;
use log::{error, info, warn}; use log::{error, info, warn};
use nvim_rs::UiAttachOptions; use nvim_rs::UiAttachOptions;
use rmpv::Value; use rmpv::Value;
use tokio::process::Command; use tokio::{process::Command, runtime::Runtime};
use tokio::runtime::Runtime;
use crate::{
cmd_line::CmdLineSettings, error_handling::ResultPanicExplanation, running_tracker::*,
settings::*,
};
use crate::running_tracker::*;
use crate::settings::*;
use crate::{cmd_line::CmdLineSettings, error_handling::ResultPanicExplanation};
pub use events::*; pub use events::*;
use handler::NeovimHandler; use handler::NeovimHandler;
pub use tx_wrapper::{TxWrapper, WrapTx}; pub use tx_wrapper::{TxWrapper, WrapTx};

@ -1,7 +1,10 @@
use std::{
io,
pin::Pin,
task::{Context, Poll},
};
use pin_project::pin_project; use pin_project::pin_project;
use std::io;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::{ use tokio::{
io::{AsyncWrite, WriteHalf}, io::{AsyncWrite, WriteHalf},
net::TcpStream, net::TcpStream,

@ -7,13 +7,13 @@ use log::trace;
use nvim_rs::{call_args, rpc::model::IntoVal, Neovim}; use nvim_rs::{call_args, rpc::model::IntoVal, Neovim};
use tokio::sync::mpsc::unbounded_channel; use tokio::sync::mpsc::unbounded_channel;
use crate::bridge::TxWrapper;
use crate::event_aggregator::EVENT_AGGREGATOR;
use crate::running_tracker::RUNNING_TRACKER;
#[cfg(windows)] #[cfg(windows)]
use crate::windows_utils::{ use crate::windows_utils::{
register_rightclick_directory, register_rightclick_file, unregister_rightclick, register_rightclick_directory, register_rightclick_file, unregister_rightclick,
}; };
use crate::{
bridge::TxWrapper, event_aggregator::EVENT_AGGREGATOR, running_tracker::RUNNING_TRACKER,
};
// Serial commands are any commands which must complete before the next value is sent. This // Serial commands are any commands which must complete before the next value is sent. This
// includes keyboard and mouse input which would cause problems if sent out of order. // includes keyboard and mouse input which would cause problems if sent out of order.

@ -1,5 +1,7 @@
use std::fmt::Debug; use std::{
use std::sync::mpsc::{SendError, Sender}; fmt::Debug,
sync::mpsc::{SendError, Sender},
};
use log::trace; use log::trace;
use tokio::sync::mpsc::{error::SendError as TokioSendError, UnboundedSender}; use tokio::sync::mpsc::{error::SendError as TokioSendError, UnboundedSender};

@ -1,5 +1,4 @@
use crate::settings::*; use crate::{dimensions::Dimensions, settings::*};
use crate::utils::Dimensions;
use clap::{App, Arg}; use clap::{App, Arg};

@ -1,6 +1,7 @@
use std::ops::{Div, Mul};
use glutin::dpi::PhysicalSize; use glutin::dpi::PhysicalSize;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::ops::{Div, Mul};
// Maybe this should be independent from serialization? // Maybe this should be independent from serialization?
#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)] #[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]

@ -1,9 +1,8 @@
use std::collections::HashMap; use std::{collections::HashMap, sync::Arc};
use std::sync::Arc;
use skia_safe::Color4f; use skia_safe::Color4f;
use super::style::{Colors, Style}; use crate::editor::style::{Colors, Style};
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum CursorShape { pub enum CursorShape {

@ -1,7 +1,6 @@
use std::sync::mpsc::{channel, Receiver, SendError, Sender}; use std::sync::mpsc::{channel, Receiver, SendError, Sender};
use super::DrawCommand; use crate::{editor::DrawCommand, event_aggregator::EVENT_AGGREGATOR};
use crate::event_aggregator::EVENT_AGGREGATOR;
pub struct DrawCommandBatcher { pub struct DrawCommandBatcher {
window_draw_command_sender: Sender<DrawCommand>, window_draw_command_sender: Sender<DrawCommand>,

@ -1,6 +1,6 @@
use std::sync::Arc; use std::sync::Arc;
use super::style::Style; use crate::editor::style::Style;
pub type GridCell = (String, Option<Arc<Style>>); pub type GridCell = (String, Option<Arc<Style>>);

@ -4,17 +4,18 @@ mod grid;
mod style; mod style;
mod window; mod window;
use std::collections::HashMap; use std::{collections::HashMap, sync::Arc, thread};
use std::sync::Arc;
use std::thread;
use log::{error, trace}; use log::{error, trace};
use crate::bridge::{GuiOption, RedrawEvent, WindowAnchor}; use crate::{
use crate::event_aggregator::EVENT_AGGREGATOR; bridge::{GuiOption, RedrawEvent, WindowAnchor},
use crate::redraw_scheduler::REDRAW_SCHEDULER; event_aggregator::EVENT_AGGREGATOR,
use crate::renderer::DrawCommand; redraw_scheduler::REDRAW_SCHEDULER,
use crate::window::WindowCommand; renderer::DrawCommand,
window::WindowCommand,
};
pub use cursor::{Cursor, CursorMode, CursorShape}; pub use cursor::{Cursor, CursorMode, CursorShape};
pub use draw_command_batcher::DrawCommandBatcher; pub use draw_command_batcher::DrawCommandBatcher;
pub use grid::CharacterGrid; pub use grid::CharacterGrid;

@ -1,14 +1,13 @@
use std::collections::HashMap; use std::{collections::HashMap, sync::Arc};
use std::sync::Arc;
use log::warn; use log::warn;
use unicode_segmentation::UnicodeSegmentation; use unicode_segmentation::UnicodeSegmentation;
use super::grid::CharacterGrid; use crate::{
use super::style::Style; bridge::GridLineCell,
use super::{AnchorInfo, DrawCommand, DrawCommandBatcher}; editor::{grid::CharacterGrid, style::Style, AnchorInfo, DrawCommand, DrawCommandBatcher},
use crate::bridge::GridLineCell; renderer::{LineFragment, WindowDrawCommand},
use crate::renderer::{LineFragment, WindowDrawCommand}; };
pub enum WindowType { pub enum WindowType {
Editor, Editor,

@ -1,6 +1,8 @@
use std::any::{type_name, Any, TypeId}; use std::{
use std::collections::{hash_map::Entry, HashMap}; any::{type_name, Any, TypeId},
use std::fmt::Debug; collections::{hash_map::Entry, HashMap},
fmt::Debug,
};
use parking_lot::{Mutex, RwLock}; use parking_lot::{Mutex, RwLock};
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver}; use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};

@ -1,8 +1,5 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
#[cfg(not(test))]
use flexi_logger::{Cleanup, Criterion, Duplicate, Logger, Naming};
// Test naming occasionally uses camelCase with underscores to separate sections of // Test naming occasionally uses camelCase with underscores to separate sections of
// the test name. // the test name.
#[cfg_attr(test, allow(non_snake_case))] #[cfg_attr(test, allow(non_snake_case))]
@ -15,6 +12,7 @@ extern crate clap;
mod bridge; mod bridge;
mod channel_utils; mod channel_utils;
mod cmd_line; mod cmd_line;
mod dimensions;
mod editor; mod editor;
mod error_handling; mod error_handling;
mod event_aggregator; mod event_aggregator;
@ -22,7 +20,6 @@ mod redraw_scheduler;
mod renderer; mod renderer;
mod running_tracker; mod running_tracker;
mod settings; mod settings;
mod utils;
mod window; mod window;
mod windows_utils; mod windows_utils;
@ -33,6 +30,8 @@ extern crate lazy_static;
use std::env::args; use std::env::args;
#[cfg(not(test))]
use flexi_logger::{Cleanup, Criterion, Duplicate, Logger, Naming};
use log::trace; use log::trace;
use bridge::start_bridge; use bridge::start_bridge;

@ -1,6 +1,10 @@
use std::sync::atomic::{AtomicBool, Ordering}; use std::{
use std::sync::Mutex; sync::{
use std::time::Instant; atomic::{AtomicBool, Ordering},
Mutex,
},
time::Instant,
};
use log::trace; use log::trace;

@ -1,7 +1,6 @@
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use crate::editor::Cursor; use crate::{editor::Cursor, redraw_scheduler::REDRAW_SCHEDULER};
use crate::redraw_scheduler::REDRAW_SCHEDULER;
#[derive(Debug)] #[derive(Debug)]
pub enum BlinkState { pub enum BlinkState {

@ -1,10 +1,13 @@
use log::error; use log::error;
use nvim_rs::Value;
use skia_safe::{paint::Style, BlendMode, Canvas, Color, Paint, Point, Rect}; use skia_safe::{paint::Style, BlendMode, Canvas, Color, Paint, Point, Rect};
use super::CursorSettings; use crate::{
use crate::editor::Cursor; editor::Cursor,
use crate::renderer::{animation_utils::*, grid_renderer::GridRenderer}; renderer::cursor_renderer::CursorSettings,
use crate::settings::*; renderer::{animation_utils::*, grid_renderer::GridRenderer},
settings::*,
};
pub trait CursorVfx { pub trait CursorVfx {
fn update( fn update(

@ -3,15 +3,16 @@ mod cursor_vfx;
use std::collections::HashMap; use std::collections::HashMap;
// use neovide_derive::SettingGroup;
use skia_safe::{Canvas, Paint, Path, Point}; use skia_safe::{Canvas, Paint, Path, Point};
use super::{GridRenderer, RenderedWindow}; use crate::{
use crate::bridge::EditorMode; bridge::EditorMode,
use crate::editor::{Cursor, CursorShape}; editor::{Cursor, CursorShape},
use crate::redraw_scheduler::REDRAW_SCHEDULER; redraw_scheduler::REDRAW_SCHEDULER,
use crate::renderer::animation_utils::*; renderer::animation_utils::*,
use crate::settings::{FromValue, SETTINGS}; renderer::{GridRenderer, RenderedWindow},
settings::{FromValue, SETTINGS},
};
use blink::*; use blink::*;

@ -3,14 +3,17 @@ use std::sync::Arc;
use log::trace; use log::trace;
use lru::LruCache; use lru::LruCache;
use skia_safe::{TextBlob, TextBlobBuilder}; use skia_safe::{TextBlob, TextBlobBuilder};
use swash::shape::ShapeContext; use swash::{
use swash::text::cluster::{CharCluster, Parser, Status, Token}; shape::ShapeContext,
use swash::text::Script; text::{
use swash::Metrics; cluster::{CharCluster, Parser, Status, Token},
Script,
},
Metrics,
};
use unicode_segmentation::UnicodeSegmentation; use unicode_segmentation::UnicodeSegmentation;
use super::font_loader::*; use crate::renderer::fonts::{font_loader::*, font_options::*};
use super::font_options::*;
#[derive(new, Clone, Hash, PartialEq, Eq, Debug)] #[derive(new, Clone, Hash, PartialEq, Eq, Debug)]
struct ShapeKey { struct ShapeKey {

@ -3,8 +3,7 @@ use std::sync::Arc;
use lru::LruCache; use lru::LruCache;
use skia_safe::{font::Edging, Data, Font, FontHinting, FontMgr, FontStyle, Typeface}; use skia_safe::{font::Edging, Data, Font, FontHinting, FontMgr, FontStyle, Typeface};
use super::font_options::FontOptions; use crate::renderer::fonts::{font_options::FontOptions, swash_font::SwashFont};
use super::swash_font::SwashFont;
static DEFAULT_FONT: &[u8] = include_bytes!("../../../assets/fonts/FiraCode-Regular.ttf"); static DEFAULT_FONT: &[u8] = include_bytes!("../../../assets/fonts/FiraCode-Regular.ttf");
static LAST_RESORT_FONT: &[u8] = include_bytes!("../../../assets/fonts/LastResort-Regular.ttf"); static LAST_RESORT_FONT: &[u8] = include_bytes!("../../../assets/fonts/LastResort-Regular.ttf");

@ -4,11 +4,13 @@ use glutin::dpi::PhysicalSize;
use log::trace; use log::trace;
use skia_safe::{colors, dash_path_effect, BlendMode, Canvas, Color, Paint, Rect, HSV}; use skia_safe::{colors, dash_path_effect, BlendMode, Canvas, Color, Paint, Rect, HSV};
use super::{CachingShaper, RendererSettings}; use crate::{
use crate::editor::{Colors, Style}; dimensions::Dimensions,
use crate::settings::*; editor::{Colors, Style},
use crate::utils::Dimensions; renderer::{CachingShaper, RendererSettings},
use crate::window::WindowSettings; settings::*,
window::WindowSettings,
};
pub struct GridRenderer { pub struct GridRenderer {
pub shaper: CachingShaper, pub shaper: CachingShaper,

@ -4,19 +4,24 @@ mod fonts;
pub mod grid_renderer; pub mod grid_renderer;
mod rendered_window; mod rendered_window;
use crate::WindowSettings; use std::{
use std::cmp::Ordering; cmp::Ordering,
use std::collections::{hash_map::Entry, HashMap}; collections::{hash_map::Entry, HashMap},
use std::sync::Arc; sync::Arc,
};
use log::error; use log::error;
use skia_safe::Canvas; use skia_safe::Canvas;
use tokio::sync::mpsc::UnboundedReceiver; use tokio::sync::mpsc::UnboundedReceiver;
use crate::bridge::EditorMode; use crate::{
use crate::editor::{Cursor, Style}; bridge::EditorMode,
use crate::event_aggregator::EVENT_AGGREGATOR; editor::{Cursor, Style},
use crate::settings::*; event_aggregator::EVENT_AGGREGATOR,
settings::*,
WindowSettings,
};
use cursor_renderer::CursorRenderer; use cursor_renderer::CursorRenderer;
pub use fonts::caching_shaper::CachingShaper; pub use fonts::caching_shaper::CachingShaper;
pub use grid_renderer::GridRenderer; pub use grid_renderer::GridRenderer;

@ -1,18 +1,19 @@
use std::collections::VecDeque; use std::{collections::VecDeque, sync::Arc};
use std::sync::Arc;
use skia_safe::canvas::{SaveLayerRec, SrcRectConstraint};
use skia_safe::gpu::SurfaceOrigin;
use skia_safe::{ use skia_safe::{
image_filters::blur, BlendMode, Budgeted, Canvas, Color, Image, ImageInfo, Paint, Point, Rect, canvas::{SaveLayerRec, SrcRectConstraint},
SamplingOptions, Surface, SurfaceProps, SurfacePropsFlags, gpu::SurfaceOrigin,
image_filters::blur,
BlendMode, Budgeted, Canvas, Color, Image, ImageInfo, Paint, Point, Rect, SamplingOptions,
Surface, SurfaceProps, SurfacePropsFlags,
}; };
use super::animation_utils::*; use crate::{
use super::{GridRenderer, RendererSettings}; dimensions::Dimensions,
use crate::editor::Style; editor::Style,
use crate::redraw_scheduler::REDRAW_SCHEDULER; redraw_scheduler::REDRAW_SCHEDULER,
use crate::utils::Dimensions; renderer::{animation_utils::*, GridRenderer, RendererSettings},
};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct LineFragment { pub struct LineFragment {

@ -1,22 +1,23 @@
use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::convert::TryInto;
mod from_value; mod from_value;
mod window_geometry; mod window_geometry;
pub use from_value::FromValue;
use log::trace; use log::trace;
use nvim_rs::Neovim; use nvim_rs::Neovim;
use parking_lot::RwLock; use parking_lot::RwLock;
pub use rmpv::Value; use rmpv::Value;
use std::{
any::{Any, TypeId},
collections::HashMap,
convert::TryInto,
};
use crate::{bridge::TxWrapper, error_handling::ResultPanicExplanation};
pub use from_value::FromValue;
pub use window_geometry::{ pub use window_geometry::{
load_last_window_settings, parse_window_geometry, save_window_geometry, load_last_window_settings, parse_window_geometry, save_window_geometry,
PersistentWindowSettings, DEFAULT_WINDOW_GEOMETRY, PersistentWindowSettings, DEFAULT_WINDOW_GEOMETRY,
}; };
use crate::bridge::TxWrapper;
use crate::error_handling::ResultPanicExplanation;
lazy_static! { lazy_static! {
pub static ref SETTINGS: Settings = Settings::new(); pub static ref SETTINGS: Settings = Settings::new();
} }

@ -1,9 +1,9 @@
use crate::settings::SETTINGS; use std::path::PathBuf;
use crate::utils::Dimensions;
use crate::window::WindowSettings;
use glutin::dpi::PhysicalPosition; use glutin::dpi::PhysicalPosition;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use crate::{dimensions::Dimensions, settings::SETTINGS, window::WindowSettings};
const SETTINGS_FILE: &str = "neovide-settings.json"; const SETTINGS_FILE: &str = "neovide-settings.json";

@ -1,3 +0,0 @@
mod dimensions;
pub use dimensions::*;

@ -1,13 +1,15 @@
use glutin::event::{ElementState, Event, KeyEvent, WindowEvent}; use glutin::{
use glutin::keyboard::Key; event::{ElementState, Event, KeyEvent, WindowEvent},
use glutin::keyboard::Key::Dead; keyboard::{Key, Key::Dead},
platform::modifier_supplement::KeyEventExtModifierSupplement,
use glutin::platform::modifier_supplement::KeyEventExtModifierSupplement; };
use crate::bridge::{SerialCommand, UiCommand}; use crate::{
use crate::event_aggregator::EVENT_AGGREGATOR; bridge::{SerialCommand, UiCommand},
use crate::settings::SETTINGS; event_aggregator::EVENT_AGGREGATOR,
use crate::window::KeyboardSettings; settings::SETTINGS,
window::KeyboardSettings,
};
enum InputEvent { enum InputEvent {
KeyEvent(KeyEvent), KeyEvent(KeyEvent),
@ -89,8 +91,9 @@ impl KeyboardManager {
// And a key was pressed // And a key was pressed
if key_event.state == ElementState::Pressed { if key_event.state == ElementState::Pressed {
if let Some(keybinding) = self.maybe_get_keybinding(key_event) { if let Some(keybinding) = self.maybe_get_keybinding(key_event) {
EVENT_AGGREGATOR EVENT_AGGREGATOR.send(UiCommand::Serial(
.send(UiCommand::Serial(SerialCommand::Keyboard(keybinding))); SerialCommand::Keyboard(keybinding),
));
} }
next_dead_key = None; next_dead_key = None;
} else if key_event.state == ElementState::Released { } else if key_event.state == ElementState::Released {
@ -103,8 +106,9 @@ impl KeyboardManager {
} }
InputEvent::ImeInput(raw_input) => { InputEvent::ImeInput(raw_input) => {
if self.prev_dead_key.is_none() { if self.prev_dead_key.is_none() {
EVENT_AGGREGATOR EVENT_AGGREGATOR.send(UiCommand::Serial(
.send(UiCommand::Serial(SerialCommand::Keyboard(raw_input.to_string()))); SerialCommand::Keyboard(raw_input.to_string()),
));
} }
} }
} }

@ -27,6 +27,7 @@ use renderer::SkiaRenderer;
use crate::{ use crate::{
bridge::{ParallelCommand, UiCommand}, bridge::{ParallelCommand, UiCommand},
cmd_line::CmdLineSettings, cmd_line::CmdLineSettings,
dimensions::Dimensions,
editor::EditorCommand, editor::EditorCommand,
event_aggregator::EVENT_AGGREGATOR, event_aggregator::EVENT_AGGREGATOR,
redraw_scheduler::REDRAW_SCHEDULER, redraw_scheduler::REDRAW_SCHEDULER,
@ -35,7 +36,6 @@ use crate::{
settings::{ settings::{
load_last_window_settings, save_window_geometry, PersistentWindowSettings, SETTINGS, load_last_window_settings, save_window_geometry, PersistentWindowSettings, SETTINGS,
}, },
utils::Dimensions,
}; };
pub use settings::{KeyboardSettings, WindowSettings}; pub use settings::{KeyboardSettings, WindowSettings};

@ -8,12 +8,14 @@ use glutin::{
}; };
use skia_safe::Rect; use skia_safe::Rect;
use super::keyboard_manager::KeyboardManager; use crate::{
use crate::bridge::{SerialCommand, UiCommand}; bridge::{SerialCommand, UiCommand},
use crate::event_aggregator::EVENT_AGGREGATOR; event_aggregator::EVENT_AGGREGATOR,
use crate::renderer::{Renderer, WindowDrawDetails}; renderer::{Renderer, WindowDrawDetails},
use crate::settings::SETTINGS; settings::SETTINGS,
use crate::window::WindowSettings; window::keyboard_manager::KeyboardManager,
window::WindowSettings,
};
fn clamp_position( fn clamp_position(
position: PhysicalPosition<f32>, position: PhysicalPosition<f32>,

@ -1,9 +1,11 @@
use skia_safe::gpu::gl::FramebufferInfo;
use skia_safe::gpu::{BackendRenderTarget, DirectContext, SurfaceOrigin};
use skia_safe::{Canvas, ColorType, Surface};
use std::convert::TryInto; use std::convert::TryInto;
use gl::types::*; use gl::types::*;
use skia_safe::{
gpu::{gl::FramebufferInfo, BackendRenderTarget, DirectContext, SurfaceOrigin},
Canvas, ColorType, Surface,
};
type WindowedContext = glutin::ContextWrapper<glutin::PossiblyCurrent, glutin::window::Window>; type WindowedContext = glutin::ContextWrapper<glutin::PossiblyCurrent, glutin::window::Window>;
fn create_surface( fn create_surface(

@ -1,7 +1,7 @@
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
use { use std::{
std::ffi::CString, ffi::CString,
std::ptr::{null, null_mut}, ptr::{null, null_mut},
}; };
#[cfg(windows)] #[cfg(windows)]

Loading…
Cancel
Save