def redraw_birdseye_graph_surf(self):
        """(Re)create a representation of the whole graph that fits the screen.

        That is, that fits the bird's eye fit area, which is slightly smaller
        than the screen in order to provide some margin.

        Other objects created along the way are also stored for their
        usefulness.
        """
        ### reference the graph manager
        gm = APP_REFS.gm

        ### grab a reference to a rects manager that references rects
        ### from all objects in the graph
        objs_rectsman = gm.rectsman

        ### obtain a copy of the rectsman, which represents a union rect
        ### of all the rects managed by it
        ###
        ### it will also be stored as an attribute since it will be
        ### useful in other operations outside this method
        union_rect = self.birdseye_union_rect = objs_rectsman.copy()

        ### store the topleft of the objects
        original_topleft = union_rect.topleft

        ### create rect from union that fits the fit area

        birdseye_graph_rect = union_rect.fit(self.birdseye_fit_area)

        ### define the difference in proportion and perform extra setups
        ### and definitions depending on whether the area of the fitted
        ### rect is smaller than the whole graph or not
        ###
        ### defining the difference in proportion (proportion_diff) is
        ### important cause it will tell us how much we need to shrink
        ### various distances between objects and the center of the screen
        ### in order to properly position them in the graph representation

        if mul(*birdseye_graph_rect.size) < mul(*union_rect.size):

            target_distance, actual_distance = (
                Vector2(rect.center).distance_to(rect.bottomright)
                for rect in (birdseye_graph_rect, union_rect)
            )

            proportion_diff = target_distance / actual_distance

        else:

            birdseye_graph_rect = union_rect.copy()
            birdseye_graph_rect.center = SCREEN_RECT.center
            proportion_diff = 1.0

        ### create the surf on which we'll draw the graph representation

        graph_surf = self.birdseye_graph.image = (
            RECT_SURF_MAP[(*birdseye_graph_rect.size, VIEW_BG)].copy()
        )

        ### position labels according to the rect of such representation

        self.birdseye_caption_label.rect.bottomleft = birdseye_graph_rect.topleft

        self.birdseye_instruction_label.rect.topright = (
            birdseye_graph_rect.bottomright
        )

        ### store the rect's representation for later use
        self.birdseye_graph.rect = birdseye_graph_rect 

        ### now draw all the elements of the graph as icons in the graph
        ### representation;
        ###
        ### such icons must be properly distributed according to their
        ### relative position to each other in the whole graph, so, as the
        ### name implies, the graph representation accurately represents
        ### the positions of the objects in the whole graph

        ## obtain an offset for the origin of the representation's rect
        offset = -Vector2(birdseye_graph_rect.topleft)

        ## reference the center of the screen locally and also assign it
        ## to the center of whole graph so the whole graph is centered
        ## on the screen center as well
        objs_rectsman.center = center = Vector2(SCREEN_RECT.center)

        ## reference the blit operation of the representation's surf
        ## locally for quicker and easier access
        blit_on_graph_surf = graph_surf.blit

        ## reference support objects and relevant method

        blit_pairs = self.birdseye_blit_pairs
        store = blit_pairs.append

        id_to_pos_map = self.birdseye_id_to_pos_map

        ## iterate over existing nodes, calculating the new positions
        ## where their icons must be drawn and storing references to
        ## their icons and such new positions so they can be drawn later
        ## in this method
        ##
        ## the reason they'll be drawn later is that we need to
        ## draw the connections between them before drawing them
        ##
        ## the reason they'll be iterated now despite only being drawn
        ## later is that we need the calculate the new positions so
        ## we can drawn the connections between such positions

        for node in gm.nodes:

            point = (
                center.lerp(node.rectsman.center, proportion_diff)
            ) + offset

            id_to_pos_map[node.id] = point

            icon = node.tiny_icon
            icon_offset = icon.get_rect().center

            if hasattr(node, 'preview_panel'):

                topleft = point + PANEL_OFFSET
                store((IMAGE_ICON, topleft))

            store((icon, point - icon_offset))

        ## iterate over the output sockets that have children,
        ## drawing the connections between them and their children
        ## using the new positions we just calculated

        for parent in gm.parents:

            a = id_to_pos_map[parent.node.id]

            segment_color = parent.line_color

            for child in parent.children:

                b = id_to_pos_map[child.node.id]
                draw_line(graph_surf, segment_color, a, b, 2)

        ## clear support object since we won't need its values
        ## anymore
        id_to_pos_map.clear()

        ## we can now draw the nodes

        for surf, topleft in blit_pairs:
            blit_on_graph_surf(surf, topleft)

        ## clear support object since we won't need its values
        ## anymore
        blit_pairs.clear()

        ## now we calculate the new positions for the text blocks
        ## and draw their icons on that positions

        for block in gm.text_blocks:

            point = (
                center.lerp(block.rect.center, proportion_diff)
            ) + offset

            blit_on_graph_surf(TEXT_BLOCK_ICON, point - TEXT_BLOCK_OFFSET)


        ### restore the position of the whole graph
        objs_rectsman.topleft = original_topleft

        ### also assign that same position to the union rect of the
        ### whole graph (remember we also have this object stored
        ### as an attribute, since it is useful for other operations)
        union_rect.topleft = original_topleft
(Re)create a representation of the whole graph that fits the screen.

        That is, that fits the bird's eye fit area, which is slightly smaller
        than the screen in order to provide some margin.

        Other objects created along the way are also stored for their
        usefulness.
        
nodezator/editing/birdseyeview.py