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"
25 string const printState(ButtonPolicy::State const & state)
30 case ButtonPolicy::INITIAL:
33 case ButtonPolicy::VALID:
36 case ButtonPolicy::INVALID:
39 case ButtonPolicy::APPLIED:
42 case ButtonPolicy::RO_INITIAL:
43 output = "RO_INITIAL";
45 case ButtonPolicy::RO_VALID:
48 case ButtonPolicy::RO_INVALID:
49 output = "RO_INVALID";
51 case ButtonPolicy::RO_APPLIED:
52 output = "RO_APPLIED";
54 case ButtonPolicy::BOGUS:
63 string const printInput(ButtonPolicy::SMInput const & input)
68 case ButtonPolicy::SMI_VALID:
71 case ButtonPolicy::SMI_INVALID:
72 output = "SMI_INVALID";
74 case ButtonPolicy::SMI_OKAY:
77 case ButtonPolicy::SMI_APPLY:
80 case ButtonPolicy::SMI_CANCEL:
81 output = "SMI_CANCEL";
83 case ButtonPolicy::SMI_RESTORE:
84 output = "SMI_RESTORE";
86 case ButtonPolicy::SMI_HIDE:
89 case ButtonPolicy::SMI_READ_ONLY:
90 output = "SMI_READ_ONLY";
92 case ButtonPolicy::SMI_READ_WRITE:
93 output = "SMI_READ_WRITE";
95 case ButtonPolicy::SMI_NOOP:
98 case ButtonPolicy::SMI_TOTAL:
108 void nextState(ButtonPolicy::State & state,
109 ButtonPolicy::SMInput in,
110 ButtonPolicy::StateMachine const & s_m,
111 char const * function_name = "nextState")
113 if (ButtonPolicy::SMI_NOOP == in) return;
115 ButtonPolicy::State tmp = s_m[state][in];
117 lyxerr[Debug::GUI] << "Transition from state "
118 << printState(state) << " to state "
119 << printState(tmp) << " after input "
120 << printInput(in) << std::endl;
122 if (ButtonPolicy::BOGUS != tmp) {
125 lyxerr << function_name
126 << ": No transition for input "
137 /*-----------------------------PreferencesPolicy-----------------------------*/
140 PreferencesPolicy::PreferencesPolicy()
142 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
143 state_machine_(APPLIED + 1,
144 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
146 // Build the state output map
147 outputs_[INITIAL] = CLOSE;
148 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
149 outputs_[INVALID] = RESTORE | CANCEL;
150 outputs_[APPLIED] = OKAY | CLOSE;
152 // Build the state machine one state at a time
153 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
154 // left out of the state machine and handled explicitly
155 // in input(). This won't necessarily be true for all
156 // policies though so I'll leave those two as distinct
157 // inputs rather than merge them. For example, a dialog
158 // that doesn't update it's input fields when reshown
159 // after being hidden needs a policy where CANCEL and
160 // HIDE are treated differently.
163 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
164 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
165 state_machine_[INITIAL][SMI_VALID] = VALID;
166 state_machine_[INITIAL][SMI_INVALID] = INVALID;
168 state_machine_[VALID][SMI_VALID] = VALID;
169 state_machine_[VALID][SMI_READ_ONLY] = VALID;
170 state_machine_[VALID][SMI_READ_WRITE] = VALID;
171 state_machine_[VALID][SMI_INVALID] = INVALID;
172 state_machine_[VALID][SMI_APPLY] = APPLIED;
173 state_machine_[VALID][SMI_OKAY] = INITIAL;
174 state_machine_[VALID][SMI_RESTORE] = INITIAL;
176 state_machine_[INVALID][SMI_VALID] = VALID;
177 state_machine_[INVALID][SMI_INVALID] = INVALID;
178 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
179 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
180 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
182 state_machine_[APPLIED][SMI_VALID] = VALID;
183 state_machine_[APPLIED][SMI_INVALID] = INVALID;
184 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
185 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
186 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
190 void PreferencesPolicy::input(SMInput input)
192 // The APPLIED state is persistent. Next time the dialog is opened,
193 // the user will be able to press 'Save'.
194 if (SMI_CANCEL == input
195 || SMI_HIDE == input) {
196 if (state_ != APPLIED)
202 "PreferencesPolicy");
207 /*-------------------------------OkCancelPolicy------------------------------*/
210 OkCancelPolicy::OkCancelPolicy()
212 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
213 state_machine_(INVALID + 1,
214 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
216 // Build the state output map
217 outputs_[INITIAL] = CLOSE;
218 outputs_[VALID] = RESTORE | OKAY | CANCEL;
219 outputs_[INVALID] = RESTORE | CANCEL;
221 // Build the state machine one state at a time
222 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
223 // left out of the state machine and handled explicitly
227 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
228 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
229 state_machine_[INITIAL][SMI_VALID] = VALID;
230 state_machine_[INITIAL][SMI_INVALID] = INVALID;
232 state_machine_[VALID][SMI_VALID] = VALID;
233 state_machine_[VALID][SMI_READ_ONLY] = VALID;
234 state_machine_[VALID][SMI_READ_WRITE] = VALID;
235 state_machine_[VALID][SMI_INVALID] = INVALID;
236 state_machine_[VALID][SMI_OKAY] = INITIAL;
237 state_machine_[VALID][SMI_RESTORE] = INITIAL;
239 state_machine_[INVALID][SMI_VALID] = VALID;
240 state_machine_[INVALID][SMI_INVALID] = INVALID;
241 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
242 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
243 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
248 void OkCancelPolicy::input(SMInput input)
250 //lyxerr << "OkCancelPolicy::input" << endl;
252 // CANCEL and HIDE always take us to INITIAL for all cases
253 if (SMI_CANCEL == input
254 || SMI_HIDE == input) {
257 nextState(state_, input, state_machine_, "OkCancelPolicy");
262 /*---------------------------OkCancelReadOnlyPolicy-------------------------*/
265 OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
267 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
268 state_machine_(RO_INVALID + 1,
269 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
271 // Build the state output map
272 outputs_[INITIAL] = CLOSE;
273 outputs_[VALID] = RESTORE | OKAY | CANCEL;
274 outputs_[INVALID] = RESTORE | CANCEL;
275 outputs_[RO_INITIAL] = CLOSE;
276 outputs_[RO_VALID] = RESTORE | CANCEL;
277 outputs_[RO_INVALID] = RESTORE | CANCEL;
279 // Build the state machine one state at a time
280 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
281 // left out of the state machine and handled explicitly
285 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
286 state_machine_[INITIAL][SMI_VALID] = VALID;
287 state_machine_[INITIAL][SMI_INVALID] = INVALID;
288 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
290 state_machine_[VALID][SMI_VALID] = VALID;
291 state_machine_[VALID][SMI_READ_WRITE] = VALID;
292 state_machine_[VALID][SMI_INVALID] = INVALID;
293 state_machine_[VALID][SMI_OKAY] = INITIAL;
294 state_machine_[VALID][SMI_RESTORE] = INITIAL;
295 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
297 state_machine_[INVALID][SMI_INVALID] = INVALID;
298 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
299 state_machine_[INVALID][SMI_VALID] = VALID;
300 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
301 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
303 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
304 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
305 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
306 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
308 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
309 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
310 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
311 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
312 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
314 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
315 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
316 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
317 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
318 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
322 void OkCancelReadOnlyPolicy::input(SMInput input)
324 //lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
326 // CANCEL and HIDE always take us to INITIAL for all cases
327 if (SMI_CANCEL == input
328 || SMI_HIDE == input) {
334 "OkCancelReadOnlyPolicy");
339 /*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
342 NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
344 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
345 state_machine_(RO_INVALID + 1,
346 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
348 // Build the state output map
349 outputs_[INITIAL] = CLOSE;
350 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
351 outputs_[INVALID] = RESTORE | CANCEL;
352 outputs_[RO_INITIAL] = CLOSE;
353 outputs_[RO_VALID] = RESTORE | CANCEL;
354 outputs_[RO_INVALID] = RESTORE | CANCEL;
356 // Build the state machine one state at a time
357 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
358 // left out of the state machine and handled explicitly
362 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
363 state_machine_[INITIAL][SMI_VALID] = VALID;
364 state_machine_[INITIAL][SMI_INVALID] = INVALID;
365 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
367 state_machine_[VALID][SMI_VALID] = VALID;
368 state_machine_[VALID][SMI_READ_WRITE] = VALID;
369 state_machine_[VALID][SMI_INVALID] = INVALID;
370 state_machine_[VALID][SMI_OKAY] = INITIAL;
371 state_machine_[VALID][SMI_APPLY] = INITIAL;
372 state_machine_[VALID][SMI_RESTORE] = INITIAL;
373 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
375 state_machine_[INVALID][SMI_INVALID] = INVALID;
376 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
377 state_machine_[INVALID][SMI_VALID] = VALID;
378 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
379 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
381 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
382 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
383 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
384 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
386 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
387 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
388 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
389 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
390 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
392 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
393 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
394 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
395 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
396 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
400 void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
402 //lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
404 // CANCEL and HIDE always take us to INITIAL for all cases
405 if (SMI_CANCEL == input
406 || SMI_HIDE == input) {
412 "NoRepeatedApplyReadOnlyPolicy");
417 /*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
420 OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
422 outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
423 state_machine_(RO_APPLIED + 1,
424 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
426 // Build the state output map
427 outputs_[INITIAL] = CLOSE;
428 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
429 outputs_[INVALID] = RESTORE | CANCEL;
430 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
431 outputs_[RO_INITIAL] = CLOSE;
432 outputs_[RO_VALID] = RESTORE | CANCEL;
433 outputs_[RO_INVALID] = RESTORE | CANCEL;
434 outputs_[RO_APPLIED] = CLOSE;
436 // Build the state machine one state at a time
437 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
438 // left out of the state machine and handled explicitly
442 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
443 state_machine_[INITIAL][SMI_VALID] = VALID;
444 state_machine_[INITIAL][SMI_INVALID] = INVALID;
445 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
447 state_machine_[VALID][SMI_VALID] = VALID;
448 state_machine_[VALID][SMI_READ_WRITE] = VALID;
449 state_machine_[VALID][SMI_INVALID] = INVALID;
450 state_machine_[VALID][SMI_OKAY] = INITIAL;
451 state_machine_[VALID][SMI_RESTORE] = INITIAL;
452 state_machine_[VALID][SMI_APPLY] = APPLIED;
453 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
455 state_machine_[INVALID][SMI_INVALID] = INVALID;
456 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
457 state_machine_[INVALID][SMI_VALID] = VALID;
458 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
459 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
461 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
462 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
463 state_machine_[APPLIED][SMI_VALID] = VALID;
464 state_machine_[APPLIED][SMI_INVALID] = INVALID;
465 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
466 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
468 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
469 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
470 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
471 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
473 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
474 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
475 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
476 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
477 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
479 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
480 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
481 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
482 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
483 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
485 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
486 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
487 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
488 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
492 void OkApplyCancelReadOnlyPolicy::input(SMInput input)
494 //lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
496 // CANCEL and HIDE always take us to INITIAL for all cases
497 if (SMI_CANCEL == input
498 || SMI_HIDE == input) {
504 "OkApplyCancelReadOnlyPolicy");
509 /*--------------------------OkApplyCancelPolicy----------------------*/
512 OkApplyCancelPolicy::OkApplyCancelPolicy()
514 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
515 state_machine_(APPLIED + 1,
516 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
518 // Build the state output map
519 outputs_[INITIAL] = CLOSE;
520 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
521 outputs_[INVALID] = RESTORE | CANCEL;
522 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
524 // Build the state machine one state at a time
525 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
526 // left out of the state machine and handled explicitly
530 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
531 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
532 state_machine_[INITIAL][SMI_VALID] = VALID;
533 state_machine_[INITIAL][SMI_INVALID] = INVALID;
535 state_machine_[VALID][SMI_VALID] = VALID;
536 state_machine_[VALID][SMI_READ_ONLY] = VALID;
537 state_machine_[VALID][SMI_READ_WRITE] = VALID;
538 state_machine_[VALID][SMI_INVALID] = INVALID;
539 state_machine_[VALID][SMI_OKAY] = INITIAL;
540 state_machine_[VALID][SMI_RESTORE] = INITIAL;
541 state_machine_[VALID][SMI_APPLY] = APPLIED;
543 state_machine_[INVALID][SMI_INVALID] = INVALID;
544 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
545 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
546 state_machine_[INVALID][SMI_VALID] = VALID;
547 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
549 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
550 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
551 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
552 state_machine_[APPLIED][SMI_VALID] = VALID;
553 state_machine_[APPLIED][SMI_INVALID] = INVALID;
554 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
558 void OkApplyCancelPolicy::input(SMInput input)
560 //lyxerr << "OkApplyCancelPolicy::input" << endl;
562 // CANCEL and HIDE always take us to INITIAL for all cases
563 if (SMI_CANCEL == input
564 || SMI_HIDE == input) {
570 "OkApplyCancelPolicy");
575 /*--------------------------NoRepeatedApplyPolicy----------------------*/
578 NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
580 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
581 state_machine_(INVALID + 1,
582 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
584 // Build the state output map
585 outputs_[INITIAL] = CLOSE;
586 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
587 outputs_[INVALID] = RESTORE | CANCEL;
589 // Build the state machine one state at a time
590 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
591 // left out of the state machine and handled explicitly
595 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
596 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
597 state_machine_[INITIAL][SMI_VALID] = VALID;
598 state_machine_[INITIAL][SMI_INVALID] = INVALID;
600 state_machine_[VALID][SMI_VALID] = VALID;
601 state_machine_[VALID][SMI_READ_ONLY] = VALID;
602 state_machine_[VALID][SMI_READ_WRITE] = VALID;
603 state_machine_[VALID][SMI_INVALID] = INVALID;
604 state_machine_[VALID][SMI_OKAY] = INITIAL;
605 state_machine_[VALID][SMI_APPLY] = INITIAL;
606 state_machine_[VALID][SMI_RESTORE] = INITIAL;
608 state_machine_[INVALID][SMI_INVALID] = INVALID;
609 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
610 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
611 state_machine_[INVALID][SMI_VALID] = VALID;
612 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
616 void NoRepeatedApplyPolicy::input(SMInput input)
618 //lyxerr << "NoRepeatedApplyPolicy::input" << endl;
620 // CANCEL and HIDE always take us to INITIAL for all cases
621 if (SMI_CANCEL == input
622 || SMI_HIDE == input) {
628 "NoRepeatedApplyPolicy");
632 } // namespace frontend