mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-22 16:04:07 +00:00
2a31934f38
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@8766 a592a061-630c-0410-9148-cb99ea01b6c8
634 lines
19 KiB
C
634 lines
19 KiB
C
/**
|
|
* \file ButtonPolicies.C
|
|
* This file is part of LyX, the document processor.
|
|
* Licence details can be found in the file COPYING.
|
|
*
|
|
* \author Allan Rae
|
|
*
|
|
* Full author contact details are available in file CREDITS.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "ButtonPolicies.h"
|
|
#include "debug.h"
|
|
#include <string>
|
|
|
|
using std::endl;
|
|
using std::string;
|
|
|
|
namespace lyx {
|
|
namespace frontend {
|
|
|
|
namespace {
|
|
|
|
string const printState(ButtonPolicy::State const & state)
|
|
{
|
|
string output;
|
|
|
|
switch(state) {
|
|
case ButtonPolicy::INITIAL:
|
|
output = "INITIAL";
|
|
break;
|
|
case ButtonPolicy::VALID:
|
|
output = "VALID";
|
|
break;
|
|
case ButtonPolicy::INVALID:
|
|
output = "INVALID";
|
|
break;
|
|
case ButtonPolicy::APPLIED:
|
|
output = "APPLIED";
|
|
break;
|
|
case ButtonPolicy::RO_INITIAL:
|
|
output = "RO_INITIAL";
|
|
break;
|
|
case ButtonPolicy::RO_VALID:
|
|
output = "RO_VALID";
|
|
break;
|
|
case ButtonPolicy::RO_INVALID:
|
|
output = "RO_INVALID";
|
|
break;
|
|
case ButtonPolicy::RO_APPLIED:
|
|
output = "RO_APPLIED";
|
|
break;
|
|
case ButtonPolicy::BOGUS:
|
|
output = "BOGUS";
|
|
break;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
string const printInput(ButtonPolicy::SMInput const & input)
|
|
{
|
|
string output;
|
|
|
|
switch (input) {
|
|
case ButtonPolicy::SMI_VALID:
|
|
output = "SMI_VALID";
|
|
break;
|
|
case ButtonPolicy::SMI_INVALID:
|
|
output = "SMI_INVALID";
|
|
break;
|
|
case ButtonPolicy::SMI_OKAY:
|
|
output = "SMI_OKAY";
|
|
break;
|
|
case ButtonPolicy::SMI_APPLY:
|
|
output = "SMI_APPLY";
|
|
break;
|
|
case ButtonPolicy::SMI_CANCEL:
|
|
output = "SMI_CANCEL";
|
|
break;
|
|
case ButtonPolicy::SMI_RESTORE:
|
|
output = "SMI_RESTORE";
|
|
break;
|
|
case ButtonPolicy::SMI_HIDE:
|
|
output = "SMI_HIDE";
|
|
break;
|
|
case ButtonPolicy::SMI_READ_ONLY:
|
|
output = "SMI_READ_ONLY";
|
|
break;
|
|
case ButtonPolicy::SMI_READ_WRITE:
|
|
output = "SMI_READ_WRITE";
|
|
break;
|
|
case ButtonPolicy::SMI_NOOP:
|
|
output = "SMI_NOOP";
|
|
break;
|
|
case ButtonPolicy::SMI_TOTAL:
|
|
output = "SMI_TOTAL";
|
|
break;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
/// Helper function
|
|
void nextState(ButtonPolicy::State & state,
|
|
ButtonPolicy::SMInput in,
|
|
ButtonPolicy::StateMachine const & s_m,
|
|
char const * function_name = "nextState")
|
|
{
|
|
if (ButtonPolicy::SMI_NOOP == in) return;
|
|
|
|
ButtonPolicy::State tmp = s_m[state][in];
|
|
|
|
lyxerr[Debug::GUI] << "Transition from state "
|
|
<< printState(state) << " to state "
|
|
<< printState(tmp) << " after input "
|
|
<< printInput(in) << std::endl;
|
|
|
|
if (ButtonPolicy::BOGUS != tmp) {
|
|
state = tmp;
|
|
} else {
|
|
lyxerr << function_name
|
|
<< ": No transition for input "
|
|
<< printInput(in)
|
|
<< " from state "
|
|
<< printState(state)
|
|
<< endl;
|
|
}
|
|
}
|
|
|
|
} // namespace anon
|
|
|
|
|
|
/*-----------------------------PreferencesPolicy-----------------------------*/
|
|
|
|
|
|
PreferencesPolicy::PreferencesPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(APPLIED + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
outputs_[APPLIED] = OKAY | CLOSE;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input(). This won't necessarily be true for all
|
|
// policies though so I'll leave those two as distinct
|
|
// inputs rather than merge them. For example, a dialog
|
|
// that doesn't update it's input fields when reshown
|
|
// after being hidden needs a policy where CANCEL and
|
|
// HIDE are treated differently.
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_ONLY] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_APPLY] = APPLIED;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
// State::APPLIED
|
|
state_machine_[APPLIED][SMI_VALID] = VALID;
|
|
state_machine_[APPLIED][SMI_INVALID] = INVALID;
|
|
state_machine_[APPLIED][SMI_OKAY] = INITIAL;
|
|
state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
|
|
state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
|
|
}
|
|
|
|
|
|
void PreferencesPolicy::input(SMInput input)
|
|
{
|
|
// The APPLIED state is persistent. Next time the dialog is opened,
|
|
// the user will be able to press 'Save'.
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
if (state_ != APPLIED)
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"PreferencesPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*-------------------------------OkCancelPolicy------------------------------*/
|
|
|
|
|
|
OkCancelPolicy::OkCancelPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(INVALID + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_ONLY] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
}
|
|
|
|
|
|
|
|
void OkCancelPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "OkCancelPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_, input, state_machine_, "OkCancelPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*---------------------------OkCancelReadOnlyPolicy-------------------------*/
|
|
|
|
|
|
OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(RO_INVALID + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
outputs_[RO_INITIAL] = CLOSE;
|
|
outputs_[RO_VALID] = RESTORE | CANCEL;
|
|
outputs_[RO_INVALID] = RESTORE | CANCEL;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
// State::RO_INITIAL
|
|
state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
// State::RO_VALID
|
|
state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
|
|
// State::RO_INVALID
|
|
state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
|
|
}
|
|
|
|
|
|
void OkCancelReadOnlyPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"OkCancelReadOnlyPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
|
|
|
|
|
|
NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(RO_INVALID + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
outputs_[RO_INITIAL] = CLOSE;
|
|
outputs_[RO_VALID] = RESTORE | CANCEL;
|
|
outputs_[RO_INVALID] = RESTORE | CANCEL;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_APPLY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
// State::RO_INITIAL
|
|
state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
// State::RO_VALID
|
|
state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
|
|
// State::RO_INVALID
|
|
state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
|
|
}
|
|
|
|
|
|
void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"NoRepeatedApplyReadOnlyPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
|
|
|
|
|
|
OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(RO_APPLIED + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
outputs_[APPLIED] = OKAY | APPLY | CLOSE;
|
|
outputs_[RO_INITIAL] = CLOSE;
|
|
outputs_[RO_VALID] = RESTORE | CANCEL;
|
|
outputs_[RO_INVALID] = RESTORE | CANCEL;
|
|
outputs_[RO_APPLIED] = CLOSE;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[VALID][SMI_APPLY] = APPLIED;
|
|
state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
// State::APPLIED
|
|
state_machine_[APPLIED][SMI_APPLY] = APPLIED;
|
|
state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
|
|
state_machine_[APPLIED][SMI_VALID] = VALID;
|
|
state_machine_[APPLIED][SMI_INVALID] = INVALID;
|
|
state_machine_[APPLIED][SMI_OKAY] = INITIAL;
|
|
state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
|
|
// State::RO_INITIAL
|
|
state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
|
|
state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
// State::RO_VALID
|
|
state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
|
|
state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
|
|
// State::RO_INVALID
|
|
state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
|
|
state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
|
|
// State::RO_APPLIED
|
|
state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
|
|
state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
|
|
state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
|
|
state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
|
|
}
|
|
|
|
|
|
void OkApplyCancelReadOnlyPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"OkApplyCancelReadOnlyPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------OkApplyCancelPolicy----------------------*/
|
|
|
|
|
|
OkApplyCancelPolicy::OkApplyCancelPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(APPLIED + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
outputs_[APPLIED] = OKAY | APPLY | CLOSE;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_ONLY] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
state_machine_[VALID][SMI_APPLY] = APPLIED;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
// State::APPLIED
|
|
state_machine_[APPLIED][SMI_APPLY] = APPLIED;
|
|
state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
|
|
state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
|
|
state_machine_[APPLIED][SMI_VALID] = VALID;
|
|
state_machine_[APPLIED][SMI_INVALID] = INVALID;
|
|
state_machine_[APPLIED][SMI_OKAY] = INITIAL;
|
|
}
|
|
|
|
|
|
void OkApplyCancelPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "OkApplyCancelPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"OkApplyCancelPolicy");
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------NoRepeatedApplyPolicy----------------------*/
|
|
|
|
|
|
NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
|
|
: state_(INITIAL),
|
|
outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
|
|
state_machine_(INVALID + 1,
|
|
StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
|
|
{
|
|
// Build the state output map
|
|
outputs_[INITIAL] = CLOSE;
|
|
outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
|
|
outputs_[INVALID] = RESTORE | CANCEL;
|
|
|
|
// Build the state machine one state at a time
|
|
// NOTE: Since CANCEL and HIDE always go to INITIAL they are
|
|
// left out of the state machine and handled explicitly
|
|
// in input()
|
|
//
|
|
// State::INITIAL
|
|
state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
|
|
state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
|
|
state_machine_[INITIAL][SMI_VALID] = VALID;
|
|
state_machine_[INITIAL][SMI_INVALID] = INVALID;
|
|
// State::VALID
|
|
state_machine_[VALID][SMI_VALID] = VALID;
|
|
state_machine_[VALID][SMI_READ_ONLY] = VALID;
|
|
state_machine_[VALID][SMI_READ_WRITE] = VALID;
|
|
state_machine_[VALID][SMI_INVALID] = INVALID;
|
|
state_machine_[VALID][SMI_OKAY] = INITIAL;
|
|
state_machine_[VALID][SMI_APPLY] = INITIAL;
|
|
state_machine_[VALID][SMI_RESTORE] = INITIAL;
|
|
// State::INVALID
|
|
state_machine_[INVALID][SMI_INVALID] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
|
|
state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
|
|
state_machine_[INVALID][SMI_VALID] = VALID;
|
|
state_machine_[INVALID][SMI_RESTORE] = INITIAL;
|
|
}
|
|
|
|
|
|
void NoRepeatedApplyPolicy::input(SMInput input)
|
|
{
|
|
//lyxerr << "NoRepeatedApplyPolicy::input" << endl;
|
|
|
|
// CANCEL and HIDE always take us to INITIAL for all cases
|
|
if (SMI_CANCEL == input
|
|
|| SMI_HIDE == input) {
|
|
state_ = INITIAL;
|
|
} else {
|
|
nextState(state_,
|
|
input,
|
|
state_machine_,
|
|
"NoRepeatedApplyPolicy");
|
|
}
|
|
}
|
|
|
|
} // namespace frontend
|
|
} // namespace lyx
|