reorganised

Author: jackyarndley

Cargo.lock

@@ -0,0 +1,128 @@
+use std::sync::Arc;
+// use std::time::Instant;
+use parking_lot::Mutex;
+
+use druid::{AppLauncher, LocalizedString, WindowDesc};
+
+use rust_fractal::{renderer::FractalRenderer};
+use rust_fractal::util::{extended_to_string_long, string_to_extended};
+use rust_fractal::util::data_export::ColoringType;
+
+use config::{Config, File};
+
+use std::thread;
+use std::sync::mpsc;
+use std::sync::atomic::AtomicBool;
+
+use rust_fractal_gui::theme::*;
+use rust_fractal_gui::render_thread::testing_renderer;
+use rust_fractal_gui::ui;
+use rust_fractal_gui::widgets::FractalData;
+
+pub fn main() {
+    // Setup the default settings. These are stored in start.toml file
+    let mut settings = Config::default();
+    settings.merge(File::with_name("start.toml")).unwrap();
+
+    if settings.get_bool("show_output").unwrap() {
+        println!(" {:<15}| {:<15}| {:<15}| {:<6}| {:<15}| {:<15}| {:<15}| {:<6}| {:<15}", "Zoom", "Approx [ms]", "Skipped [it]", "Order", "Maximum [it]", "Iteration [ms]", "Correct [ms]", "Ref", "Frame [ms]");
+    };
+
+    let shared_settings = Arc::new(Mutex::new(settings.clone()));
+    let shared_renderer = Arc::new(Mutex::new(FractalRenderer::new(settings.clone())));
+    let shared_stop_flag = Arc::new(AtomicBool::new(false));
+    let shared_repeat_flag = Arc::new(AtomicBool::new(false));
+
+    let thread_settings = shared_settings.clone();
+    let thread_renderer = shared_renderer.clone();
+    let thread_stop_flag = shared_stop_flag.clone();
+    let thread_repeat_flag = shared_repeat_flag.clone();
+
+    let buffer = shared_renderer.lock().data_export.clone();
+
+    let window = WindowDesc::new(ui::window_main(shared_renderer.clone())).title(
+        LocalizedString::new("rust-fractal"),
+    ).window_size((1392.0, 830.0)).resizable(true).menu(ui::make_menu);
+
+    let launcher = AppLauncher::with_window(window);
+
+    let event_sink = launcher.get_external_handle();
+
+    let (sender, reciever) = mpsc::channel();
+
+    let mut center_reference_zoom = string_to_extended(&settings.get_str("zoom").unwrap());
+    center_reference_zoom.exponent += 40;
+
+    thread::spawn(move || testing_renderer(event_sink, reciever, thread_settings, thread_renderer, thread_stop_flag, thread_repeat_flag));
+
+    launcher
+        .configure_env(|env, _| configure_env(env))
+        .launch(FractalData {
+            image_width: settings.get_int("image_width").unwrap(),
+            image_height: settings.get_int("image_height").unwrap(),
+            real: settings.get_str("real").unwrap(),
+            imag: settings.get_str("imag").unwrap(),
+            zoom: settings.get_str("zoom").unwrap(),
+            root_zoom: "1E0".to_string(),
+            iteration_limit: settings.get_int("iterations").unwrap(),
+            rotation: settings.get_float("rotate").unwrap(),
+            order: settings.get_int("approximation_order").unwrap(),
+            period: 0,
+            palette_source: "default".to_string(),
+            palette_cyclic: settings.get_bool("palette_cyclic").unwrap(),
+            palette_iteration_span: settings.get_float("palette_iteration_span").unwrap(),
+            palette_offset: settings.get_float("palette_offset").unwrap(),
+            rendering_progress: 0.0,
+            root_progress: 1.0,
+            rendering_stage: 1,
+            rendering_time: 0,
+            root_iteration: 64,
+            root_stage: 0,
+            min_valid_iterations: 1,
+            max_valid_iterations: 1,
+            min_iterations: 1,
+            max_iterations: 1,
+            display_glitches: settings.get_bool("display_glitches").unwrap(),
+            glitch_tolerance: settings.get_float("glitch_tolerance").unwrap(),
+            glitch_percentage: settings.get_float("glitch_percentage").unwrap(),
+            iteration_interval: settings.get_int("data_storage_interval").unwrap(),
+            series_approximation_tiled: settings.get_bool("series_approximation_tiled").unwrap(),
+            series_approximation_enabled: settings.get_bool("series_approximation_enabled").unwrap(),
+            probe_sampling: settings.get_int("probe_sampling").unwrap(),
+            jitter: settings.get_bool("jitter").unwrap(),
+            jitter_factor: settings.get_float("jitter_factor").unwrap(),
+            auto_adjust_iterations: settings.get_bool("auto_adjust_iterations").unwrap(),
+            remove_centre: settings.get_bool("remove_centre").unwrap(),
+            renderer: shared_renderer,
+            settings: shared_settings,
+            sender: Arc::new(Mutex::new(sender)),
+            stop_flag: shared_stop_flag,
+            repeat_flag: shared_repeat_flag,
+            buffer,
+            need_full_rerender: false,
+            zoom_out_enabled: false,
+            pixel_pos: [0, 0],
+            pixel_iterations: 1,
+            pixel_smooth: 0.0,
+            pixel_rgb: Arc::new(Mutex::new(vec![0u8; 255 * 3])),
+            coloring_type: ColoringType::SmoothIteration,
+            mouse_mode: 0,
+            current_tab: 0,
+            zoom_scale_factor: settings.get_float("zoom_scale").unwrap(),
+            root_zoom_factor: 0.5,
+            center_reference_zoom: extended_to_string_long(center_reference_zoom),
+            reference_count: 1,
+            stripe_scale: settings.get_float("stripe_scale").unwrap() as f32,
+            distance_transition: settings.get_float("distance_transition").unwrap() as f32,
+            distance_color: settings.get_bool("distance_color").unwrap(),
+            lighting: settings.get_bool("lighting").unwrap(),
+            lighting_direction: settings.get_float("lighting_direction").unwrap(),
+            lighting_azimuth: settings.get_float("lighting_azimuth").unwrap(),
+            lighting_opacity: settings.get_float("lighting_opacity").unwrap(),
+            lighting_ambient: settings.get_float("lighting_ambient").unwrap(),
+            lighting_diffuse: settings.get_float("lighting_diffuse").unwrap(),
+            lighting_specular: settings.get_float("lighting_specular").unwrap(),
+            lighting_shininess: settings.get_int("lighting_shininess").unwrap(),
+        })
+        .expect("launch failed");
+}

src/bin/main.rs

@@ -1,8 +1,6 @@
 use druid::Selector;
 
-use rust_fractal::util::{ComplexExtended, FloatExtended};
-
-use crate::ColoringType;
+use rust_fractal::util::{ComplexExtended, FloatExtended, data_export::ColoringType};
 
 pub const RESET_RENDERER_FAST: Selector<()> = Selector::new("reset_renderer_fast");
 pub const RESET_RENDERER_FULL: Selector<()> = Selector::new("reset_renderer_full");

src/commands.rs

@@ -1,67 +1,9 @@
-use crate::{FractalData, commands::{UPDATE_PALETTE, UPDATE_PIXEL_INFORMATION}};
+use crate::{widgets::FractalData, commands::{UPDATE_PALETTE, UPDATE_PIXEL_INFORMATION}};
 
-use druid::piet::{FontFamily, PietText, ImageFormat, ImageBuf};
+use druid::piet::{ImageFormat, ImageBuf};
 use druid::widget::prelude::*;
-use druid::{ArcStr, Color, FontDescriptor, Point, TextLayout, WidgetPod};
 use druid::widget::{Controller, Image};
 
-const LINE_HEIGHT_FACTOR: f64 = 1.2;
-const X_PADDING: f64 = 5.0;
-pub struct NoUpdateLabel {
-    text: TextLayout<ArcStr>,
-    // Does the layout need to be changed?
-    needs_update: bool,
-    font_size: f64
-}
-
-impl NoUpdateLabel {
-    pub fn new(font_size: f64) -> NoUpdateLabel {
-        NoUpdateLabel {
-            text: TextLayout::new(),
-            needs_update: true,
-            font_size
-        }
-    }
-
-    fn make_layout_if_needed(&mut self, value: &str, t: &mut PietText, env: &Env) {
-        if self.needs_update {
-            self.text
-                .set_text(value.into());
-            self.text
-                .set_font(FontDescriptor::new(FontFamily::MONOSPACE).with_size(self.font_size));
-            self.text.set_text_color(Color::WHITE);
-            self.text.rebuild_if_needed(t, env);
-
-            self.needs_update = false;
-        }
-    }
-}
-
-impl Widget<String> for NoUpdateLabel {
-    fn event(&mut self, _: &mut EventCtx, _: &Event, _: &mut String, _: &Env) {}
-
-    fn lifecycle(&mut self, _: &mut LifeCycleCtx, _: &LifeCycle, _: &String, _: &Env) {}
-
-    fn update(&mut self, ctx: &mut UpdateCtx, _: &String, _: &String, _: &Env) {
-        self.needs_update = true;
-        ctx.request_paint();
-    }
-
-    fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints, data: &String, env: &Env) -> Size {
-        self.make_layout_if_needed(&data, &mut ctx.text(), env);
-        bc.constrain((
-            self.text.size().width + 2.0 * X_PADDING,
-            self.font_size * LINE_HEIGHT_FACTOR,
-        ))
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &String, env: &Env) {
-        self.make_layout_if_needed(&data, &mut ctx.text(), env);
-        let origin = Point::new(X_PADDING, 0.0);
-        self.text.draw(ctx, origin);
-    }
-}
-
 pub struct PaletteUpdateController;
 
 impl Controller<FractalData, Image> for PaletteUpdateController {
@@ -110,82 +52,4 @@ impl Controller<FractalData, Image> for PixelInformationUpdateController {
             other => child.event(ctx, other, data, env),
         }
     }
-}
-
-/// A widget that switches between two possible child views.
-pub struct Either<T> {
-    closure: Box<dyn Fn(&T, &Env) -> usize>,
-    branches: Vec<WidgetPod<T, Box<dyn Widget<T>>>>,
-    current: usize,
-}
-
-impl<T> Either<T> {
-    /// Create a new widget that switches between two views.
-    pub fn new(
-        closure: impl Fn(&T, &Env) -> usize + 'static,
-    ) -> Either<T> {
-        Either {
-            closure: Box::new(closure),
-            branches: Vec::new(),
-            current: 0,
-        }
-    }
-
-    pub fn add_branch(mut self, branch: impl Widget<T> + 'static) -> Self {
-        self.branches.push(WidgetPod::new(branch).boxed());
-        self
-    }
-}
-
-impl<T: Data> Widget<T> for Either<T> {
-    fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
-        if event.should_propagate_to_hidden() {
-            for branch in &mut self.branches {
-                branch.event(ctx, event, data, env);
-            }
-        } else {
-            self.current_widget().event(ctx, event, data, env)
-        }
-    }
-
-    fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, data: &T, env: &Env) {
-        if let LifeCycle::WidgetAdded = event {
-            self.current = (self.closure)(data, env);
-        }
-
-        if event.should_propagate_to_hidden() {
-            for branch in &mut self.branches {
-                branch.lifecycle(ctx, event, data, env);
-            }
-        } else {
-            self.current_widget().lifecycle(ctx, event, data, env)
-        }
-    }
-
-    fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &T, data: &T, env: &Env) {
-        let current = (self.closure)(data, env);
-        if current != self.current {
-            self.current = current;
-            ctx.request_layout();
-        }
-        self.current_widget().update(ctx, data, env)
-    }
-
-    fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints, data: &T, env: &Env) -> Size {
-        let current_widget = self.current_widget();
-        let size = current_widget.layout(ctx, bc, data, env);
-        current_widget.set_origin(ctx, data, env, Point::ORIGIN);
-        ctx.set_paint_insets(current_widget.paint_insets());
-        size
-    }
-
-    fn paint(&mut self, ctx: &mut PaintCtx, data: &T, env: &Env) {
-        self.current_widget().paint(ctx, data, env)
-    }
-}
-
-impl<T> Either<T> {
-    fn current_widget(&mut self) -> &mut WidgetPod<T, Box<dyn Widget<T>>> {
-        &mut self.branches[self.current]
-    }
 }

src/custom.rs

@@ -1,6 +1,6 @@
 use druid::Lens;
 
-use crate::FractalData;
+use crate::widgets::FractalData;
 pub struct RealLens;
 
 impl Lens<FractalData, String> for RealLens {

src/lens.rs

@@ -0,0 +1,7 @@
+pub mod widgets;
+pub mod ui;
+pub mod theme;
+pub mod commands;
+pub mod lens;
+pub mod custom;
+pub mod render_thread;

src/lib.rs

@@ -12,15 +12,10 @@ use druid::theme::{PRIMARY_DARK, BACKGROUND_DARK};
 
 use parking_lot::Mutex;
 use std::sync::Arc;
-use rust_fractal::{
-    renderer::FractalRenderer,
-    util::{string_to_extended, extended_to_string_short, FloatExtended}
-};
+use rust_fractal::{renderer::FractalRenderer, util::{FloatExtended, data_export::ColoringType, extended_to_string_short, string_to_extended}};
 
-use crate::{FractalData, FractalWidget, ColoringType};
+use crate::widgets::*;
 use crate::custom::*;
-
-
 use crate::commands::*;
 use crate::lens;