How do I convert RC<RefCell<DrawingBackendImpl>> to DrawingArea?

[DaMilyutin]

Hi, I have such problem

fn render_plot(width: f32, height: f32) -> sixtyfps::Image {
    let width = width as usize;
    let height = height as usize;
    let mut pixel_buffer = SharedPixelBuffer::new(width, height);
    let size = (pixel_buffer.width() as u32, pixel_buffer.height() as u32);

    let backend = BitMapBackend::with_buffer(pixel_buffer.make_mut_bytes(), size);

    // let backend = Rc::new(RefCell::new(backend));  // If I uncomment this
    let root = backend.into_drawing_area();  // error appears with message about traits...

I have no idea how to fix it.
I need both backend and root.

I see trait From for Rc<RefCel> (which is stored in DrawingArea)
But by some reason .into() is not seen for it.

Error message:
"
error[E0599]: the method into_drawing_area exists for struct Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>, but its trait bounds were not satisfied
--> src\main.rs:46:24
|
46 | let root = backend.into_drawing_area();
| ^^^^^^^^^^^^^^^^^ method cannot be called on Rc<RefCell<plotters::prelude::BitMapBackend<'_>>> due to unsatisfied trait bounds
|
::: C:\Users\58.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\cell.rs:603:1
|
603 | pub struct RefCell<T: ?Sized> {
| -----------------------------
| |
| doesn't satisfy _: plotters::drawing::IntoDrawingArea
| doesn't satisfy _: plotters_backend::DrawingBackend
|
::: C:\Users\58.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\alloc\src\rc.rs:309:1
|
309 | pub struct Rc<T: ?Sized> {
| ------------------------
| |
| doesn't satisfy _: plotters::drawing::IntoDrawingArea
| doesn't satisfy _: plotters_backend::DrawingBackend
|
= note: the following trait bounds were not satisfied:
Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters_backend::DrawingBackend
which is required by Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters::drawing::IntoDrawingArea
&Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters_backend::DrawingBackend
which is required by &Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters::drawing::IntoDrawingArea
&mut Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters_backend::DrawingBackend
which is required by &mut Rc<RefCell<plotters::prelude::BitMapBackend<'_>>>: plotters::drawing::IntoDrawingArea
RefCell<plotters::prelude::BitMapBackend<'_>>: plotters_backend::DrawingBackend
which is required by RefCell<plotters::prelude::BitMapBackend<'_>>: plotters::drawing::IntoDrawingArea
&RefCell<plotters::prelude::BitMapBackend<'_>>: plotters_backend::DrawingBackend
which is required by &RefCell<plotters::prelude::BitMapBackend<'_>>: plotters::drawing::IntoDrawingArea
&mut RefCell<plotters::prelude::BitMapBackend<'_>>: plotters_backend::DrawingBackend
which is required by &mut RefCell<plotters::prelude::BitMapBackend<'_>>: plotters::drawing::IntoDrawingArea

"

[414owen]

Hi @DaMilyutin,

This error is telling you that in order to call .into_drawing_area(), your data needs to implement DrawingBackend.

The DrawingBackend trait is documented here: https://docs.rs/plotters/0.3.0/plotters/prelude/trait.DrawingBackend.html

You seem to need a BitMapBackend, rather than an Rc<RefCell<BitmapBackend>>.

As Rc implements deref, I'm guessing you want to try something like RefCell's .borrow_mut()?

Hope this helps :)

[DaMilyutin]

@414owen, (I've deleted my useless comments above).
I've managed to do it right way.

First, you were right about borrow_mut().
When I got debugging through code to see how it does the job, I've found pattern

// impl DrawingArea
    /// Perform operation on the drawing backend
   fn backend_ops<R, O: FnOnce(&mut DB) -> Result<R, DrawingErrorKind<DB::ErrorType>>>(
        &self,
        ops: O,
    ) -> Result<R, DrawingAreaError<DB>> {
        if let Ok(mut db) = self.backend.try_borrow_mut() {
            db.ensure_prepared()
                .map_err(DrawingAreaErrorKind::BackendError)?;
            ops(&mut db).map_err(DrawingAreaErrorKind::BackendError)
        } else {
            Err(DrawingAreaErrorKind::SharingError)
        }
    }

Just borrow_mut couldn't help bacause there can be only one mutating reference.
So I just could use this pattern.
But I just hacked and made this function public. And It seems a little cleaner solution to me.
For example for interface extendability.

What I'm going to play is make dashed, dotted lines and gradient lines.

Thank you for your help. I was quite desperate.

[DaMilyutin]

I've managed to implement gradient coloured line!

[DaMilyutin]

And dashed line, too.

The code is quite simple!

    root.backend_ops(|db| {
        primitives::draw_segment(db, (0, 10), (width as i32, height as i32 - 10), &|t| {
            let b = 255f64 * t;
            let r = 255f64 * (1.0 - t);
            let dash = (256f64 * t) as i32;
            plotters_backend::BackendColor {
                alpha: if dash % 2 == 0 { 0.0 } else { 1.0 },
                rgb: (b as u8, r as u8, 0u8),
            }
        })
    })
    .unwrap();

The idea is that instead of Style I pass style function mapping [0,1]->RGBAColor which tells what color to apply to pixel.

[414owen]

Congrats @DaMilyutin, it looks good!

To be honest, I'd only made a small PR to plotters, and I'm not a rust expert, so there were probably people you could have reached out to that would have explained the solution better :)