2 * \file ButtonPolicy.cpp
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 "ButtonPolicy.h"
15 #include "support/debug.h"
25 static char const * printState(ButtonPolicy::State const & state)
28 case ButtonPolicy::INITIAL:
30 case ButtonPolicy::VALID:
32 case ButtonPolicy::INVALID:
34 case ButtonPolicy::APPLIED:
36 case ButtonPolicy::AUTOAPPLY_INITIAL:
37 return "AUTOAPPLY_INITIAL";
38 case ButtonPolicy::AUTOAPPLY_CHANGED:
39 return "AUTOAPPLY_CHANGED";
40 case ButtonPolicy::RO_INITIAL:
42 case ButtonPolicy::RO_VALID:
44 case ButtonPolicy::RO_INVALID:
46 case ButtonPolicy::RO_APPLIED:
48 case ButtonPolicy::RO_AUTOAPPLY:
49 return "RO_AUTOAPPLY";
50 case ButtonPolicy::BOGUS:
58 static char const * printInput(ButtonPolicy::SMInput const & input)
61 case ButtonPolicy::SMI_VALID:
63 case ButtonPolicy::SMI_INVALID:
65 case ButtonPolicy::SMI_OKAY:
67 case ButtonPolicy::SMI_APPLY:
69 case ButtonPolicy::SMI_CANCEL:
71 case ButtonPolicy::SMI_RESTORE:
73 case ButtonPolicy::SMI_AUTOAPPLY:
74 return "SMI_AUTOAPPLY";
75 case ButtonPolicy::SMI_HIDE:
77 case ButtonPolicy::SMI_READ_ONLY:
78 return "SMI_READ_ONLY";
79 case ButtonPolicy::SMI_READ_WRITE:
80 return "SMI_READ_WRITE";
81 case ButtonPolicy::SMI_NOOP:
83 case ButtonPolicy::SMI_TOTAL:
91 char const * functionName(ButtonPolicy::Policy policy)
94 case ButtonPolicy::PreferencesPolicy:
95 return "PreferencesPolicy";
96 case ButtonPolicy::OkCancelPolicy:
97 return "OkCancelPolicy";
98 case ButtonPolicy::OkCancelReadOnlyPolicy:
99 return "OkCancelReadOnlyPolicy";
100 case ButtonPolicy::OkApplyCancelPolicy:
101 return "OkApplyCancelPolicy";
102 case ButtonPolicy::OkApplyCancelReadOnlyPolicy:
103 return "OkApplyCancelReadOnlyPolicy";
104 case ButtonPolicy::OkApplyCancelAutoReadOnlyPolicy:
105 return "OkApplyCancelAutoReadOnlyPolicy";
106 case ButtonPolicy::NoRepeatedApplyPolicy:
107 return "NoRepeatedApplyPolicy";
108 case ButtonPolicy::NoRepeatedApplyReadOnlyPolicy:
109 return "NoRepeatedApplyReadOnlyPolicy";
110 case ButtonPolicy::IgnorantPolicy:
111 return "IgnorantPolicy";
113 return "Unknown policy";
118 ostream & operator<<(ostream & os, ButtonPolicy::State st)
120 return os << int(st);
124 ostream & operator<<(ostream & os, ButtonPolicy::SMInput smi)
126 return os << int(smi);
130 /////////////////////////////////////////////////////////////////////////
132 // ButtonPolicy::Private
134 /////////////////////////////////////////////////////////////////////////
136 class ButtonPolicy::Private
139 typedef ButtonPolicy::SMInput SMInput;
140 typedef ButtonPolicy::Policy Policy;
141 typedef ButtonPolicy::State State;
143 Private(Policy policy);
145 void nextState(SMInput input);
148 void initOkCancelReadOnly();
149 void initNoRepeatedApplyReadOnly();
150 void initOkApplyCancelReadOnly();
151 void initOkApplyCancelAutoReadOnly();
152 void initOkApplyCancel();
153 void initNoRepeatedApply();
154 void initPreferences();
160 /// Transition map of the state machine.
161 typedef std::vector<State> StateArray;
163 typedef std::vector<StateArray> StateMachine;
164 /// The state outputs are the status of the buttons.
165 typedef std::vector<int> StateOutputs;
169 /// Which buttons are active for a given state.
170 StateOutputs outputs_;
172 StateMachine state_machine_;
176 ButtonPolicy::Private::Private(Policy policy)
185 case OkCancelReadOnlyPolicy:
186 initOkCancelReadOnly();
188 case OkApplyCancelPolicy:
191 case OkApplyCancelReadOnlyPolicy:
192 initOkApplyCancelReadOnly();
194 case OkApplyCancelAutoReadOnlyPolicy:
195 initOkApplyCancelAutoReadOnly();
197 case NoRepeatedApplyPolicy:
198 initNoRepeatedApply();
200 case NoRepeatedApplyReadOnlyPolicy:
201 initNoRepeatedApplyReadOnly();
203 case PreferencesPolicy:
212 void ButtonPolicy::Private::nextState(SMInput input)
214 if (SMI_NOOP == input)
217 State tmp = state_machine_[state_][input];
219 LYXERR(Debug::GUI, "Transition from state "
220 << printState(state_) << " to state "
221 << printState(tmp) << " after input "
222 << printInput(input));
227 LYXERR0(functionName(policy_) << ": No transition for input "
228 << printInput(input) << " from state " << printState(state_));
233 void ButtonPolicy::Private::initPreferences()
235 outputs_ = StateOutputs(APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
236 state_machine_ = StateMachine(APPLIED + 1,
237 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
239 // Build the state output map
240 outputs_[INITIAL] = CLOSE;
241 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
242 outputs_[INVALID] = RESTORE | CANCEL;
243 outputs_[APPLIED] = OKAY | CLOSE;
245 // Build the state machine one state at a time
246 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
247 // left out of the state machine and handled explicitly
248 // in input(). This won't necessarily be true for all
249 // policies though so I'll leave those two as distinct
250 // inputs rather than merge them. For example, a dialog
251 // that doesn't update it's input fields when reshown
252 // after being hidden needs a policy where CANCEL and
253 // HIDE are treated differently.
256 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
257 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
258 state_machine_[INITIAL][SMI_VALID] = VALID;
259 state_machine_[INITIAL][SMI_INVALID] = INVALID;
261 state_machine_[VALID][SMI_VALID] = VALID;
262 state_machine_[VALID][SMI_READ_ONLY] = VALID;
263 state_machine_[VALID][SMI_READ_WRITE] = VALID;
264 state_machine_[VALID][SMI_INVALID] = INVALID;
265 state_machine_[VALID][SMI_APPLY] = APPLIED;
266 state_machine_[VALID][SMI_OKAY] = INITIAL;
267 state_machine_[VALID][SMI_RESTORE] = INITIAL;
269 state_machine_[INVALID][SMI_VALID] = VALID;
270 state_machine_[INVALID][SMI_INVALID] = INVALID;
271 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
272 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
273 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
275 state_machine_[APPLIED][SMI_VALID] = VALID;
276 state_machine_[APPLIED][SMI_INVALID] = INVALID;
277 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
278 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
279 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
283 void ButtonPolicy::Private::initOkCancel()
285 outputs_ = StateOutputs(INVALID + 1, ButtonPolicy::ALL_BUTTONS);
286 state_machine_ = StateMachine(INVALID + 1,
287 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
289 // Build the state output map
290 outputs_[INITIAL] = CLOSE;
291 outputs_[VALID] = RESTORE | OKAY | CANCEL;
292 outputs_[INVALID] = RESTORE | CANCEL;
294 // Build the state machine one state at a time
295 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
296 // left out of the state machine and handled explicitly
300 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
301 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
302 state_machine_[INITIAL][SMI_VALID] = VALID;
303 state_machine_[INITIAL][SMI_INVALID] = INVALID;
305 state_machine_[VALID][SMI_VALID] = VALID;
306 state_machine_[VALID][SMI_READ_ONLY] = VALID;
307 state_machine_[VALID][SMI_READ_WRITE] = VALID;
308 state_machine_[VALID][SMI_INVALID] = INVALID;
309 state_machine_[VALID][SMI_OKAY] = INITIAL;
310 state_machine_[VALID][SMI_RESTORE] = INITIAL;
312 state_machine_[INVALID][SMI_VALID] = VALID;
313 state_machine_[INVALID][SMI_INVALID] = INVALID;
314 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
315 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
316 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
320 void ButtonPolicy::Private::initOkCancelReadOnly()
322 outputs_ = StateOutputs(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS);
323 state_machine_ = StateMachine(RO_INVALID + 1,
324 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
326 // Build the state output map
327 outputs_[INITIAL] = CLOSE;
328 outputs_[VALID] = RESTORE | OKAY | CANCEL;
329 outputs_[INVALID] = RESTORE | CANCEL;
330 outputs_[RO_INITIAL] = CLOSE;
331 outputs_[RO_VALID] = RESTORE | CANCEL;
332 outputs_[RO_INVALID] = RESTORE | CANCEL;
334 // Build the state machine one state at a time
335 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
336 // left out of the state machine and handled explicitly
340 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
341 state_machine_[INITIAL][SMI_VALID] = VALID;
342 state_machine_[INITIAL][SMI_INVALID] = INVALID;
343 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
345 state_machine_[VALID][SMI_VALID] = VALID;
346 state_machine_[VALID][SMI_READ_WRITE] = VALID;
347 state_machine_[VALID][SMI_INVALID] = INVALID;
348 state_machine_[VALID][SMI_OKAY] = INITIAL;
349 state_machine_[VALID][SMI_RESTORE] = INITIAL;
350 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
352 state_machine_[INVALID][SMI_INVALID] = INVALID;
353 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
354 state_machine_[INVALID][SMI_VALID] = VALID;
355 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
356 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
358 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
359 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
360 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
361 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
363 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
364 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
365 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
366 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
367 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
369 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
370 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
371 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
372 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
373 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
377 void ButtonPolicy::Private::initNoRepeatedApplyReadOnly()
379 outputs_ = StateOutputs(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS);
380 state_machine_ = StateMachine(RO_INVALID + 1,
381 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
383 // Build the state output map
384 outputs_[INITIAL] = CLOSE;
385 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
386 outputs_[INVALID] = RESTORE | CANCEL;
387 outputs_[RO_INITIAL] = CLOSE;
388 outputs_[RO_VALID] = RESTORE | CANCEL;
389 outputs_[RO_INVALID] = RESTORE | CANCEL;
391 // Build the state machine one state at a time
392 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
393 // left out of the state machine and handled explicitly
397 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
398 state_machine_[INITIAL][SMI_VALID] = VALID;
399 state_machine_[INITIAL][SMI_INVALID] = INVALID;
400 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
402 state_machine_[VALID][SMI_VALID] = VALID;
403 state_machine_[VALID][SMI_READ_WRITE] = VALID;
404 state_machine_[VALID][SMI_INVALID] = INVALID;
405 state_machine_[VALID][SMI_OKAY] = INITIAL;
406 state_machine_[VALID][SMI_APPLY] = INITIAL;
407 state_machine_[VALID][SMI_RESTORE] = INITIAL;
408 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
410 state_machine_[INVALID][SMI_INVALID] = INVALID;
411 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
412 state_machine_[INVALID][SMI_VALID] = VALID;
413 state_machine_[INVALID][SMI_OKAY] = INITIAL;
414 state_machine_[INVALID][SMI_APPLY] = INITIAL;
415 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
416 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
418 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
419 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
420 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
421 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
423 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
424 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
425 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
426 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
427 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
429 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
430 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
431 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
432 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
433 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
437 void ButtonPolicy::Private::initOkApplyCancelReadOnly()
439 outputs_ = StateOutputs(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
440 state_machine_ = StateMachine(RO_APPLIED + 1,
441 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
443 // Build the state output map
444 outputs_[INITIAL] = CLOSE;
445 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
446 outputs_[INVALID] = RESTORE | CANCEL;
447 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
448 outputs_[RO_INITIAL] = CLOSE;
449 outputs_[RO_VALID] = RESTORE | CANCEL;
450 outputs_[RO_INVALID] = RESTORE | CANCEL;
451 outputs_[RO_APPLIED] = CLOSE;
453 // Build the state machine one state at a time
454 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
455 // left out of the state machine and handled explicitly
459 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
460 state_machine_[INITIAL][SMI_VALID] = VALID;
461 state_machine_[INITIAL][SMI_INVALID] = INVALID;
462 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
464 state_machine_[VALID][SMI_VALID] = VALID;
465 state_machine_[VALID][SMI_READ_WRITE] = VALID;
466 state_machine_[VALID][SMI_INVALID] = INVALID;
467 state_machine_[VALID][SMI_OKAY] = INITIAL;
468 state_machine_[VALID][SMI_RESTORE] = INITIAL;
469 state_machine_[VALID][SMI_APPLY] = APPLIED;
470 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
472 state_machine_[INVALID][SMI_INVALID] = INVALID;
473 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
474 state_machine_[INVALID][SMI_VALID] = VALID;
475 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
476 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
478 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
479 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
480 state_machine_[APPLIED][SMI_VALID] = VALID;
481 state_machine_[APPLIED][SMI_INVALID] = INVALID;
482 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
483 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
485 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
486 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
487 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
488 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
490 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
491 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
492 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
493 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
494 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
496 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
497 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
498 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
499 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
500 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
502 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
503 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
504 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
505 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
509 void ButtonPolicy::Private::initOkApplyCancel()
511 outputs_ = StateOutputs(APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
512 state_machine_ = StateMachine(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 ButtonPolicy::Private::initOkApplyCancelAutoReadOnly()
557 outputs_ = StateOutputs(RO_AUTOAPPLY + 1, ButtonPolicy::ALL_BUTTONS);
558 state_machine_ = StateMachine(RO_AUTOAPPLY + 1,
559 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
561 // Build the state output map
562 outputs_[INITIAL] = CLOSE | AUTOAPPLY;
563 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL | AUTOAPPLY;
564 outputs_[INVALID] = RESTORE | CANCEL | AUTOAPPLY;
565 outputs_[APPLIED] = OKAY | CLOSE | AUTOAPPLY;
566 outputs_[AUTOAPPLY_INITIAL] = CLOSE | AUTOAPPLY;
567 outputs_[AUTOAPPLY_CHANGED] = CLOSE | RESTORE | AUTOAPPLY | OKAY;
568 outputs_[RO_INITIAL] = CLOSE;
569 outputs_[RO_VALID] = RESTORE | CANCEL;
570 outputs_[RO_INVALID] = RESTORE | CANCEL;
571 outputs_[RO_APPLIED] = CLOSE;
572 outputs_[RO_AUTOAPPLY] = CLOSE;
574 // Build the state machine one state at a time
575 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
576 // left out of the state machine and handled explicitly
580 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
581 state_machine_[INITIAL][SMI_VALID] = VALID;
582 state_machine_[INITIAL][SMI_INVALID] = INVALID;
583 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
584 state_machine_[INITIAL][SMI_AUTOAPPLY] = AUTOAPPLY_INITIAL;
586 state_machine_[VALID][SMI_VALID] = VALID;
587 state_machine_[VALID][SMI_READ_WRITE] = VALID;
588 state_machine_[VALID][SMI_INVALID] = INVALID;
589 state_machine_[VALID][SMI_OKAY] = INITIAL;
590 state_machine_[VALID][SMI_RESTORE] = INITIAL;
591 state_machine_[VALID][SMI_APPLY] = APPLIED;
592 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
593 state_machine_[VALID][SMI_AUTOAPPLY] = AUTOAPPLY_INITIAL;
595 state_machine_[INVALID][SMI_INVALID] = INVALID;
596 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
597 state_machine_[INVALID][SMI_VALID] = VALID;
598 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
599 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
600 state_machine_[INVALID][SMI_AUTOAPPLY] = AUTOAPPLY_CHANGED;
602 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
603 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
604 state_machine_[APPLIED][SMI_VALID] = VALID;
605 state_machine_[APPLIED][SMI_INVALID] = INVALID;
606 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
607 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
608 state_machine_[APPLIED][SMI_AUTOAPPLY] = AUTOAPPLY_INITIAL;
609 // State::AUTOAPPLY_INITIAL
610 state_machine_[AUTOAPPLY_INITIAL][SMI_AUTOAPPLY] = APPLIED;
611 state_machine_[AUTOAPPLY_INITIAL][SMI_READ_ONLY] = RO_AUTOAPPLY;
612 state_machine_[AUTOAPPLY_INITIAL][SMI_VALID] = AUTOAPPLY_CHANGED;
613 state_machine_[AUTOAPPLY_INITIAL][SMI_INVALID] = AUTOAPPLY_CHANGED;
614 state_machine_[AUTOAPPLY_INITIAL][SMI_READ_WRITE] = AUTOAPPLY_INITIAL;
615 // State::AUTOAPPLY_CHANGED
616 state_machine_[AUTOAPPLY_CHANGED][SMI_AUTOAPPLY] = APPLIED;
617 state_machine_[AUTOAPPLY_CHANGED][SMI_READ_ONLY] = RO_AUTOAPPLY;
618 state_machine_[AUTOAPPLY_CHANGED][SMI_RESTORE] = AUTOAPPLY_INITIAL;
619 state_machine_[AUTOAPPLY_CHANGED][SMI_VALID] = AUTOAPPLY_CHANGED;
620 state_machine_[AUTOAPPLY_CHANGED][SMI_INVALID] = AUTOAPPLY_CHANGED;
621 state_machine_[AUTOAPPLY_CHANGED][SMI_READ_WRITE] = AUTOAPPLY_CHANGED;
622 state_machine_[AUTOAPPLY_CHANGED][SMI_APPLY] = AUTOAPPLY_INITIAL;
624 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
625 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
626 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
627 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
628 state_machine_[RO_INITIAL][SMI_AUTOAPPLY] = RO_AUTOAPPLY;
630 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
631 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
632 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
633 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
634 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
635 state_machine_[RO_VALID][SMI_AUTOAPPLY] = RO_AUTOAPPLY;
637 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
638 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
639 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
640 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
641 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
642 state_machine_[RO_INVALID][SMI_AUTOAPPLY] = RO_AUTOAPPLY;
644 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
645 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
646 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
647 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
648 state_machine_[RO_APPLIED][SMI_AUTOAPPLY] = RO_AUTOAPPLY;
649 // State::RO_AUTOAPPLY
650 state_machine_[RO_AUTOAPPLY][SMI_READ_WRITE] = AUTOAPPLY_INITIAL;
654 void ButtonPolicy::Private::initNoRepeatedApply()
656 outputs_ = StateOutputs(INVALID + 1, ButtonPolicy::ALL_BUTTONS);
657 state_machine_ = StateMachine(INVALID + 1,
658 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
660 // Build the state output map
661 outputs_[INITIAL] = CLOSE;
662 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
663 outputs_[INVALID] = RESTORE | CANCEL;
665 // Build the state machine one state at a time
666 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
667 // left out of the state machine and handled explicitly
671 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
672 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
673 state_machine_[INITIAL][SMI_VALID] = VALID;
674 state_machine_[INITIAL][SMI_INVALID] = INVALID;
676 state_machine_[VALID][SMI_VALID] = VALID;
677 state_machine_[VALID][SMI_READ_ONLY] = VALID;
678 state_machine_[VALID][SMI_READ_WRITE] = VALID;
679 state_machine_[VALID][SMI_INVALID] = INVALID;
680 state_machine_[VALID][SMI_OKAY] = INITIAL;
681 state_machine_[VALID][SMI_APPLY] = INITIAL;
682 state_machine_[VALID][SMI_RESTORE] = INITIAL;
684 state_machine_[INVALID][SMI_INVALID] = INVALID;
685 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
686 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
687 state_machine_[INVALID][SMI_VALID] = VALID;
688 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
692 /////////////////////////////////////////////////////////////////////////
696 /////////////////////////////////////////////////////////////////////////
698 ButtonPolicy::ButtonPolicy(Policy policy)
699 : d(new Private(policy))
703 ButtonPolicy::~ButtonPolicy()
709 void ButtonPolicy::setPolicy(Policy policy)
711 *d = Private(policy);
715 void ButtonPolicy::input(SMInput input)
717 switch (d->policy_) {
718 case PreferencesPolicy:
719 // The APPLIED state is persistent. Next time the dialog is opened,
720 // the user will be able to press 'Save'.
721 if (SMI_CANCEL == input || SMI_HIDE == input) {
722 if (d->state_ != APPLIED)
731 // CANCEL and HIDE always take us to INITIAL for all cases
732 if (SMI_CANCEL == input || SMI_HIDE == input) {
733 if (d->state_ == AUTOAPPLY_INITIAL
734 || d->state_ == AUTOAPPLY_CHANGED)
735 d->state_ = AUTOAPPLY_INITIAL;
745 bool ButtonPolicy::buttonStatus(Button button) const
747 return d->policy_ == IgnorantPolicy || (button & d->outputs_[d->state_]);
751 bool ButtonPolicy::isReadOnly() const
753 switch (d->policy_) {
754 case NoRepeatedApplyReadOnlyPolicy:
755 case OkCancelReadOnlyPolicy:
756 case OkApplyCancelReadOnlyPolicy:
757 return RO_INITIAL == d->state_
758 || RO_VALID == d->state_
759 || RO_INVALID == d->state_
760 || RO_APPLIED == d->state_;
768 } // namespace frontend