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::RO_INITIAL:
38 case ButtonPolicy::RO_VALID:
40 case ButtonPolicy::RO_INVALID:
42 case ButtonPolicy::RO_APPLIED:
44 case ButtonPolicy::BOGUS:
52 static char const * printInput(ButtonPolicy::SMInput const & input)
55 case ButtonPolicy::SMI_VALID:
57 case ButtonPolicy::SMI_INVALID:
59 case ButtonPolicy::SMI_OKAY:
61 case ButtonPolicy::SMI_APPLY:
63 case ButtonPolicy::SMI_CANCEL:
65 case ButtonPolicy::SMI_RESTORE:
67 case ButtonPolicy::SMI_HIDE:
69 case ButtonPolicy::SMI_READ_ONLY:
70 return "SMI_READ_ONLY";
71 case ButtonPolicy::SMI_READ_WRITE:
72 return "SMI_READ_WRITE";
73 case ButtonPolicy::SMI_NOOP:
75 case ButtonPolicy::SMI_TOTAL:
83 char const * functionName(ButtonPolicy::Policy policy)
86 case ButtonPolicy::PreferencesPolicy:
87 return "PreferencesPolicy";
88 case ButtonPolicy::OkCancelPolicy:
89 return "OkCancelPolicy";
90 case ButtonPolicy::OkCancelReadOnlyPolicy:
91 return "OkCancelReadOnlyPolicy";
92 case ButtonPolicy::OkApplyCancelPolicy:
93 return "OkApplyCancelPolicy";
94 case ButtonPolicy::OkApplyCancelReadOnlyPolicy:
95 return "OkApplyCancelReadOnlyPolicy";
96 case ButtonPolicy::NoRepeatedApplyPolicy:
97 return "NoRepeatedApplyPolicy";
98 case ButtonPolicy::NoRepeatedApplyReadOnlyPolicy:
99 return "NoRepeatedApplyReadOnlyPolicy";
100 case ButtonPolicy::IgnorantPolicy:
101 return "IgnorantPolicy";
103 return "Unknown policy";
108 ostream & operator<<(ostream & os, ButtonPolicy::State st)
110 return os << int(st);
114 ostream & operator<<(ostream & os, ButtonPolicy::SMInput smi)
116 return os << int(smi);
120 /////////////////////////////////////////////////////////////////////////
122 // ButtonPolicy::Private
124 /////////////////////////////////////////////////////////////////////////
126 class ButtonPolicy::Private
129 typedef ButtonPolicy::SMInput SMInput;
130 typedef ButtonPolicy::Policy Policy;
131 typedef ButtonPolicy::State State;
133 Private(Policy policy);
135 void nextState(SMInput input);
138 void initOkCancelReadOnly();
139 void initNoRepeatedApplyReadOnly();
140 void initOkApplyCancelReadOnly();
141 void initOkApplyCancel();
142 void initNoRepeatedApply();
143 void initPreferences();
149 /// Transition map of the state machine.
150 typedef std::vector<State> StateArray;
152 typedef std::vector<StateArray> StateMachine;
153 /// The state outputs are the status of the buttons.
154 typedef std::vector<int> StateOutputs;
158 /// Which buttons are active for a given state.
159 StateOutputs outputs_;
161 StateMachine state_machine_;
165 ButtonPolicy::Private::Private(Policy policy)
174 case OkCancelReadOnlyPolicy:
175 initOkCancelReadOnly();
177 case OkApplyCancelPolicy:
180 case OkApplyCancelReadOnlyPolicy:
181 initOkApplyCancelReadOnly();
183 case NoRepeatedApplyPolicy:
184 initNoRepeatedApply();
186 case NoRepeatedApplyReadOnlyPolicy:
187 initNoRepeatedApplyReadOnly();
189 case PreferencesPolicy:
198 void ButtonPolicy::Private::nextState(SMInput input)
200 if (SMI_NOOP == input)
203 State tmp = state_machine_[state_][input];
205 LYXERR(Debug::GUI, "Transition from state "
206 << printState(state_) << " to state "
207 << printState(tmp) << " after input "
208 << printInput(input));
213 LYXERR0(functionName(policy_) << ": No transition for input "
214 << printInput(input) << " from state " << printState(state_));
219 void ButtonPolicy::Private::initPreferences()
221 outputs_ = StateOutputs(APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
222 state_machine_ = StateMachine(APPLIED + 1,
223 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
225 // Build the state output map
226 outputs_[INITIAL] = CLOSE;
227 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
228 outputs_[INVALID] = RESTORE | CANCEL;
229 outputs_[APPLIED] = OKAY | CLOSE;
231 // Build the state machine one state at a time
232 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
233 // left out of the state machine and handled explicitly
234 // in input(). This won't necessarily be true for all
235 // policies though so I'll leave those two as distinct
236 // inputs rather than merge them. For example, a dialog
237 // that doesn't update it's input fields when reshown
238 // after being hidden needs a policy where CANCEL and
239 // HIDE are treated differently.
242 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
243 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
244 state_machine_[INITIAL][SMI_VALID] = VALID;
245 state_machine_[INITIAL][SMI_INVALID] = INVALID;
247 state_machine_[VALID][SMI_VALID] = VALID;
248 state_machine_[VALID][SMI_READ_ONLY] = VALID;
249 state_machine_[VALID][SMI_READ_WRITE] = VALID;
250 state_machine_[VALID][SMI_INVALID] = INVALID;
251 state_machine_[VALID][SMI_APPLY] = APPLIED;
252 state_machine_[VALID][SMI_OKAY] = INITIAL;
253 state_machine_[VALID][SMI_RESTORE] = INITIAL;
255 state_machine_[INVALID][SMI_VALID] = VALID;
256 state_machine_[INVALID][SMI_INVALID] = INVALID;
257 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
258 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
259 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
261 state_machine_[APPLIED][SMI_VALID] = VALID;
262 state_machine_[APPLIED][SMI_INVALID] = INVALID;
263 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
264 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
265 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
269 void ButtonPolicy::Private::initOkCancel()
271 outputs_ = StateOutputs(INVALID + 1, ButtonPolicy::ALL_BUTTONS);
272 state_machine_ = StateMachine(INVALID + 1,
273 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
275 // Build the state output map
276 outputs_[INITIAL] = CLOSE;
277 outputs_[VALID] = RESTORE | OKAY | CANCEL;
278 outputs_[INVALID] = RESTORE | CANCEL;
280 // Build the state machine one state at a time
281 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
282 // left out of the state machine and handled explicitly
286 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
287 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
288 state_machine_[INITIAL][SMI_VALID] = VALID;
289 state_machine_[INITIAL][SMI_INVALID] = INVALID;
291 state_machine_[VALID][SMI_VALID] = VALID;
292 state_machine_[VALID][SMI_READ_ONLY] = VALID;
293 state_machine_[VALID][SMI_READ_WRITE] = VALID;
294 state_machine_[VALID][SMI_INVALID] = INVALID;
295 state_machine_[VALID][SMI_OKAY] = INITIAL;
296 state_machine_[VALID][SMI_RESTORE] = INITIAL;
298 state_machine_[INVALID][SMI_VALID] = VALID;
299 state_machine_[INVALID][SMI_INVALID] = INVALID;
300 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
301 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
302 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
306 void ButtonPolicy::Private::initOkCancelReadOnly()
308 outputs_ = StateOutputs(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS);
309 state_machine_ = StateMachine(RO_INVALID + 1,
310 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
312 // Build the state output map
313 outputs_[INITIAL] = CLOSE;
314 outputs_[VALID] = RESTORE | OKAY | CANCEL;
315 outputs_[INVALID] = RESTORE | CANCEL;
316 outputs_[RO_INITIAL] = CLOSE;
317 outputs_[RO_VALID] = RESTORE | CANCEL;
318 outputs_[RO_INVALID] = RESTORE | CANCEL;
320 // Build the state machine one state at a time
321 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
322 // left out of the state machine and handled explicitly
326 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
327 state_machine_[INITIAL][SMI_VALID] = VALID;
328 state_machine_[INITIAL][SMI_INVALID] = INVALID;
329 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
331 state_machine_[VALID][SMI_VALID] = VALID;
332 state_machine_[VALID][SMI_READ_WRITE] = VALID;
333 state_machine_[VALID][SMI_INVALID] = INVALID;
334 state_machine_[VALID][SMI_OKAY] = INITIAL;
335 state_machine_[VALID][SMI_RESTORE] = INITIAL;
336 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
338 state_machine_[INVALID][SMI_INVALID] = INVALID;
339 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
340 state_machine_[INVALID][SMI_VALID] = VALID;
341 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
342 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
344 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
345 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
346 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
347 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
349 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
350 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
351 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
352 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
353 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
355 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
356 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
357 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
358 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
359 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
363 void ButtonPolicy::Private::initNoRepeatedApplyReadOnly()
365 outputs_ = StateOutputs(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS);
366 state_machine_ = StateMachine(RO_INVALID + 1,
367 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
369 // Build the state output map
370 outputs_[INITIAL] = CLOSE;
371 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
372 outputs_[INVALID] = RESTORE | CANCEL;
373 outputs_[RO_INITIAL] = CLOSE;
374 outputs_[RO_VALID] = RESTORE | CANCEL;
375 outputs_[RO_INVALID] = RESTORE | CANCEL;
377 // Build the state machine one state at a time
378 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
379 // left out of the state machine and handled explicitly
383 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
384 state_machine_[INITIAL][SMI_VALID] = VALID;
385 state_machine_[INITIAL][SMI_INVALID] = INVALID;
386 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
388 state_machine_[VALID][SMI_VALID] = VALID;
389 state_machine_[VALID][SMI_READ_WRITE] = VALID;
390 state_machine_[VALID][SMI_INVALID] = INVALID;
391 state_machine_[VALID][SMI_OKAY] = INITIAL;
392 state_machine_[VALID][SMI_APPLY] = INITIAL;
393 state_machine_[VALID][SMI_RESTORE] = INITIAL;
394 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
396 state_machine_[INVALID][SMI_INVALID] = INVALID;
397 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
398 state_machine_[INVALID][SMI_VALID] = VALID;
399 state_machine_[INVALID][SMI_OKAY] = INITIAL;
400 state_machine_[INVALID][SMI_APPLY] = INITIAL;
401 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
402 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
404 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
405 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
406 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
407 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
409 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
410 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
411 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
412 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
413 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
415 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
416 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
417 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
418 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
419 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
423 void ButtonPolicy::Private::initOkApplyCancelReadOnly()
425 outputs_ = StateOutputs(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
426 state_machine_ = StateMachine(RO_APPLIED + 1,
427 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
429 // Build the state output map
430 outputs_[INITIAL] = CLOSE;
431 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
432 outputs_[INVALID] = RESTORE | CANCEL;
433 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
434 outputs_[RO_INITIAL] = CLOSE;
435 outputs_[RO_VALID] = RESTORE | CANCEL;
436 outputs_[RO_INVALID] = RESTORE | CANCEL;
437 outputs_[RO_APPLIED] = CLOSE;
439 // Build the state machine one state at a time
440 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
441 // left out of the state machine and handled explicitly
445 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
446 state_machine_[INITIAL][SMI_VALID] = VALID;
447 state_machine_[INITIAL][SMI_INVALID] = INVALID;
448 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
450 state_machine_[VALID][SMI_VALID] = VALID;
451 state_machine_[VALID][SMI_READ_WRITE] = VALID;
452 state_machine_[VALID][SMI_INVALID] = INVALID;
453 state_machine_[VALID][SMI_OKAY] = INITIAL;
454 state_machine_[VALID][SMI_RESTORE] = INITIAL;
455 state_machine_[VALID][SMI_APPLY] = APPLIED;
456 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
458 state_machine_[INVALID][SMI_INVALID] = INVALID;
459 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
460 state_machine_[INVALID][SMI_VALID] = VALID;
461 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
462 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
464 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
465 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
466 state_machine_[APPLIED][SMI_VALID] = VALID;
467 state_machine_[APPLIED][SMI_INVALID] = INVALID;
468 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
469 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
471 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
472 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
473 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
474 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
476 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
477 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
478 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
479 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
480 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
482 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
483 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
484 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
485 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
486 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
488 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
489 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
490 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
491 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
495 void ButtonPolicy::Private::initOkApplyCancel()
497 outputs_ = StateOutputs(APPLIED + 1, ButtonPolicy::ALL_BUTTONS);
498 state_machine_ = StateMachine(APPLIED + 1,
499 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
501 // Build the state output map
502 outputs_[INITIAL] = CLOSE;
503 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
504 outputs_[INVALID] = RESTORE | CANCEL;
505 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
507 // Build the state machine one state at a time
508 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
509 // left out of the state machine and handled explicitly
513 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
514 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
515 state_machine_[INITIAL][SMI_VALID] = VALID;
516 state_machine_[INITIAL][SMI_INVALID] = INVALID;
518 state_machine_[VALID][SMI_VALID] = VALID;
519 state_machine_[VALID][SMI_READ_ONLY] = VALID;
520 state_machine_[VALID][SMI_READ_WRITE] = VALID;
521 state_machine_[VALID][SMI_INVALID] = INVALID;
522 state_machine_[VALID][SMI_OKAY] = INITIAL;
523 state_machine_[VALID][SMI_RESTORE] = INITIAL;
524 state_machine_[VALID][SMI_APPLY] = APPLIED;
526 state_machine_[INVALID][SMI_INVALID] = INVALID;
527 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
528 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
529 state_machine_[INVALID][SMI_VALID] = VALID;
530 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
532 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
533 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
534 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
535 state_machine_[APPLIED][SMI_VALID] = VALID;
536 state_machine_[APPLIED][SMI_INVALID] = INVALID;
537 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
541 void ButtonPolicy::Private::initNoRepeatedApply()
543 outputs_ = StateOutputs(INVALID + 1, ButtonPolicy::ALL_BUTTONS);
544 state_machine_ = StateMachine(INVALID + 1,
545 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS));
547 // Build the state output map
548 outputs_[INITIAL] = CLOSE;
549 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
550 outputs_[INVALID] = RESTORE | CANCEL;
552 // Build the state machine one state at a time
553 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
554 // left out of the state machine and handled explicitly
558 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
559 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
560 state_machine_[INITIAL][SMI_VALID] = VALID;
561 state_machine_[INITIAL][SMI_INVALID] = INVALID;
563 state_machine_[VALID][SMI_VALID] = VALID;
564 state_machine_[VALID][SMI_READ_ONLY] = VALID;
565 state_machine_[VALID][SMI_READ_WRITE] = VALID;
566 state_machine_[VALID][SMI_INVALID] = INVALID;
567 state_machine_[VALID][SMI_OKAY] = INITIAL;
568 state_machine_[VALID][SMI_APPLY] = INITIAL;
569 state_machine_[VALID][SMI_RESTORE] = INITIAL;
571 state_machine_[INVALID][SMI_INVALID] = INVALID;
572 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
573 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
574 state_machine_[INVALID][SMI_VALID] = VALID;
575 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
579 /////////////////////////////////////////////////////////////////////////
583 /////////////////////////////////////////////////////////////////////////
585 ButtonPolicy::ButtonPolicy(Policy policy)
586 : d(new Private(policy))
590 ButtonPolicy::~ButtonPolicy()
596 void ButtonPolicy::setPolicy(Policy policy)
598 *d = Private(policy);
602 void ButtonPolicy::input(SMInput input)
604 switch (d->policy_) {
605 case PreferencesPolicy:
606 // The APPLIED state is persistent. Next time the dialog is opened,
607 // the user will be able to press 'Save'.
608 if (SMI_CANCEL == input || SMI_HIDE == input) {
609 if (d->state_ != APPLIED)
618 // CANCEL and HIDE always take us to INITIAL for all cases
619 if (SMI_CANCEL == input || SMI_HIDE == input)
628 bool ButtonPolicy::buttonStatus(Button button) const
630 return d->policy_ == IgnorantPolicy || (button & d->outputs_[d->state_]);
634 bool ButtonPolicy::isReadOnly() const
636 switch (d->policy_) {
637 case NoRepeatedApplyReadOnlyPolicy:
638 case OkCancelReadOnlyPolicy:
639 case OkApplyCancelReadOnlyPolicy:
640 return RO_INITIAL == d->state_
641 || RO_VALID == d->state_
642 || RO_INVALID == d->state_
643 || RO_APPLIED == d->state_;
651 } // namespace frontend