SVG backend cannot print second part

[DorianCoding]

Hello,

I have this code:

use plotters::{
    backend,
    drawing::IntoDrawingArea,
    style::{self, AsRelative, IntoTextStyle, RGBColor, full_palette},
};

fn main() {
    let g = backend::SVGBackend::new("new.svg", (700, 600)).into_drawing_area();
    let (top, bottom) = g.split_vertically((50).percent_height());
    let val: (&'static str, u32, &'static RGBColor) = ("sans-serif", 14, &style::colors::BLACK);
    top.fill(&full_palette::AMBER).unwrap();
    top.draw_text("Hello3", &val.into_text_style(&top), (40, 40))
        .unwrap();
    top.present().unwrap();
    bottom.fill(&full_palette::CYAN).unwrap();
    bottom
        .draw_text("Hello4", &val.into_text_style(&bottom), (40, 30))
        .unwrap();
    bottom.present().unwrap();
    let g = backend::BitMapBackend::new("new.png", (700, 600)).into_drawing_area();
    let (top, bottom) = g.split_vertically((50).percent_height());
    let val: (&'static str, u32, &'static RGBColor) = ("sans-serif", 14, &style::colors::BLACK);
    top.fill(&full_palette::AMBER).unwrap();
    top.draw_text("Hello3", &val.into_text_style(&top), (40, 40))
        .unwrap();
    top.present().unwrap();
    bottom.fill(&full_palette::CYAN).unwrap();
    bottom
        .draw_text("Hello4", &val.into_text_style(&bottom), (40, 30))
        .unwrap();
    bottom.present().unwrap();
}

The SVG is not drawn if top.present is called. If commented however it works well. I don't have this issue with BitMap, why?

[MLuc24]

The thing tripping you up is that present() is not a per-area operation. top and bottom are two views onto the same backend, so top.present() does not present the top half — it finalises the entire SVG document, before you have drawn the bottom one.

For SVG that is a one-way door:

fn present(&mut self) -> Result<(), DrawingErrorKind<Error>> {
    if !self.saved {
        while self.close_tag() {}
        match self.target {
            Target::File(ref buf, path) => { /* write buf to path */ }
            Target::Buffer(_) => {}
        }
        self.saved = true;
    }
    Ok(())
}

Every open tag gets closed, the buffer as it stands is written to new.svg, and saved latches to true. Your second call then hits if !self.saved, does nothing at all, and returns Ok(()) — so it reports success while never writing the bottom half. That silent success is why it looks like the drawing failed rather than the saving.

The difference from BitMapBackend is one line, and it is the one you would never think to look at:

// bitmap
fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<BitMapBackendError>> {
    self.saved = false;
    Ok(())
}

// svg
fn ensure_prepared(&mut self) -> Result<(), DrawingErrorKind<Error>> {
    Ok(())
}

Both backends use the same saved latch, but the bitmap one clears it in ensure_prepared, which runs before each drawing operation. So drawing after a present re-arms it and the next present writes the file again. SVG's ensure_prepared does nothing, so once latched it stays latched for the life of the backend — and unlike a bitmap, a text format that has already emitted its closing tags could not simply be appended to anyway.

It also explains the part you found puzzling, that commenting the call out fixes it. The backend saves itself on the way out:

impl Drop for SVGBackend<'_> {
    fn drop(&mut self) {
        if !self.saved {
            let _ = self.present();
        }
    }
}

With no explicit call, nothing latches early, and the complete document lands on disk when the backend drops.

So the fix is just to present once, after all the drawing is done, on the root area rather than on the pieces — or to leave it out entirely and let the drop handler do it. The same applies to your bitmap block; it works there by accident of that one flag reset rather than because the two-present pattern is right.

[DorianCoding]

Hello, thanks for your rapid and accurate answer!

The thing tripping you up is that present() is not a per-area operation. top and bottom are two views onto the same backend, so top.present() does not present the top half — it finalises the entire SVG document, before you have drawn the bottom one.

Ok the problem is I did not keep track of the DrawingArea. I will try to.

so it reports success while never writing the bottom half. That silent success is why it looks like the drawing failed rather than the saving.

This should return an error actually and is indeed very misleading.

So the fix is just to present once, after all the drawing is done, on the root area rather than on the pieces — or to leave it out entirely and let the drop handler do it. The same applies to your bitmap block; it works there by accident of that one flag reset rather than because the two-present pattern is right.

Yes I could let drop but then I will silent the error. Drawing at the end of the block is better to detect the error, thanks again. It is not clear in the documentation and show be made clearer, or at least the error mentionned in 2), or even better, a compile error.