2 * \file ButtonPolicies.C
3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
8 * Full author contact details are available in file CREDITS.
13 #include "ButtonPolicies.h"
22 string const printState(ButtonPolicy::State const & state)
27 case ButtonPolicy::INITIAL:
30 case ButtonPolicy::VALID:
33 case ButtonPolicy::INVALID:
36 case ButtonPolicy::APPLIED:
39 case ButtonPolicy::RO_INITIAL:
40 output = "RO_INITIAL";
42 case ButtonPolicy::RO_VALID:
45 case ButtonPolicy::RO_INVALID:
46 output = "RO_INVALID";
48 case ButtonPolicy::RO_APPLIED:
49 output = "RO_APPLIED";
51 case ButtonPolicy::BOGUS:
60 string const printInput(ButtonPolicy::SMInput const & input)
65 case ButtonPolicy::SMI_VALID:
68 case ButtonPolicy::SMI_INVALID:
69 output = "SMI_INVALID";
71 case ButtonPolicy::SMI_OKAY:
74 case ButtonPolicy::SMI_APPLY:
77 case ButtonPolicy::SMI_CANCEL:
78 output = "SMI_CANCEL";
80 case ButtonPolicy::SMI_RESTORE:
81 output = "SMI_RESTORE";
83 case ButtonPolicy::SMI_HIDE:
86 case ButtonPolicy::SMI_READ_ONLY:
87 output = "SMI_READ_ONLY";
89 case ButtonPolicy::SMI_READ_WRITE:
90 output = "SMI_READ_WRITE";
92 case ButtonPolicy::SMI_NOOP:
95 case ButtonPolicy::SMI_TOTAL:
105 void nextState(ButtonPolicy::State & state,
106 ButtonPolicy::SMInput in,
107 ButtonPolicy::StateMachine const & s_m,
108 char const * function_name = "nextState")
110 if (ButtonPolicy::SMI_NOOP == in) return;
112 ButtonPolicy::State tmp = s_m[state][in];
114 lyxerr[Debug::GUI] << "Transition from state "
115 << printState(state) << " to state "
116 << printState(tmp) << " after input "
117 << printInput(in) << std::endl;
119 if (ButtonPolicy::BOGUS != tmp) {
122 lyxerr << function_name
123 << ": No transition for input "
134 /*-----------------------------PreferencesPolicy-----------------------------*/
137 PreferencesPolicy::PreferencesPolicy()
139 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
140 state_machine_(APPLIED + 1,
141 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
143 // Build the state output map
144 outputs_[INITIAL] = CLOSE;
145 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
146 outputs_[INVALID] = RESTORE | CANCEL;
147 outputs_[APPLIED] = OKAY | CLOSE;
149 // Build the state machine one state at a time
150 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
151 // left out of the state machine and handled explicitly
152 // in input(). This won't necessarily be true for all
153 // policies though so I'll leave those two as distinct
154 // inputs rather than merge them. For example, a dialog
155 // that doesn't update it's input fields when reshown
156 // after being hidden needs a policy where CANCEL and
157 // HIDE are treated differently.
160 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
161 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
162 state_machine_[INITIAL][SMI_VALID] = VALID;
163 state_machine_[INITIAL][SMI_INVALID] = INVALID;
165 state_machine_[VALID][SMI_VALID] = VALID;
166 state_machine_[VALID][SMI_READ_ONLY] = VALID;
167 state_machine_[VALID][SMI_READ_WRITE] = VALID;
168 state_machine_[VALID][SMI_INVALID] = INVALID;
169 state_machine_[VALID][SMI_APPLY] = APPLIED;
170 state_machine_[VALID][SMI_OKAY] = INITIAL;
171 state_machine_[VALID][SMI_RESTORE] = INITIAL;
173 state_machine_[INVALID][SMI_VALID] = VALID;
174 state_machine_[INVALID][SMI_INVALID] = INVALID;
175 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
176 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
177 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
179 state_machine_[APPLIED][SMI_VALID] = VALID;
180 state_machine_[APPLIED][SMI_INVALID] = INVALID;
181 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
182 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
183 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
187 void PreferencesPolicy::input(SMInput input)
189 // The APPLIED state is persistent. Next time the dialog is opened,
190 // the user will be able to press 'Save'.
191 if (SMI_CANCEL == input
192 || SMI_HIDE == input) {
193 if (state_ != APPLIED)
199 "PreferencesPolicy");
204 /*-------------------------------OkCancelPolicy------------------------------*/
207 OkCancelPolicy::OkCancelPolicy()
209 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
210 state_machine_(INVALID + 1,
211 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
213 // Build the state output map
214 outputs_[INITIAL] = CLOSE;
215 outputs_[VALID] = RESTORE | OKAY | CANCEL;
216 outputs_[INVALID] = RESTORE | CANCEL;
218 // Build the state machine one state at a time
219 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
220 // left out of the state machine and handled explicitly
224 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
225 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
226 state_machine_[INITIAL][SMI_VALID] = VALID;
227 state_machine_[INITIAL][SMI_INVALID] = INVALID;
229 state_machine_[VALID][SMI_VALID] = VALID;
230 state_machine_[VALID][SMI_READ_ONLY] = VALID;
231 state_machine_[VALID][SMI_READ_WRITE] = VALID;
232 state_machine_[VALID][SMI_INVALID] = INVALID;
233 state_machine_[VALID][SMI_OKAY] = INITIAL;
234 state_machine_[VALID][SMI_RESTORE] = INITIAL;
236 state_machine_[INVALID][SMI_VALID] = VALID;
237 state_machine_[INVALID][SMI_INVALID] = INVALID;
238 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
239 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
240 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
245 void OkCancelPolicy::input(SMInput input)
247 //lyxerr << "OkCancelPolicy::input" << endl;
249 // CANCEL and HIDE always take us to INITIAL for all cases
250 if (SMI_CANCEL == input
251 || SMI_HIDE == input) {
254 nextState(state_, input, state_machine_, "OkCancelPolicy");
259 /*---------------------------OkCancelReadOnlyPolicy-------------------------*/
262 OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
264 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
265 state_machine_(RO_INVALID + 1,
266 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
268 // Build the state output map
269 outputs_[INITIAL] = CLOSE;
270 outputs_[VALID] = RESTORE | OKAY | CANCEL;
271 outputs_[INVALID] = RESTORE | CANCEL;
272 outputs_[RO_INITIAL] = CLOSE;
273 outputs_[RO_VALID] = RESTORE | CANCEL;
274 outputs_[RO_INVALID] = RESTORE | CANCEL;
276 // Build the state machine one state at a time
277 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
278 // left out of the state machine and handled explicitly
282 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
283 state_machine_[INITIAL][SMI_VALID] = VALID;
284 state_machine_[INITIAL][SMI_INVALID] = INVALID;
285 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
287 state_machine_[VALID][SMI_VALID] = VALID;
288 state_machine_[VALID][SMI_READ_WRITE] = VALID;
289 state_machine_[VALID][SMI_INVALID] = INVALID;
290 state_machine_[VALID][SMI_OKAY] = INITIAL;
291 state_machine_[VALID][SMI_RESTORE] = INITIAL;
292 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
294 state_machine_[INVALID][SMI_INVALID] = INVALID;
295 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
296 state_machine_[INVALID][SMI_VALID] = VALID;
297 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
298 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
300 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
301 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
302 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
303 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
305 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
306 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
307 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
308 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
309 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
311 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
312 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
313 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
314 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
315 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
319 void OkCancelReadOnlyPolicy::input(SMInput input)
321 //lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
323 // CANCEL and HIDE always take us to INITIAL for all cases
324 if (SMI_CANCEL == input
325 || SMI_HIDE == input) {
331 "OkCancelReadOnlyPolicy");
336 /*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
339 NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
341 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
342 state_machine_(RO_INVALID + 1,
343 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
345 // Build the state output map
346 outputs_[INITIAL] = CLOSE;
347 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
348 outputs_[INVALID] = RESTORE | CANCEL;
349 outputs_[RO_INITIAL] = CLOSE;
350 outputs_[RO_VALID] = RESTORE | CANCEL;
351 outputs_[RO_INVALID] = RESTORE | CANCEL;
353 // Build the state machine one state at a time
354 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
355 // left out of the state machine and handled explicitly
359 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
360 state_machine_[INITIAL][SMI_VALID] = VALID;
361 state_machine_[INITIAL][SMI_INVALID] = INVALID;
362 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
364 state_machine_[VALID][SMI_VALID] = VALID;
365 state_machine_[VALID][SMI_READ_WRITE] = VALID;
366 state_machine_[VALID][SMI_INVALID] = INVALID;
367 state_machine_[VALID][SMI_OKAY] = INITIAL;
368 state_machine_[VALID][SMI_APPLY] = INITIAL;
369 state_machine_[VALID][SMI_RESTORE] = INITIAL;
370 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
372 state_machine_[INVALID][SMI_INVALID] = INVALID;
373 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
374 state_machine_[INVALID][SMI_VALID] = VALID;
375 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
376 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
378 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
379 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
380 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
381 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
383 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
384 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
385 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
386 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
387 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
389 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
390 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
391 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
392 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
393 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
397 void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
399 //lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
401 // CANCEL and HIDE always take us to INITIAL for all cases
402 if (SMI_CANCEL == input
403 || SMI_HIDE == input) {
409 "NoRepeatedApplyReadOnlyPolicy");
414 /*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
417 OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
419 outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
420 state_machine_(RO_APPLIED + 1,
421 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
423 // Build the state output map
424 outputs_[INITIAL] = CLOSE;
425 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
426 outputs_[INVALID] = RESTORE | CANCEL;
427 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
428 outputs_[RO_INITIAL] = CLOSE;
429 outputs_[RO_VALID] = RESTORE | CANCEL;
430 outputs_[RO_INVALID] = RESTORE | CANCEL;
431 outputs_[RO_APPLIED] = CLOSE;
433 // Build the state machine one state at a time
434 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
435 // left out of the state machine and handled explicitly
439 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
440 state_machine_[INITIAL][SMI_VALID] = VALID;
441 state_machine_[INITIAL][SMI_INVALID] = INVALID;
442 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
444 state_machine_[VALID][SMI_VALID] = VALID;
445 state_machine_[VALID][SMI_READ_WRITE] = VALID;
446 state_machine_[VALID][SMI_INVALID] = INVALID;
447 state_machine_[VALID][SMI_OKAY] = INITIAL;
448 state_machine_[VALID][SMI_RESTORE] = INITIAL;
449 state_machine_[VALID][SMI_APPLY] = APPLIED;
450 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
452 state_machine_[INVALID][SMI_INVALID] = INVALID;
453 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
454 state_machine_[INVALID][SMI_VALID] = VALID;
455 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
456 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
458 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
459 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
460 state_machine_[APPLIED][SMI_VALID] = VALID;
461 state_machine_[APPLIED][SMI_INVALID] = INVALID;
462 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
463 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
465 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
466 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
467 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
468 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
470 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
471 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
472 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
473 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
474 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
476 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
477 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
478 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
479 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
480 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
482 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
483 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
484 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
485 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
489 void OkApplyCancelReadOnlyPolicy::input(SMInput input)
491 //lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
493 // CANCEL and HIDE always take us to INITIAL for all cases
494 if (SMI_CANCEL == input
495 || SMI_HIDE == input) {
501 "OkApplyCancelReadOnlyPolicy");
506 /*--------------------------OkApplyCancelPolicy----------------------*/
509 OkApplyCancelPolicy::OkApplyCancelPolicy()
511 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
512 state_machine_(APPLIED + 1,
513 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
515 // Build the state output map
516 outputs_[INITIAL] = CLOSE;
517 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
518 outputs_[INVALID] = RESTORE | CANCEL;
519 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
521 // Build the state machine one state at a time
522 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
523 // left out of the state machine and handled explicitly
527 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
528 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
529 state_machine_[INITIAL][SMI_VALID] = VALID;
530 state_machine_[INITIAL][SMI_INVALID] = INVALID;
532 state_machine_[VALID][SMI_VALID] = VALID;
533 state_machine_[VALID][SMI_READ_ONLY] = VALID;
534 state_machine_[VALID][SMI_READ_WRITE] = VALID;
535 state_machine_[VALID][SMI_INVALID] = INVALID;
536 state_machine_[VALID][SMI_OKAY] = INITIAL;
537 state_machine_[VALID][SMI_RESTORE] = INITIAL;
538 state_machine_[VALID][SMI_APPLY] = APPLIED;
540 state_machine_[INVALID][SMI_INVALID] = INVALID;
541 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
542 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
543 state_machine_[INVALID][SMI_VALID] = VALID;
544 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
546 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
547 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
548 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
549 state_machine_[APPLIED][SMI_VALID] = VALID;
550 state_machine_[APPLIED][SMI_INVALID] = INVALID;
551 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
555 void OkApplyCancelPolicy::input(SMInput input)
557 //lyxerr << "OkApplyCancelPolicy::input" << endl;
559 // CANCEL and HIDE always take us to INITIAL for all cases
560 if (SMI_CANCEL == input
561 || SMI_HIDE == input) {
567 "OkApplyCancelPolicy");
572 /*--------------------------NoRepeatedApplyPolicy----------------------*/
575 NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
577 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
578 state_machine_(INVALID + 1,
579 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
581 // Build the state output map
582 outputs_[INITIAL] = CLOSE;
583 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
584 outputs_[INVALID] = RESTORE | CANCEL;
586 // Build the state machine one state at a time
587 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
588 // left out of the state machine and handled explicitly
592 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
593 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
594 state_machine_[INITIAL][SMI_VALID] = VALID;
595 state_machine_[INITIAL][SMI_INVALID] = INVALID;
597 state_machine_[VALID][SMI_VALID] = VALID;
598 state_machine_[VALID][SMI_READ_ONLY] = VALID;
599 state_machine_[VALID][SMI_READ_WRITE] = VALID;
600 state_machine_[VALID][SMI_INVALID] = INVALID;
601 state_machine_[VALID][SMI_OKAY] = INITIAL;
602 state_machine_[VALID][SMI_APPLY] = INITIAL;
603 state_machine_[VALID][SMI_RESTORE] = INITIAL;
605 state_machine_[INVALID][SMI_INVALID] = INVALID;
606 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
607 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
608 state_machine_[INVALID][SMI_VALID] = VALID;
609 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
613 void NoRepeatedApplyPolicy::input(SMInput input)
615 //lyxerr << "NoRepeatedApplyPolicy::input" << endl;
617 // CANCEL and HIDE always take us to INITIAL for all cases
618 if (SMI_CANCEL == input
619 || SMI_HIDE == input) {
625 "NoRepeatedApplyPolicy");