use parking_lot::ReentrantMutex;
use std::cell::UnsafeCell;
use std::ffi::{CStr, CString};
use std::ops::Drop;
use std::path::PathBuf;
use std::ptr;
use crate::clipboard::{ClipboardBackend, ClipboardContext};
use crate::fonts::atlas::{FontAtlas, FontId, SharedFontAtlas};
use crate::io::Io;
use crate::style::Style;
use crate::{sys, DrawData};
use crate::{MouseCursor, Ui};
#[derive(Debug)]
pub struct Context {
raw: *mut sys::ImGuiContext,
shared_font_atlas: Option<SharedFontAtlas>,
ini_filename: Option<CString>,
log_filename: Option<CString>,
platform_name: Option<CString>,
renderer_name: Option<CString>,
clipboard_ctx: Box<UnsafeCell<ClipboardContext>>,
#[cfg(feature = "docking")]
platform_viewport_ctx: Box<UnsafeCell<crate::PlatformViewportContext>>,
#[cfg(feature = "docking")]
renderer_viewport_ctx: Box<UnsafeCell<crate::RendererViewportContext>>,
ui: Ui,
}
static CTX_MUTEX: ReentrantMutex<()> = parking_lot::const_reentrant_mutex(());
fn clear_current_context() {
unsafe {
sys::igSetCurrentContext(ptr::null_mut());
}
}
fn no_current_context() -> bool {
let ctx = unsafe { sys::igGetCurrentContext() };
ctx.is_null()
}
impl Context {
#[doc(alias = "CreateContext")]
pub fn create() -> Self {
Self::create_internal(None)
}
#[doc(alias = "CreateContext")]
pub fn create_with_shared_font_atlas(shared_font_atlas: SharedFontAtlas) -> Self {
Self::create_internal(Some(shared_font_atlas))
}
#[doc(alias = "CreateContext")]
pub fn suspend(self) -> SuspendedContext {
let _guard = CTX_MUTEX.lock();
assert!(
self.is_current_context(),
"context to be suspended is not the active context"
);
clear_current_context();
SuspendedContext(self)
}
pub fn ini_filename(&self) -> Option<PathBuf> {
let io = self.io();
if io.ini_filename.is_null() {
None
} else {
let s = unsafe { CStr::from_ptr(io.ini_filename) };
Some(PathBuf::from(s.to_str().ok()?))
}
}
pub fn set_ini_filename<T: Into<Option<PathBuf>>>(&mut self, ini_filename: T) {
let ini_filename: Option<PathBuf> = ini_filename.into();
let ini_filename = ini_filename.and_then(|v| CString::new(v.to_str()?).ok());
self.io_mut().ini_filename = ini_filename
.as_ref()
.map(|x| x.as_ptr())
.unwrap_or(ptr::null());
self.ini_filename = ini_filename;
}
pub fn log_filename(&self) -> Option<PathBuf> {
let io = self.io();
if io.log_filename.is_null() {
None
} else {
let cstr = unsafe { CStr::from_ptr(io.log_filename) };
Some(PathBuf::from(cstr.to_str().ok()?))
}
}
pub fn set_log_filename<T: Into<Option<PathBuf>>>(&mut self, log_filename: T) {
let log_filename = log_filename
.into()
.and_then(|v| CString::new(v.to_str()?).ok());
self.io_mut().log_filename = log_filename
.as_ref()
.map(|x| x.as_ptr())
.unwrap_or(ptr::null());
self.log_filename = log_filename;
}
pub fn platform_name(&self) -> Option<&str> {
let io = self.io();
if io.backend_platform_name.is_null() {
None
} else {
let cstr = unsafe { CStr::from_ptr(io.backend_platform_name) };
cstr.to_str().ok()
}
}
pub fn set_platform_name<T: Into<Option<String>>>(&mut self, platform_name: T) {
let platform_name: Option<CString> =
platform_name.into().and_then(|v| CString::new(v).ok());
self.io_mut().backend_platform_name = platform_name
.as_ref()
.map(|x| x.as_ptr())
.unwrap_or(ptr::null());
self.platform_name = platform_name;
}
pub fn renderer_name(&self) -> Option<&str> {
let io = self.io();
if io.backend_renderer_name.is_null() {
None
} else {
let cstr = unsafe { CStr::from_ptr(io.backend_renderer_name) };
cstr.to_str().ok()
}
}
pub fn set_renderer_name<T: Into<Option<String>>>(&mut self, renderer_name: T) {
let renderer_name: Option<CString> =
renderer_name.into().and_then(|v| CString::new(v).ok());
self.io_mut().backend_renderer_name = renderer_name
.as_ref()
.map(|x| x.as_ptr())
.unwrap_or(ptr::null());
self.renderer_name = renderer_name;
}
#[doc(alias = "LoadIniSettingsFromMemory")]
pub fn load_ini_settings(&mut self, data: &str) {
unsafe { sys::igLoadIniSettingsFromMemory(data.as_ptr() as *const _, data.len()) }
}
#[doc(alias = "SaveInitSettingsToMemory")]
pub fn save_ini_settings(&mut self, buf: &mut String) {
let data = unsafe { CStr::from_ptr(sys::igSaveIniSettingsToMemory(ptr::null_mut())) };
buf.push_str(&data.to_string_lossy());
}
pub fn set_clipboard_backend<T: ClipboardBackend>(&mut self, backend: T) {
let clipboard_ctx: Box<UnsafeCell<_>> = Box::new(ClipboardContext::new(backend).into());
let io = self.io_mut();
io.set_clipboard_text_fn = Some(crate::clipboard::set_clipboard_text);
io.get_clipboard_text_fn = Some(crate::clipboard::get_clipboard_text);
io.clipboard_user_data = clipboard_ctx.get() as *mut _;
self.clipboard_ctx = clipboard_ctx;
}
fn create_internal(mut shared_font_atlas: Option<SharedFontAtlas>) -> Self {
let _guard = CTX_MUTEX.lock();
assert!(
no_current_context(),
"A new active context cannot be created, because another one already exists"
);
let shared_font_atlas_ptr = match &mut shared_font_atlas {
Some(shared_font_atlas) => shared_font_atlas.as_ptr_mut(),
None => ptr::null_mut(),
};
let raw = unsafe { sys::igCreateContext(shared_font_atlas_ptr) };
Context {
raw,
shared_font_atlas,
ini_filename: None,
log_filename: None,
platform_name: None,
renderer_name: None,
clipboard_ctx: Box::new(ClipboardContext::dummy().into()),
#[cfg(feature = "docking")]
platform_viewport_ctx: Box::new(UnsafeCell::new(
crate::PlatformViewportContext::dummy(),
)),
#[cfg(feature = "docking")]
renderer_viewport_ctx: Box::new(UnsafeCell::new(
crate::RendererViewportContext::dummy(),
)),
ui: Ui {
buffer: UnsafeCell::new(crate::string::UiBuffer::new(1024)),
},
}
}
fn is_current_context(&self) -> bool {
let ctx = unsafe { sys::igGetCurrentContext() };
self.raw == ctx
}
}
impl Drop for Context {
#[doc(alias = "DestroyContext")]
fn drop(&mut self) {
let _guard = CTX_MUTEX.lock();
unsafe {
if !sys::igGetCurrentContext().is_null() && sys::igGetFrameCount() > 0 {
sys::igEndFrame();
}
sys::igDestroyContext(self.raw);
}
}
}
#[derive(Debug)]
pub struct SuspendedContext(Context);
impl SuspendedContext {
#[doc(alias = "CreateContext")]
pub fn create() -> Self {
Self::create_internal(None)
}
pub fn create_with_shared_font_atlas(shared_font_atlas: SharedFontAtlas) -> Self {
Self::create_internal(Some(shared_font_atlas))
}
#[doc(alias = "SetCurrentContext")]
pub fn activate(self) -> Result<Context, SuspendedContext> {
let _guard = CTX_MUTEX.lock();
if no_current_context() {
unsafe {
sys::igSetCurrentContext(self.0.raw);
}
Ok(self.0)
} else {
Err(self)
}
}
fn create_internal(shared_font_atlas: Option<SharedFontAtlas>) -> Self {
let _guard = CTX_MUTEX.lock();
let raw = unsafe { sys::igCreateContext(ptr::null_mut()) };
let ctx = Context {
raw,
shared_font_atlas,
ini_filename: None,
log_filename: None,
platform_name: None,
renderer_name: None,
clipboard_ctx: Box::new(ClipboardContext::dummy().into()),
#[cfg(feature = "docking")]
platform_viewport_ctx: Box::new(UnsafeCell::new(
crate::PlatformViewportContext::dummy(),
)),
#[cfg(feature = "docking")]
renderer_viewport_ctx: Box::new(UnsafeCell::new(
crate::RendererViewportContext::dummy(),
)),
ui: Ui {
buffer: UnsafeCell::new(crate::string::UiBuffer::new(1024)),
},
};
if ctx.is_current_context() {
clear_current_context();
}
SuspendedContext(ctx)
}
}
#[test]
fn test_one_context() {
let _guard = crate::test::TEST_MUTEX.lock();
let _ctx = Context::create();
assert!(!no_current_context());
}
#[test]
fn test_drop_clears_current_context() {
let _guard = crate::test::TEST_MUTEX.lock();
{
let _ctx1 = Context::create();
assert!(!no_current_context());
}
assert!(no_current_context());
{
let _ctx2 = Context::create();
assert!(!no_current_context());
}
assert!(no_current_context());
}
#[test]
fn test_new_suspended() {
let _guard = crate::test::TEST_MUTEX.lock();
let ctx = Context::create();
let _suspended = SuspendedContext::create();
assert!(ctx.is_current_context());
::std::mem::drop(_suspended);
assert!(ctx.is_current_context());
}
#[test]
fn test_suspend() {
let _guard = crate::test::TEST_MUTEX.lock();
let ctx = Context::create();
assert!(!no_current_context());
let _suspended = ctx.suspend();
assert!(no_current_context());
let _ctx2 = Context::create();
}
#[test]
fn test_drop_suspended() {
let _guard = crate::test::TEST_MUTEX.lock();
let suspended = Context::create().suspend();
assert!(no_current_context());
let ctx2 = Context::create();
::std::mem::drop(suspended);
assert!(ctx2.is_current_context());
}
#[test]
fn test_suspend_activate() {
let _guard = crate::test::TEST_MUTEX.lock();
let suspended = Context::create().suspend();
assert!(no_current_context());
let ctx = suspended.activate().unwrap();
assert!(ctx.is_current_context());
}
#[test]
fn test_suspend_failure() {
let _guard = crate::test::TEST_MUTEX.lock();
let suspended = Context::create().suspend();
let _ctx = Context::create();
assert!(suspended.activate().is_err());
}
#[test]
fn test_shared_font_atlas() {
let _guard = crate::test::TEST_MUTEX.lock();
let atlas = SharedFontAtlas::create();
let suspended1 = SuspendedContext::create_with_shared_font_atlas(atlas.clone());
let mut ctx2 = Context::create_with_shared_font_atlas(atlas);
{
let _borrow = ctx2.fonts();
}
let _suspended2 = ctx2.suspend();
let mut ctx = suspended1.activate().unwrap();
let _borrow = ctx.fonts();
}
#[test]
fn test_ini_load_save() {
let (_guard, mut ctx) = crate::test::test_ctx();
let data = "[Window][Debug##Default]
Pos=60,60
Size=400,400
Collapsed=0";
ctx.load_ini_settings(data);
let mut buf = String::new();
ctx.save_ini_settings(&mut buf);
assert_eq!(data.trim(), buf.trim());
}
#[test]
fn test_default_ini_filename() {
let _guard = crate::test::TEST_MUTEX.lock();
let ctx = Context::create();
assert_eq!(ctx.ini_filename(), Some(PathBuf::from("imgui.ini")));
}
#[test]
fn test_set_ini_filename() {
let (_guard, mut ctx) = crate::test::test_ctx();
ctx.set_ini_filename(Some(PathBuf::from("test.ini")));
assert_eq!(ctx.ini_filename(), Some(PathBuf::from("test.ini")));
}
#[test]
fn test_default_log_filename() {
let _guard = crate::test::TEST_MUTEX.lock();
let ctx = Context::create();
assert_eq!(ctx.log_filename(), Some(PathBuf::from("imgui_log.txt")));
}
#[test]
fn test_set_log_filename() {
let (_guard, mut ctx) = crate::test::test_ctx();
ctx.set_log_filename(Some(PathBuf::from("test.log")));
assert_eq!(ctx.log_filename(), Some(PathBuf::from("test.log")));
}
impl Context {
pub fn io(&self) -> &Io {
unsafe {
&*(sys::igGetIO() as *const Io)
}
}
pub fn io_mut(&mut self) -> &mut Io {
unsafe {
&mut *(sys::igGetIO() as *mut Io)
}
}
#[doc(alias = "GetStyle")]
pub fn style(&self) -> &Style {
unsafe {
&*(sys::igGetStyle() as *const Style)
}
}
#[doc(alias = "GetStyle")]
pub fn style_mut(&mut self) -> &mut Style {
unsafe {
&mut *(sys::igGetStyle() as *mut Style)
}
}
pub fn fonts(&mut self) -> &mut FontAtlas {
unsafe { &mut *self.io_mut().fonts }
}
pub fn clone_shared_font_atlas(&mut self) -> Option<SharedFontAtlas> {
self.shared_font_atlas.clone()
}
pub fn frame(&mut self) -> &mut Ui {
self.new_frame()
}
#[doc(alias = "NewFame")]
pub fn new_frame(&mut self) -> &mut Ui {
let default_font = self.io().font_default;
if !default_font.is_null() && self.fonts().get_font(FontId(default_font)).is_none() {
self.io_mut().font_default = ptr::null_mut();
}
unsafe {
sys::igNewFrame();
}
&mut self.ui
}
#[doc(alias = "Render", alias = "GetDrawData")]
pub fn render(&mut self) -> &DrawData {
unsafe {
sys::igRender();
&*(sys::igGetDrawData() as *mut DrawData)
}
}
#[doc(alias = "GetMouseCursor")]
pub fn mouse_cursor(&self) -> Option<MouseCursor> {
match unsafe { sys::igGetMouseCursor() } {
sys::ImGuiMouseCursor_Arrow => Some(MouseCursor::Arrow),
sys::ImGuiMouseCursor_TextInput => Some(MouseCursor::TextInput),
sys::ImGuiMouseCursor_ResizeAll => Some(MouseCursor::ResizeAll),
sys::ImGuiMouseCursor_ResizeNS => Some(MouseCursor::ResizeNS),
sys::ImGuiMouseCursor_ResizeEW => Some(MouseCursor::ResizeEW),
sys::ImGuiMouseCursor_ResizeNESW => Some(MouseCursor::ResizeNESW),
sys::ImGuiMouseCursor_ResizeNWSE => Some(MouseCursor::ResizeNWSE),
sys::ImGuiMouseCursor_Hand => Some(MouseCursor::Hand),
sys::ImGuiMouseCursor_NotAllowed => Some(MouseCursor::NotAllowed),
_ => None,
}
}
}
#[cfg(feature = "docking")]
impl Context {
pub fn platform_io(&self) -> &crate::PlatformIo {
unsafe {
&*(sys::igGetPlatformIO() as *const crate::PlatformIo)
}
}
pub fn platform_io_mut(&mut self) -> &mut crate::PlatformIo {
unsafe {
&mut *(sys::igGetPlatformIO() as *mut crate::PlatformIo)
}
}
pub fn main_viewport(&self) -> &crate::Viewport {
unsafe {
&*(sys::igGetMainViewport() as *mut crate::Viewport)
}
}
pub fn main_viewport_mut(&mut self) -> &mut crate::Viewport {
unsafe {
&mut *(sys::igGetMainViewport() as *mut crate::Viewport)
}
}
pub fn viewport_by_id(&self, id: crate::Id) -> Option<&crate::Viewport> {
unsafe {
(sys::igFindViewportByID(id.0) as *const crate::Viewport).as_ref()
}
}
pub fn viewport_by_id_mut(&mut self, id: crate::Id) -> Option<&mut crate::Viewport> {
unsafe {
(sys::igFindViewportByID(id.0) as *mut crate::Viewport).as_mut()
}
}
pub fn viewports(&self) -> impl Iterator<Item = &crate::Viewport> {
let slice = self.platform_io().viewports.as_slice();
unsafe { slice.iter().map(|ptr| &**ptr) }
}
pub fn viewports_mut(&mut self) -> impl Iterator<Item = &mut crate::Viewport> {
let slice = self.platform_io_mut().viewports.as_slice();
unsafe { slice.iter().map(|ptr| &mut **ptr) }
}
pub fn set_platform_backend<T: crate::PlatformViewportBackend>(&mut self, backend: T) {
let ctx = Box::new(UnsafeCell::new(crate::PlatformViewportContext {
backend: Box::new(backend),
}));
let io = self.io_mut();
io.backend_platform_user_data = ctx.get() as *mut _;
let pio = self.platform_io_mut();
pio.platform_create_window = Some(crate::platform_io::platform_create_window);
pio.platform_destroy_window = Some(crate::platform_io::platform_destroy_window);
pio.platform_show_window = Some(crate::platform_io::platform_show_window);
pio.platform_set_window_pos = Some(crate::platform_io::platform_set_window_pos);
unsafe {
crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowPos(
pio,
crate::platform_io::platform_get_window_pos,
);
}
pio.platform_set_window_size = Some(crate::platform_io::platform_set_window_size);
unsafe {
crate::platform_io::ImGuiPlatformIO_Set_Platform_GetWindowSize(
pio,
crate::platform_io::platform_get_window_size,
);
}
pio.platform_set_window_focus = Some(crate::platform_io::platform_set_window_focus);
pio.platform_get_window_focus = Some(crate::platform_io::platform_get_window_focus);
pio.platform_get_window_minimized = Some(crate::platform_io::platform_get_window_minimized);
pio.platform_set_window_title = Some(crate::platform_io::platform_set_window_title);
pio.platform_set_window_alpha = Some(crate::platform_io::platform_set_window_alpha);
pio.platform_update_window = Some(crate::platform_io::platform_update_window);
pio.platform_render_window = Some(crate::platform_io::platform_render_window);
pio.platform_swap_buffers = Some(crate::platform_io::platform_swap_buffers);
pio.platform_create_vk_surface = Some(crate::platform_io::platform_create_vk_surface);
self.platform_viewport_ctx = ctx;
}
pub fn set_renderer_backend<T: crate::RendererViewportBackend>(&mut self, backend: T) {
let ctx = Box::new(UnsafeCell::new(crate::RendererViewportContext {
backend: Box::new(backend),
}));
let io = self.io_mut();
io.backend_renderer_user_data = ctx.get() as *mut _;
let pio = self.platform_io_mut();
pio.renderer_create_window = Some(crate::platform_io::renderer_create_window);
pio.renderer_destroy_window = Some(crate::platform_io::renderer_destroy_window);
pio.renderer_set_window_size = Some(crate::platform_io::renderer_set_window_size);
pio.renderer_render_window = Some(crate::platform_io::renderer_render_window);
pio.renderer_swap_buffers = Some(crate::platform_io::renderer_swap_buffers);
self.renderer_viewport_ctx = ctx;
}
pub fn update_platform_windows(&mut self) {
unsafe {
sys::igUpdatePlatformWindows();
}
}
pub fn render_platform_windows_default(&mut self) {
unsafe {
sys::igRenderPlatformWindowsDefault(std::ptr::null_mut(), std::ptr::null_mut());
}
}
}