Method draw

src/render.rs:104–183

(&mut self, _: &str)

    }

    pub fn draw(&mut self, _: &str) -> Result<usize> {
        let mut pending = false;

        // mutable iterator of items, skipping things outside the viewport
        let mut items = self.strcts.iter_mut()
            .map(|(a, item)| {
                if !item.is_in_view(&self.metadata, &self.blocks) {
                    if let FoldInner::Node((_, ref mut view)) = item {
                        *view = NodeView::Hidden;
                    }
                }

                (a, item)
            })
            .filter(|(_, item)| {
                item.is_in_view(&self.metadata, &self.blocks)
            })
            .collect::<Vec<_>>();

        // initialize current item
        let mut iter = items.iter_mut();
        let mut item = match iter.next() {
            Some(x) => x,
            None => return Ok(0)
        };

        // initialize last line and top offset, so that first iteration gives offset to first item
        let mut last_line = self.metadata.file_range.0 as usize;
        let mut top_offset: isize = 0;
    
        // perform fold skipping if folded in
        let mut skip_to = None;
        'outer: loop {
            match item.1 {
                FoldInner::Node((id, ref mut node_view)) => {
                    let node = self.blocks.get_mut(id).unwrap();

                    // calculate new offset (this can be negative at the beginning)
                    top_offset += node.range.0 as isize - last_line as isize;
                    last_line = node.range.0;

                    pending |= Render::draw_node(&self.metadata, &self.stdout, node, node_view, top_offset)?;
                },
                FoldInner::Fold(ref fold) => {
                    // offset has a header of single line
                    top_offset += fold.line as isize - last_line as isize;

                    if let FoldState::Folded(end) =  fold.state {
                        skip_to = Some(end);
                        
                        last_line = end;
                    } else {
                        last_line = fold.line;
                    }
                }
            }

            // get new items and skip until line is reached