Mercurial > octave

comparison libinterp/corefcn/event-manager.cc @ 30134:71d738ed015d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: use "m_" prefix for member variables in class event_manager. * event-manager.cc, event-manager.h: Use "m_" prefix for member variables in class event_manager. Re-order event_manager class to have public/protected/private ordering.
author Rik <rik@octave.org>
date Tue, 07 Sep 2021 16:00:42 -0700
parents 7d6709900da7
children a7981aa5822b
comparison
equal deleted inserted replaced
30133:938794bc82b7 30134:71d738ed015d
63 63
64 ee.display (std::cerr); 64 ee.display (std::cerr);
65 } 65 }
66 66
67 event_manager::event_manager (interpreter& interp) 67 event_manager::event_manager (interpreter& interp)
68 : m_interpreter (interp), instance (new interpreter_events ()), 68 : m_event_queue_mutex (new mutex ()), m_gui_event_queue (),
69 m_qt_event_handlers (), 69 m_debugging (false), m_link_enabled (true),
70 event_queue_mutex (new mutex ()), gui_event_queue (), 70 m_interpreter (interp), m_instance (new interpreter_events ()),
71 debugging (false), link_enabled (true) 71 m_qt_event_handlers ()
72 { 72 {
73 push_event_queue (); 73 push_event_queue ();
74 command_editor::add_event_hook (readline_event_hook); 74 command_editor::add_event_hook (readline_event_hook);
75 } 75 }
76 76
77 event_manager::~event_manager (void) 77 event_manager::~event_manager (void)
78 { 78 {
79 delete event_queue_mutex; 79 delete m_event_queue_mutex;
80 } 80 }
81 81
82 // Programming Note: It is possible to disable the link without deleting 82 // Programming Note: It is possible to disable the link without deleting
83 // the connection. This allows it to be temporarily disabled. But if 83 // the connection. This allows it to be temporarily disabled. But if
84 // the link is removed, we also set the link_enabled flag to false 84 // the link is removed, we also set the link_enabled flag to false
89 event_manager::connect_link (const std::shared_ptr<interpreter_events>& obj) 89 event_manager::connect_link (const std::shared_ptr<interpreter_events>& obj)
90 { 90 {
91 if (! obj) 91 if (! obj)
92 disable (); 92 disable ();
93 93
94 instance = obj; 94 m_instance = obj;
95 } 95 }
96 96
97 bool event_manager::enable (void) 97 bool event_manager::enable (void)
98 { 98 {
99 bool retval = link_enabled; 99 bool retval = m_link_enabled;
100 100
101 if (instance) 101 if (m_instance)
102 link_enabled = true; 102 m_link_enabled = true;
103 else 103 else
104 warning ("event_manager: must have connected link to enable"); 104 warning ("event_manager: must have connected link to enable");
105 105
106 return retval; 106 return retval;
107 } 107 }
111 if (enabled ()) 111 if (enabled ())
112 { 112 {
113 if (disable_flag) 113 if (disable_flag)
114 disable (); 114 disable ();
115 115
116 event_queue_mutex->lock (); 116 m_event_queue_mutex->lock ();
117 std::shared_ptr<event_queue> evq = gui_event_queue.top (); 117 std::shared_ptr<event_queue> evq = m_gui_event_queue.top ();
118 event_queue_mutex->unlock (); 118 m_event_queue_mutex->unlock ();
119 119
120 evq->run (); 120 evq->run ();
121 } 121 }
122 } 122 }
123 123
124 void event_manager::discard_events (void) 124 void event_manager::discard_events (void)
125 { 125 {
126 if (enabled ()) 126 if (enabled ())
127 { 127 {
128 event_queue_mutex->lock (); 128 m_event_queue_mutex->lock ();
129 std::shared_ptr<event_queue> evq = gui_event_queue.top (); 129 std::shared_ptr<event_queue> evq = m_gui_event_queue.top ();
130 event_queue_mutex->unlock (); 130 m_event_queue_mutex->unlock ();
131 131
132 evq->discard (); 132 evq->discard ();
133 } 133 }
134 } 134 }
135 135
136 void event_manager::push_event_queue (void) 136 void event_manager::push_event_queue (void)
137 { 137 {
138 std::shared_ptr<event_queue> evq (new event_queue ()); 138 std::shared_ptr<event_queue> evq (new event_queue ());
139 gui_event_queue.push (evq); 139 m_gui_event_queue.push (evq);
140 } 140 }
141 141
142 void event_manager::pop_event_queue (void) 142 void event_manager::pop_event_queue (void)
143 { 143 {
144 // FIXME: Should we worry about the possibility of events remaining 144 // FIXME: Should we worry about the possibility of events remaining
148 // that were in the previous queue. This case could happen if 148 // that were in the previous queue. This case could happen if
149 // graphics callback functions were added to the event queue during a 149 // graphics callback functions were added to the event queue during a
150 // debug session just after a dbcont command was added but before it 150 // debug session just after a dbcont command was added but before it
151 // executed and brought us here, for example. 151 // executed and brought us here, for example.
152 152
153 std::shared_ptr<event_queue> evq = gui_event_queue.top (); 153 std::shared_ptr<event_queue> evq = m_gui_event_queue.top ();
154 gui_event_queue.pop (); 154 m_gui_event_queue.pop ();
155 } 155 }
156 156
157 void event_manager::post_event (const fcn_callback& fcn) 157 void event_manager::post_event (const fcn_callback& fcn)
158 { 158 {
159 if (enabled ()) 159 if (enabled ())
160 { 160 {
161 std::shared_ptr<event_queue> evq = gui_event_queue.top (); 161 std::shared_ptr<event_queue> evq = m_gui_event_queue.top ();
162 evq->add (fcn); 162 evq->add (fcn);
163 } 163 }
164 } 164 }
165 165
166 void event_manager::post_event (const meth_callback& meth) 166 void event_manager::post_event (const meth_callback& meth)
167 { 167 {
168 if (enabled ()) 168 if (enabled ())
169 { 169 {
170 std::shared_ptr<event_queue> evq = gui_event_queue.top (); 170 std::shared_ptr<event_queue> evq = m_gui_event_queue.top ();
171 evq->add (std::bind (meth, std::ref (m_interpreter))); 171 evq->add (std::bind (meth, std::ref (m_interpreter)));
172 } 172 }
173 } 173 }
174 174
175 void event_manager::set_workspace (void) 175 void event_manager::set_workspace (void)
176 { 176 {
177 if (enabled ()) 177 if (enabled ())
178 { 178 {
179 tree_evaluator& tw = m_interpreter.get_evaluator (); 179 tree_evaluator& tw = m_interpreter.get_evaluator ();
180 180
181 instance->set_workspace (tw.at_top_level (), debugging, 181 m_instance->set_workspace (tw.at_top_level (), m_debugging,
182 tw.get_symbol_info (), true); 182 tw.get_symbol_info (), true);
183 } 183 }
184 } 184 }
185 185
186 void event_manager::set_history (void) 186 void event_manager::set_history (void)
187 { 187 {
188 if (enabled ()) 188 if (enabled ())
189 instance->set_history (command_history::list ()); 189 m_instance->set_history (command_history::list ());
190 } 190 }
191 191
192 // FIXME: Should the following function be __event_manager_desktop__ 192 // FIXME: Should the following function be __event_manager_desktop__
193 // with the desktop function implemented in a .m file, similar to the 193 // with the desktop function implemented in a .m file, similar to the
194 // way the UI* functions work? 194 // way the UI* functions work?