LCOV - code coverage report
Current view: top level - util - CubitUndo.cpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 2 128 1.6 %
Date: 2020-06-30 00:58:45 Functions: 1 41 2.4 %
Branches: 1 92 1.1 %

           Branch data     Line data    Source code
       1                 :            : //- Class:       UndoCommands
       2                 :            : //- Description: Provides main undo capability for Cubit system
       3                 :            : //- Owner:       Ray J. Meyers
       4                 :            : //- Checked by:
       5                 :            : //- Version: $Id: 
       6                 :            : 
       7                 :            : #include "CubitUndo.hpp"
       8                 :            : #include "CubitString.hpp"
       9                 :            : 
      10                 :            : CubitUndo* CubitUndo::mInstance = 0;
      11                 :            : 
      12                 :          0 : CubitUndo::CubitUndo()
      13                 :            : {
      14         [ #  # ]:          0 :   if(mInstance)
      15                 :            :   {
      16                 :          0 :     assert(0);
      17                 :            :     // if you want a new instance in place of a previous one,
      18                 :            :     // delete the previous one first
      19                 :            :   }
      20                 :          0 :   mInstance = this;
      21                 :          0 : }
      22                 :            : 
      23                 :          0 : CubitUndo::~CubitUndo()
      24                 :            : {
      25                 :          0 :   mInstance = 0;
      26         [ #  # ]:          0 : }
      27                 :            : 
      28                 :          0 : void CubitUndo::start_undo_group()
      29                 :            : {
      30         [ #  # ]:          0 :   if(!mInstance ) return;
      31                 :          0 :   mInstance->p_start_undo_group(); 
      32                 :            : }
      33                 :            : 
      34                 :          0 : void CubitUndo::end_undo_group()
      35                 :            : {
      36         [ #  # ]:          0 :   if(!mInstance ) return;
      37                 :          0 :   mInstance->p_end_undo_group(); 
      38                 :            : }
      39                 :            : 
      40                 :          0 : void CubitUndo::set_undo_enabled(bool value)
      41                 :            : {
      42         [ #  # ]:          0 :   if(!mInstance ) return;
      43                 :          0 :   mInstance->p_set_undo_enabled( value );
      44                 :            : }
      45                 :            : 
      46                 :       4629 : bool CubitUndo::get_undo_enabled()
      47                 :            : {
      48         [ +  - ]:       4629 :   if(!mInstance ) return false;
      49                 :          0 :   return mInstance->p_get_undo_enabled();
      50                 :            : }
      51                 :            : 
      52                 :          0 : void CubitUndo::clear_undo_groups()
      53                 :            : {
      54         [ #  # ]:          0 :   if(!mInstance ) return;
      55                 :          0 :   mInstance->p_clear_undo_groups();
      56                 :            : }
      57                 :            : 
      58                 :          0 : int CubitUndo::execute_undo()
      59                 :            : {
      60         [ #  # ]:          0 :   if(!mInstance ) 
      61                 :          0 :     return 0;
      62                 :            : 
      63                 :          0 :   return mInstance->p_execute_undo();
      64                 :            : }
      65                 :            : 
      66                 :          0 : void CubitUndo::remove_last_undo()
      67                 :            : {
      68         [ #  # ]:          0 :   if(!mInstance ) return;
      69                 :          0 :   mInstance->p_remove_last_undo();
      70                 :            : }
      71                 :            : 
      72                 :            : 
      73                 :          0 : void CubitUndo::remove_last_undo_group()
      74                 :            : {
      75         [ #  # ]:          0 :   if(!mInstance ) return;
      76                 :          0 :   mInstance->p_remove_last_undo_group();
      77                 :            : }
      78                 :            : 
      79                 :          0 : void CubitUndo::save_state()
      80                 :            : {
      81         [ #  # ]:          0 :   if(!mInstance ) return;
      82                 :          0 :   mInstance->p_save_state();
      83                 :            : }
      84                 :            : 
      85                 :          0 : void CubitUndo::save_state_with_cubit_file(DLIList<RefVolume*> &volumes_to_save )
      86                 :            : {
      87         [ #  # ]:          0 :   if(!mInstance ) return;
      88                 :          0 :   mInstance->p_save_state_with_cubit_file( volumes_to_save );
      89                 :            : }
      90                 :            : 
      91                 :          0 : void CubitUndo::save_state_with_cubit_file(RefFace *face_to_save )
      92                 :            : {
      93         [ #  # ]:          0 :   if(!mInstance ) return;
      94                 :          0 :   mInstance->p_save_state_with_cubit_file( face_to_save );
      95                 :            : }
      96                 :            : 
      97                 :          0 : void CubitUndo::save_state_with_cubit_file(RefVolume *volume_to_save )
      98                 :            : {
      99         [ #  # ]:          0 :   if(!mInstance ) return;
     100                 :          0 :   mInstance->p_save_state_with_cubit_file( volume_to_save );
     101                 :            : }
     102                 :            : 
     103                 :          0 : void CubitUndo::save_state_with_cubit_file( DLIList<MRefVolume*> &volumes_to_save )
     104                 :            : {
     105         [ #  # ]:          0 :   if(!mInstance ) return;
     106                 :          0 :   mInstance->p_save_state_with_cubit_file( volumes_to_save );
     107                 :            : }
     108                 :          0 : void CubitUndo::save_state_with_cubit_file(DLIList<RefFace*> &faces_to_save )
     109                 :            : {
     110         [ #  # ]:          0 :   if(!mInstance ) return;
     111                 :          0 :   mInstance->p_save_state_with_cubit_file( faces_to_save );
     112                 :            : }
     113                 :            : 
     114                 :          0 : void CubitUndo::save_state_with_cubit_file(DLIList<RefEdge*> &edges_to_save )
     115                 :            : {
     116         [ #  # ]:          0 :   if(!mInstance ) return;
     117                 :          0 :   mInstance->p_save_state_with_cubit_file( edges_to_save );
     118                 :            : }
     119                 :            : 
     120                 :          0 : void CubitUndo::save_state_with_cubit_file(DLIList<RefVertex*> &verts_to_save,
     121                 :            :                                            bool save_only_if_free )
     122                 :            : {
     123         [ #  # ]:          0 :   if(!mInstance ) return;
     124                 :          0 :   mInstance->p_save_state_with_cubit_file( verts_to_save, save_only_if_free );
     125                 :            : }
     126                 :            : 
     127                 :          0 : void CubitUndo::save_state_with_cubit_file( DLIList<Body*> &bodies_to_save,
     128                 :            :                                             DLIList<RefEntity*> *free_ents_to_save )
     129                 :            : {
     130         [ #  # ]:          0 :   if(!mInstance ) return;
     131                 :          0 :   mInstance->p_save_state_with_cubit_file( bodies_to_save, free_ents_to_save );
     132                 :            : }
     133                 :            : 
     134                 :          0 : void CubitUndo::note_result_body( Body *body_to_delete )
     135                 :            : {
     136         [ #  # ]:          0 :   if(!mInstance ) return;
     137                 :          0 :   mInstance->p_note_result_body( body_to_delete );
     138                 :            : }
     139                 :            : 
     140                 :          0 : void CubitUndo::note_result_bodies( DLIList<Body*> &bodies_to_delete )
     141                 :            : {
     142         [ #  # ]:          0 :   if(!mInstance ) return;
     143                 :          0 :   mInstance->p_note_result_bodies( bodies_to_delete );
     144                 :            : }
     145                 :            : 
     146                 :          0 : void CubitUndo::retain_mesh_on_result_bodies( DLIList<Body*> &bodies )
     147                 :            : {
     148         [ #  # ]:          0 :   if(!mInstance ) return;
     149                 :          0 :   mInstance->p_retain_mesh_on_result_bodies( bodies );
     150                 :            : }
     151                 :            : 
     152                 :          0 : void CubitUndo::retain_mesh_on_result_curves( DLIList<RefEdge*> &curves )
     153                 :            : {
     154         [ #  # ]:          0 :   if(!mInstance ) return;
     155                 :          0 :   mInstance->p_retain_mesh_on_result_curves( curves );
     156                 :            : }
     157                 :            : 
     158                 :          0 : void CubitUndo::retain_mesh_on_result_vertices( DLIList<RefVertex*> &verts )
     159                 :            : {
     160         [ #  # ]:          0 :   if(!mInstance ) return;
     161                 :          0 :   mInstance->p_retain_mesh_on_result_vertices( verts );
     162                 :            : }
     163                 :            : 
     164                 :          0 : void CubitUndo::note_result_boundary_conditions( RefEntity *owner_entity )
     165                 :            : {
     166         [ #  # ]:          0 :     if(!mInstance ) return;
     167                 :          0 :   mInstance->p_note_result_boundary_conditions( owner_entity );
     168                 :            : }
     169                 :            : 
     170                 :          0 : void CubitUndo::note_result_entity( RefEntity *entity_to_delete ) 
     171                 :            : {
     172         [ #  # ]:          0 :   if(!mInstance ) return;
     173                 :          0 :   mInstance->p_note_result_entity( entity_to_delete );
     174                 :            : }
     175                 :            : 
     176                 :          0 : void CubitUndo::note_result_entities( DLIList<MRefVolume*> &vols_to_delete )
     177                 :            : {
     178         [ #  # ]:          0 :   if(!mInstance ) return;
     179                 :          0 :   mInstance->p_note_result_entities( vols_to_delete );
     180                 :            : }
     181                 :            : 
     182                 :          0 : void CubitUndo::note_result_entities( DLIList<RefEntity*> &entities_to_delete )
     183                 :            : {
     184         [ #  # ]:          0 :   if(!mInstance ) return;
     185                 :          0 :   mInstance->p_note_result_entities( entities_to_delete );
     186                 :            : }
     187                 :            : 
     188                 :          0 : void CubitUndo::set_undo_by_restoring_state()
     189                 :            : {
     190         [ #  # ]:          0 :   if(!mInstance ) return;
     191                 :          0 :   mInstance->p_set_undo_by_restoring_state();
     192                 :            : }
     193                 :            : 
     194                 :          0 : void CubitUndo::set_undo_by_command(CubitString undo_command_string)
     195                 :            : {
     196         [ #  # ]:          0 :   if(!mInstance ) return;
     197         [ #  # ]:          0 :   mInstance->p_set_undo_by_command( undo_command_string );
     198                 :            : }
     199                 :            : 
     200                 :          0 : int CubitUndo::number_undo_groups()
     201                 :            : {
     202         [ #  # ]:          0 :   if(!mInstance ) return 0;
     203                 :          0 :   return mInstance->p_number_undo_groups();
     204                 :            : }
     205                 :            : 
     206                 :          0 : void CubitUndo::create_dummy_undo_object()
     207                 :            : {
     208         [ #  # ]:          0 :   if(!mInstance ) return;
     209                 :          0 :   mInstance->p_create_dummy_undo_object();
     210                 :            : }
     211                 :            : 
     212                 :          0 : bool CubitUndo::inside_undo_group()
     213                 :            : {
     214         [ #  # ]:          0 :   if(!mInstance ) return false;
     215                 :          0 :   return mInstance->p_inside_undo_group();
     216                 :            : }
     217                 :            : 
     218                 :          0 : void CubitUndo::save_mesh_size_data( MRefEntity *entity )
     219                 :            : {
     220         [ #  # ]:          0 :   if(!mInstance ) return;
     221                 :          0 :   mInstance->p_save_mesh_size_data( entity );
     222                 :            : }
     223                 :            : 
     224                 :          0 : void CubitUndo::save_mesh_scheme_data( MRefEntity *entity )
     225                 :            : {
     226         [ #  # ]:          0 :   if(!mInstance ) return;
     227                 :          0 :   mInstance->p_save_mesh_scheme_data( entity );
     228                 :            : }
     229                 :            : 
     230                 :          0 : void CubitUndo::save_smooth_scheme_data( MRefEntity *entity )
     231                 :            : {
     232         [ #  # ]:          0 :   if(!mInstance ) return;
     233                 :          0 :   mInstance->p_save_smooth_scheme_data( entity );
     234                 :            : }
     235                 :            : 
     236                 :          0 : void CubitUndo::save_all_mesh_data( MRefEntity *entity )
     237                 :            : {
     238         [ #  # ]:          0 :   if(!mInstance ) return;
     239                 :          0 :   mInstance->p_save_all_mesh_data( entity );
     240                 :            : }
     241                 :            : 
     242                 :          0 : void CubitUndo::save_merge_data( DLIList<RefEntity*> &ents, bool merging )
     243                 :            : {
     244         [ #  # ]:          0 :   if(!mInstance ) return;
     245                 :          0 :   mInstance->p_save_merge_data( ents, merging );
     246                 :            : }
     247                 :            : 
     248                 :          0 : void CubitUndo::save_mesh_state_before_smoothing( MRefEntity *entity )
     249                 :            : {
     250         [ #  # ]:          0 :   if(!mInstance ) return;
     251         [ #  # ]:          0 :   DLIList<MRefEntity*> ents_to_smooth(1);
     252         [ #  # ]:          0 :   ents_to_smooth.append( entity );
     253 [ #  # ][ #  # ]:          0 :   mInstance->p_save_mesh_state_before_smoothing( ents_to_smooth ); 
     254                 :            : }
     255                 :            : 
     256                 :          0 : void CubitUndo::save_mesh_state_before_smoothing( DLIList<MRefEntity*> &ents_to_smooth )
     257                 :            : {
     258         [ #  # ]:          0 :   if(!mInstance ) return;
     259                 :          0 :   mInstance->p_save_mesh_state_before_smoothing( ents_to_smooth ); 
     260                 :            : }
     261                 :            : 
     262                 :          0 : void CubitUndo::save_mesh_state_before_smoothing( DLIList<MeshEntity*> &ents_to_smooth )
     263                 :            : {
     264         [ #  # ]:          0 :   if(!mInstance ) return;
     265                 :          0 :   mInstance->p_save_mesh_state_before_smoothing( ents_to_smooth ); 
     266                 :            : }
     267                 :            : 

Generated by: LCOV version 1.11