2 * \file ButtonPolicies.C
3 * Read the file COPYING
7 * Full author contact details are available in file CREDITS
12 #include "ButtonPolicies.h"
21 void nextState(ButtonPolicy::State & state,
22 ButtonPolicy::SMInput in,
23 ButtonPolicy::StateMachine const & s_m,
24 char const * function_name = "nextState")
26 if (ButtonPolicy::SMI_NOOP == in) return;
28 ButtonPolicy::State tmp = s_m[state][in];
30 lyxerr[Debug::GUI] << "Transition from state "
31 << state << " to state " << tmp << " after input "
34 if (ButtonPolicy::BOGUS != tmp) {
37 lyxerr << function_name
38 << ": No transition for input "
49 /*-----------------------------PreferencesPolicy-----------------------------*/
52 PreferencesPolicy::PreferencesPolicy()
54 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
55 state_machine_(APPLIED + 1,
56 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
58 // Build the state output map
59 outputs_[INITIAL] = CLOSE;
60 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
61 outputs_[INVALID] = RESTORE | CANCEL;
62 outputs_[APPLIED] = OKAY | CLOSE;
64 // Build the state machine one state at a time
65 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
66 // left out of the state machine and handled explicitly
67 // in input(). This won't necessarily be true for all
68 // policies though so I'll leave those two as distinct
69 // inputs rather than merge them. For example, a dialog
70 // that doesn't update it's input fields when reshown
71 // after being hidden needs a policy where CANCEL and
72 // HIDE are treated differently.
75 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
76 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
77 state_machine_[INITIAL][SMI_VALID] = VALID;
78 state_machine_[INITIAL][SMI_INVALID] = INVALID;
80 state_machine_[VALID][SMI_VALID] = VALID;
81 state_machine_[VALID][SMI_READ_ONLY] = VALID;
82 state_machine_[VALID][SMI_READ_WRITE] = VALID;
83 state_machine_[VALID][SMI_INVALID] = INVALID;
84 state_machine_[VALID][SMI_APPLY] = APPLIED;
85 state_machine_[VALID][SMI_OKAY] = INITIAL;
86 state_machine_[VALID][SMI_RESTORE] = INITIAL;
88 state_machine_[INVALID][SMI_VALID] = VALID;
89 state_machine_[INVALID][SMI_INVALID] = INVALID;
90 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
91 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
92 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
94 state_machine_[APPLIED][SMI_VALID] = VALID;
95 state_machine_[APPLIED][SMI_INVALID] = INVALID;
96 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
97 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
98 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
102 void PreferencesPolicy::input(SMInput input)
104 //lyxerr << "PreferencesPolicy::input" << endl;
105 // CANCEL and HIDE always take us to INITIAL for all cases.
106 // Note that I didn't put that special case in the helper function
107 // because it doesn't belong there. Some other
108 // This is probably optimising for the wrong case since it occurs as the
109 // dialog will be hidden. It would have saved a little memory in the
110 // state machine if I could have gotten map working. ARRae 20000813
111 if (SMI_CANCEL == input
112 || SMI_HIDE == input) {
118 "PreferencesPolicy");
123 /*-------------------------------OkCancelPolicy------------------------------*/
126 OkCancelPolicy::OkCancelPolicy()
128 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
129 state_machine_(INVALID + 1,
130 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
132 // Build the state output map
133 outputs_[INITIAL] = CLOSE;
134 outputs_[VALID] = RESTORE | OKAY | CANCEL;
135 outputs_[INVALID] = RESTORE | CANCEL;
137 // Build the state machine one state at a time
138 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
139 // left out of the state machine and handled explicitly
143 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
144 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
145 state_machine_[INITIAL][SMI_VALID] = VALID;
146 state_machine_[INITIAL][SMI_INVALID] = INVALID;
148 state_machine_[VALID][SMI_VALID] = VALID;
149 state_machine_[VALID][SMI_READ_ONLY] = VALID;
150 state_machine_[VALID][SMI_READ_WRITE] = VALID;
151 state_machine_[VALID][SMI_INVALID] = INVALID;
152 state_machine_[VALID][SMI_OKAY] = INITIAL;
153 state_machine_[VALID][SMI_RESTORE] = INITIAL;
155 state_machine_[INVALID][SMI_VALID] = VALID;
156 state_machine_[INVALID][SMI_INVALID] = INVALID;
157 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
158 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
159 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
164 void OkCancelPolicy::input(SMInput input)
166 //lyxerr << "OkCancelPolicy::input" << endl;
168 // CANCEL and HIDE always take us to INITIAL for all cases
169 if (SMI_CANCEL == input
170 || SMI_HIDE == input) {
173 nextState(state_, input, state_machine_, "OkCancelPolicy");
178 /*---------------------------OkCancelReadOnlyPolicy-------------------------*/
181 OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
183 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
184 state_machine_(RO_INVALID + 1,
185 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
187 // Build the state output map
188 outputs_[INITIAL] = CLOSE;
189 outputs_[VALID] = RESTORE | OKAY | CANCEL;
190 outputs_[INVALID] = RESTORE | CANCEL;
191 outputs_[RO_INITIAL] = CLOSE;
192 outputs_[RO_VALID] = RESTORE | CANCEL;
193 outputs_[RO_INVALID] = RESTORE | CANCEL;
195 // Build the state machine one state at a time
196 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
197 // left out of the state machine and handled explicitly
201 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
202 state_machine_[INITIAL][SMI_VALID] = VALID;
203 state_machine_[INITIAL][SMI_INVALID] = INVALID;
204 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
206 state_machine_[VALID][SMI_VALID] = VALID;
207 state_machine_[VALID][SMI_READ_WRITE] = VALID;
208 state_machine_[VALID][SMI_INVALID] = INVALID;
209 state_machine_[VALID][SMI_OKAY] = INITIAL;
210 state_machine_[VALID][SMI_RESTORE] = INITIAL;
211 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
213 state_machine_[INVALID][SMI_INVALID] = INVALID;
214 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
215 state_machine_[INVALID][SMI_VALID] = VALID;
216 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
217 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
219 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
220 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
221 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
222 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
224 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
225 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
226 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
227 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
228 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
230 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
231 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
232 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
233 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
234 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
238 void OkCancelReadOnlyPolicy::input(SMInput input)
240 //lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
242 // CANCEL and HIDE always take us to INITIAL for all cases
243 if (SMI_CANCEL == input
244 || SMI_HIDE == input) {
250 "OkCancelReadOnlyPolicy");
255 /*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
258 NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
260 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
261 state_machine_(RO_INVALID + 1,
262 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
264 // Build the state output map
265 outputs_[INITIAL] = CLOSE;
266 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
267 outputs_[INVALID] = RESTORE | CANCEL;
268 outputs_[RO_INITIAL] = CLOSE;
269 outputs_[RO_VALID] = RESTORE | CANCEL;
270 outputs_[RO_INVALID] = RESTORE | CANCEL;
272 // Build the state machine one state at a time
273 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
274 // left out of the state machine and handled explicitly
278 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
279 state_machine_[INITIAL][SMI_VALID] = VALID;
280 state_machine_[INITIAL][SMI_INVALID] = INVALID;
281 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
283 state_machine_[VALID][SMI_VALID] = VALID;
284 state_machine_[VALID][SMI_READ_WRITE] = VALID;
285 state_machine_[VALID][SMI_INVALID] = INVALID;
286 state_machine_[VALID][SMI_OKAY] = INITIAL;
287 state_machine_[VALID][SMI_APPLY] = INITIAL;
288 state_machine_[VALID][SMI_RESTORE] = INITIAL;
289 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
291 state_machine_[INVALID][SMI_INVALID] = INVALID;
292 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
293 state_machine_[INVALID][SMI_VALID] = VALID;
294 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
295 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
297 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
298 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
299 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
300 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
302 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
303 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
304 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
305 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
306 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
308 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
309 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
310 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
311 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
312 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
316 void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
318 //lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
320 // CANCEL and HIDE always take us to INITIAL for all cases
321 if (SMI_CANCEL == input
322 || SMI_HIDE == input) {
328 "NoRepeatedApplyReadOnlyPolicy");
333 /*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
336 OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
338 outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
339 state_machine_(RO_APPLIED + 1,
340 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
342 // Build the state output map
343 outputs_[INITIAL] = CLOSE;
344 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
345 outputs_[INVALID] = RESTORE | CANCEL;
346 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
347 outputs_[RO_INITIAL] = CLOSE;
348 outputs_[RO_VALID] = RESTORE | CANCEL;
349 outputs_[RO_INVALID] = RESTORE | CANCEL;
350 outputs_[RO_APPLIED] = CLOSE;
352 // Build the state machine one state at a time
353 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
354 // left out of the state machine and handled explicitly
358 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
359 state_machine_[INITIAL][SMI_VALID] = VALID;
360 state_machine_[INITIAL][SMI_INVALID] = INVALID;
361 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
363 state_machine_[VALID][SMI_VALID] = VALID;
364 state_machine_[VALID][SMI_READ_WRITE] = VALID;
365 state_machine_[VALID][SMI_INVALID] = INVALID;
366 state_machine_[VALID][SMI_OKAY] = INITIAL;
367 state_machine_[VALID][SMI_RESTORE] = INITIAL;
368 state_machine_[VALID][SMI_APPLY] = APPLIED;
369 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
371 state_machine_[INVALID][SMI_INVALID] = INVALID;
372 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
373 state_machine_[INVALID][SMI_VALID] = VALID;
374 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
375 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
377 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
378 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
379 state_machine_[APPLIED][SMI_VALID] = VALID;
380 state_machine_[APPLIED][SMI_INVALID] = INVALID;
381 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
382 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
384 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
385 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
386 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
387 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
389 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
390 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
391 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
392 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
393 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
395 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
396 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
397 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
398 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
399 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
401 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
402 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
403 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
404 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
408 void OkApplyCancelReadOnlyPolicy::input(SMInput input)
410 //lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
412 // CANCEL and HIDE always take us to INITIAL for all cases
413 if (SMI_CANCEL == input
414 || SMI_HIDE == input) {
420 "OkApplyCancelReadOnlyPolicy");
425 /*--------------------------OkApplyCancelPolicy----------------------*/
428 OkApplyCancelPolicy::OkApplyCancelPolicy()
430 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
431 state_machine_(APPLIED + 1,
432 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
434 // Build the state output map
435 outputs_[INITIAL] = CLOSE;
436 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
437 outputs_[INVALID] = RESTORE | CANCEL;
438 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
440 // Build the state machine one state at a time
441 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
442 // left out of the state machine and handled explicitly
446 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
447 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
448 state_machine_[INITIAL][SMI_VALID] = VALID;
449 state_machine_[INITIAL][SMI_INVALID] = INVALID;
451 state_machine_[VALID][SMI_VALID] = VALID;
452 state_machine_[VALID][SMI_READ_ONLY] = VALID;
453 state_machine_[VALID][SMI_READ_WRITE] = VALID;
454 state_machine_[VALID][SMI_INVALID] = INVALID;
455 state_machine_[VALID][SMI_OKAY] = INITIAL;
456 state_machine_[VALID][SMI_RESTORE] = INITIAL;
457 state_machine_[VALID][SMI_APPLY] = APPLIED;
459 state_machine_[INVALID][SMI_INVALID] = INVALID;
460 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
461 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
462 state_machine_[INVALID][SMI_VALID] = VALID;
463 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
465 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
466 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
467 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
468 state_machine_[APPLIED][SMI_VALID] = VALID;
469 state_machine_[APPLIED][SMI_INVALID] = INVALID;
470 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
474 void OkApplyCancelPolicy::input(SMInput input)
476 //lyxerr << "OkApplyCancelPolicy::input" << endl;
478 // CANCEL and HIDE always take us to INITIAL for all cases
479 if (SMI_CANCEL == input
480 || SMI_HIDE == input) {
486 "OkApplyCancelPolicy");
491 /*--------------------------NoRepeatedApplyPolicy----------------------*/
494 NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
496 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
497 state_machine_(INVALID + 1,
498 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
500 // Build the state output map
501 outputs_[INITIAL] = CLOSE;
502 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
503 outputs_[INVALID] = RESTORE | CANCEL;
505 // Build the state machine one state at a time
506 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
507 // left out of the state machine and handled explicitly
511 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
512 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
513 state_machine_[INITIAL][SMI_VALID] = VALID;
514 state_machine_[INITIAL][SMI_INVALID] = INVALID;
516 state_machine_[VALID][SMI_VALID] = VALID;
517 state_machine_[VALID][SMI_READ_ONLY] = VALID;
518 state_machine_[VALID][SMI_READ_WRITE] = VALID;
519 state_machine_[VALID][SMI_INVALID] = INVALID;
520 state_machine_[VALID][SMI_OKAY] = INITIAL;
521 state_machine_[VALID][SMI_APPLY] = INITIAL;
522 state_machine_[VALID][SMI_RESTORE] = INITIAL;
524 state_machine_[INVALID][SMI_INVALID] = INVALID;
525 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
526 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
527 state_machine_[INVALID][SMI_VALID] = VALID;
528 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
532 void NoRepeatedApplyPolicy::input(SMInput input)
534 //lyxerr << "NoRepeatedApplyPolicy::input" << endl;
536 // CANCEL and HIDE always take us to INITIAL for all cases
537 if (SMI_CANCEL == input
538 || SMI_HIDE == input) {
544 "NoRepeatedApplyPolicy");