file_maintenance_clipped/state_menu.cpp at master · cppmsg/file_maintenance_clipped · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include "state_menu.h"
#include <memory>
#include <cassert>
#include <stdexcept>
#include "menu.h"

std::shared_ptr<Menu> State_menu::menu_top_sp() const {
    assert( ! menu_stack.empty());
    return menu_stack.top();
}

void State_menu::push_menu_sp (std::shared_ptr<Menu> const sp) {
    menu_stack.push( sp );
}

std::shared_ptr<Menu> State_menu::menu_pop_top_sp() {
    if ( menu_stack.size() < 1 )
        throw( std::logic_error( "State_menu::menu_pop_top_sp(): Empty stack." ));
    menu_stack.pop();
    return menu_stack.top();
}

std::shared_ptr<Menu> State_menu::menu_pop_to_sp(std::shared_ptr<Menu> const sp) {
    auto current  = menu_stack.top();
    while ( sp != current ) {
        if ( menu_stack.size() > 0 )
            menu_stack.pop();
        else
            throw( std::logic_error( "State_menu::menu_pop_to_sp(): Empty stack." ));
        current = menu_stack.top();
    }
    return current;
}

InteractionCategory State_menu::action_top() const {
    assert( ! action_stack.empty());
    return action_stack.top();
}

void State_menu::action_push(const InteractionCategory ars) {
    action_stack.push( ars );
}

InteractionCategory State_menu::action_pop_top() {
    if ( action_stack.size() < 1 )
        throw ( std::logic_error( "State_menu::action_pop_top(): Empty stack." ));
    action_stack.pop();
    return action_stack.top();
}

bool State_menu::is_menu_current_main() const
{
    return ( menu_stack.top() == menu_main_sp );
}

std::shared_ptr<State_application> State_menu::getApplication_data_sp() const
{
    return application_data_sp;
}

void State_menu::setApplication_data_sp(const std::shared_ptr<State_application> &value)
{
    application_data_sp = value;
}

/*std::shared_ptr<Menu> State_menu::getMenu_prior() const
//{
//    return menu_prior_sp;
//}

//void State_menu::setMenu_prior(const std::shared_ptr<Menu> &value)
//{
//    menu_prior_sp = value;
//}

//std::shared_ptr<Menu> State_menu::getMenu_current() const
//{
//    return menu_current_sp;
//}

//void State_menu::setMenu_current(const std::shared_ptr<Menu> &value)
//{
//    menu_current_sp = value;
//}*/

bool State_menu::getAdvanced_menu_enabled() const
{
    return advanced_menu_enabled;
}

void State_menu::setAdvanced_menu_enabled(bool value)
{
    advanced_menu_enabled = value;
}

//bool State_menu::getIs_data_unsaved() const
//{
    //return is_data_saved;
//}

//void State_menu::setIs_data_unsaved(bool value)
//{
    //is_data_saved = value;
//}

std::shared_ptr<Menu> State_menu::getMenu_main() const
{
    return menu_main_sp;
}

void State_menu::setMenu_main(const std::shared_ptr<Menu> &value)
{
    menu_main_sp = value;
}

std::shared_ptr<Menu> State_menu::getMenu_edit() const
{
    return menu_edit_sp;
}

void State_menu::setMenu_edit(const std::shared_ptr<Menu> &value)
{
    menu_edit_sp = value;
}

std::shared_ptr<Menu> State_menu::getMenu_file() const
{
    return menu_file_sp;
}

void State_menu::setMenu_file(const std::shared_ptr<Menu> &value)
{
    menu_file_sp = value;
}

std::shared_ptr<Menu> State_menu::getMenu_settings() const
{
    return menu_settings_sp;
}

void State_menu::setMenu_settings(const std::shared_ptr<Menu> &value)
{
    menu_settings_sp = value;
}

// State::State( Menu * m_ptr) {
// menu_current = std::shared_ptr<Menu>( std::move(m_ptr) );
// }