Line data    Source code

       1             : /* File: pencil_classifier_2d_layouter.inl; Copyright and License: see below */
       2             : 
       3             : #include "u8/u8_log.h"
       4             : #include <assert.h>
       5             : 
       6             : /* ================================ INITIAL LAYOUT ================================ */
       7             : 
       8             : /* ================================ MOVE TO AVOID OVERLAPS ================================ */
       9             : 
      10             : /* ================================ EMBRACE CHILDREN STEP BY STEP ================================ */
      11             : 
      12             : /* ================================ EMBRACE CHILDREN COMMON ================================ */
      13             : 
      14             : /* ================================ EMBRACE AND MOVE CHILDREN TOGETHER ================================ */
      15             : 
      16           0 : static inline geometry_rectangle_t pencil_classifier_2d_layouter_private_calc_descendant_envelope( pencil_classifier_2d_layouter_t *this_,
      17             :                                                                                                    const layout_visible_classifier_t *ancestor_classifier )
      18             : {
      19           0 :     U8_TRACE_BEGIN();
      20           0 :     assert( ancestor_classifier != NULL );
      21             :     geometry_rectangle_t descendant_envelope;
      22           0 :     geometry_rectangle_init( &descendant_envelope, 0.0, 0.0, 0.0, 0.0 );
      23           0 :     bool descendant_envelope_initialized = false;
      24             : 
      25           0 :     const uint32_t count_classifiers = layout_visible_set_get_visible_classifier_count( (*this_).layout_data );
      26           0 :     for ( uint32_t classifier_search_idx = 0; classifier_search_idx < count_classifiers; classifier_search_idx ++ )
      27             :     {
      28             :         const layout_visible_classifier_t *const probe_classifier
      29           0 :             = layout_visible_set_get_visible_classifier_ptr( (*this_).layout_data, classifier_search_idx );
      30             : 
      31           0 :         const bool is_ancestor = layout_visible_set_is_ancestor( (*this_).layout_data, ancestor_classifier, probe_classifier );
      32           0 :         const bool is_self
      33           0 :             = ( layout_visible_classifier_get_classifier_id( ancestor_classifier )
      34           0 :             == layout_visible_classifier_get_classifier_id( probe_classifier ) );
      35             : 
      36           0 :         if ( is_ancestor && ( ! is_self ) )
      37             :         {
      38           0 :             const geometry_rectangle_t probe_envelope = layout_visible_classifier_get_envelope_box( probe_classifier );
      39           0 :             if ( ! descendant_envelope_initialized )
      40             :             {
      41           0 :                 geometry_rectangle_copy( &descendant_envelope, &probe_envelope );
      42           0 :                 descendant_envelope_initialized = true;
      43             :             }
      44             :             else
      45             :             {
      46           0 :                 geometry_rectangle_init_by_bounds ( &descendant_envelope, &descendant_envelope, &probe_envelope );
      47             :             }
      48             :         }
      49             :     }
      50             : 
      51           0 :     U8_TRACE_END();
      52           0 :     return descendant_envelope;
      53             : }
      54             : 
      55           0 : static inline geometry_rectangle_t pencil_classifier_2d_layouter_private_calc_outer_space( pencil_classifier_2d_layouter_t *this_,
      56             :                                                                                            const geometry_rectangle_t *start_rect,
      57             :                                                                                            const layout_visible_classifier_t *the_classifier )
      58             : {
      59           0 :     U8_TRACE_BEGIN();
      60           0 :     assert( start_rect != NULL );
      61           0 :     assert( the_classifier != NULL );
      62             : 
      63             :     /* fetch data on parent classifier */
      64           0 :     const geometry_rectangle_t parent_envelope = layout_visible_classifier_get_envelope_box( the_classifier );
      65           0 :     const geometry_rectangle_t *const parent_space = layout_visible_classifier_get_space_const( the_classifier );
      66           0 :     const double parent_space_width_diff
      67           0 :         = geometry_rectangle_get_width(&parent_envelope) - geometry_rectangle_get_width(parent_space);
      68           0 :     const double parent_space_height_diff
      69           0 :         = geometry_rectangle_get_height(&parent_envelope) - geometry_rectangle_get_height(parent_space);
      70             : 
      71             :     /* determine outer space around start_rect rectangle */
      72             :     geometry_rectangle_t outer_space;
      73             :     {
      74           0 :         geometry_rectangle_copy( &outer_space, start_rect );
      75           0 :         const double children_envelope_w = geometry_rectangle_get_width(start_rect);
      76           0 :         const double children_envelope_h = geometry_rectangle_get_height(start_rect);
      77           0 :         geometry_rectangle_shift ( &outer_space,
      78           0 :                                    -0.5*children_envelope_w-parent_space_width_diff,
      79           0 :                                    -0.5*children_envelope_h-parent_space_height_diff
      80             :                                  );
      81           0 :         geometry_rectangle_enlarge ( &outer_space,
      82           0 :                                     children_envelope_w+2.0*parent_space_width_diff,
      83           0 :                                     children_envelope_h+2.0*parent_space_height_diff
      84             :                                   );
      85             : 
      86           0 :         geometry_rectangle_init_by_intersect( &outer_space, &outer_space, (*this_).diagram_draw_area );
      87             : 
      88           0 :         const uint32_t count_classifiers = layout_visible_set_get_visible_classifier_count ( (*this_).layout_data );
      89           0 :         for ( uint32_t probe_index = 0; probe_index < count_classifiers; probe_index ++ )
      90             :         {
      91             :             /* get classifier to check overlaps */
      92             :             const layout_visible_classifier_t *const the_probe
      93           0 :                 = layout_visible_set_get_visible_classifier_const( (*this_).layout_data, probe_index );
      94             : 
      95           0 :             const bool ignore
      96           0 :                 = layout_visible_set_is_ancestor ( (*this_).layout_data, the_classifier, the_probe )
      97           0 :                 || layout_visible_set_is_ancestor ( (*this_).layout_data, the_probe, the_classifier ) /* ancestor may already encapsulate probe */
      98           0 :                 || ( layout_visible_classifier_is_equal_diagramelement_id( the_classifier, the_probe ));
      99           0 :             if ( ! ignore )
     100             :             {
     101           0 :                 const geometry_rectangle_t probe_envelope = layout_visible_classifier_get_envelope_box( the_probe );
     102           0 :                 geometry_rectangle_init_by_difference_max( &outer_space, &outer_space, &probe_envelope );
     103             :             }
     104             :         }
     105             :     }
     106             : 
     107           0 :     U8_TRACE_END();
     108           0 :     return outer_space;
     109             : }
     110             : 
     111           0 : static inline void pencil_classifier_2d_layouter_private_move_descendants( pencil_classifier_2d_layouter_t *this_,
     112             :                                                                            const layout_visible_classifier_t *ancestor_classifier,
     113             :                                                                            const geometry_offset_t *offset )
     114             : {
     115           0 :     U8_TRACE_BEGIN();
     116           0 :     assert( ancestor_classifier != NULL );
     117             : 
     118             :     /* check all classifiers */
     119           0 :     const uint32_t count_classifiers = layout_visible_set_get_visible_classifier_count ( (*this_).layout_data );
     120           0 :     for ( uint32_t index = 0; index < count_classifiers; index ++ )
     121             :     {
     122           0 :         layout_visible_classifier_t *const probe_classifier = layout_visible_set_get_visible_classifier_ptr( (*this_).layout_data, index );
     123           0 :         const bool is_descendant = layout_visible_set_is_ancestor ( (*this_).layout_data, ancestor_classifier, probe_classifier );
     124           0 :         const bool is_self
     125           0 :             = ( layout_visible_classifier_get_classifier_id( ancestor_classifier )
     126           0 :             == layout_visible_classifier_get_classifier_id( probe_classifier ) );
     127           0 :         if ( is_descendant && ( ! is_self ) )
     128             :         {
     129             :             /* trace */
     130           0 :             U8_TRACE_INFO_INT_INT( "classifier moved:",
     131             :                                    geometry_offset_get_dx( offset ),
     132             :                                    geometry_offset_get_dy( offset )
     133             :                                  );
     134             : 
     135           0 :             layout_visible_classifier_shift( probe_classifier, offset );
     136             :         }
     137             :     }
     138           0 :     U8_TRACE_END();
     139           0 : }
     140             : 
     141             : 
     142             : /*
     143             : Copyright 2018-2025 Andreas Warnke
     144             : 
     145             : Licensed under the Apache License, Version 2.0 (the "License");
     146             : you may not use this file except in compliance with the License.
     147             : You may obtain a copy of the License at
     148             : 
     149             :     http://www.apache.org/licenses/LICENSE-2.0
     150             : 
     151             : Unless required by applicable law or agreed to in writing, software
     152             : distributed under the License is distributed on an "AS IS" BASIS,
     153             : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     154             : See the License for the specific language governing permissions and
     155             : limitations under the License.
     156             : */