src/frontends/controllers/ButtonPolicies.C

   1 /**
   2  * \file ButtonPolicies.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Allan Rae
   7  *
   8  * Full author contact details are available in file CREDITS
   9  */
  10
  11 #include <config.h>
  12
  13 #include "ButtonPolicies.h"
  14 #include "debug.h"
  15
  16 using std::endl;
  17
  18 namespace {
  19
  20 /// Helper function
  21 inline
  22 void nextState(ButtonPolicy::State & state,
  23                ButtonPolicy::SMInput in,
  24                ButtonPolicy::StateMachine const & s_m,
  25                char const * function_name = "nextState")
  26 {
  27         if (ButtonPolicy::SMI_NOOP == in) return;
  28
  29         ButtonPolicy::State tmp = s_m[state][in];
  30
  31         lyxerr[Debug::GUI] << "Transition from state "
  32                 << state << " to state " << tmp << " after input "
  33                 << in << std::endl;
  34
  35         if (ButtonPolicy::BOGUS != tmp) {
  36                 state = tmp;
  37         } else {
  38                 lyxerr << function_name
  39                        << ": No transition for input "
  40                        << in
  41                        << " from state "
  42                        << state
  43                        << endl;
  44         }
  45 }
  46
  47 } // namespace anon
  48
  49
  50 /*-----------------------------PreferencesPolicy-----------------------------*/
  51
  52
  53 PreferencesPolicy::PreferencesPolicy()
  54         : state_(INITIAL),
  55           outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
  56           state_machine_(APPLIED + 1,
  57                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
  58 {
  59         // Build the state output map
  60         outputs_[INITIAL] = CLOSE;
  61         outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
  62         outputs_[INVALID] = RESTORE | CANCEL;
  63         outputs_[APPLIED] = OKAY | CLOSE;
  64
  65         // Build the state machine one state at a time
  66         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
  67         //        left out of the state machine and handled explicitly
  68         //        in input().  This won't necessarily be true for all
  69         //        policies though so I'll leave those two as distinct
  70         //        inputs rather than merge them.  For example, a dialog
  71         //        that doesn't update it's input fields when reshown
  72         //        after being hidden needs a policy where CANCEL and
  73         //        HIDE are treated differently.
  74         //
  75         // State::INITIAL
  76         state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
  77         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
  78         state_machine_[INITIAL][SMI_VALID] = VALID;
  79         state_machine_[INITIAL][SMI_INVALID] = INVALID;
  80         // State::VALID
  81         state_machine_[VALID][SMI_VALID] = VALID;
  82         state_machine_[VALID][SMI_READ_ONLY] = VALID;
  83         state_machine_[VALID][SMI_READ_WRITE] = VALID;
  84         state_machine_[VALID][SMI_INVALID] = INVALID;
  85         state_machine_[VALID][SMI_APPLY] = APPLIED;
  86         state_machine_[VALID][SMI_OKAY] = INITIAL;
  87         state_machine_[VALID][SMI_RESTORE] = INITIAL;
  88         // State::INVALID
  89         state_machine_[INVALID][SMI_VALID] = VALID;
  90         state_machine_[INVALID][SMI_INVALID] = INVALID;
  91         state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
  92         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
  93         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
  94         // State::APPLIED
  95         state_machine_[APPLIED][SMI_VALID] = VALID;
  96         state_machine_[APPLIED][SMI_INVALID] = INVALID;
  97         state_machine_[APPLIED][SMI_OKAY] = INITIAL;
  98         state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
  99         state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
 100 }
 101
 102
 103 void PreferencesPolicy::input(SMInput input)
 104 {
 105         //lyxerr << "PreferencesPolicy::input" << endl;
 106         // CANCEL and HIDE always take us to INITIAL for all cases.
 107         // Note that I didn't put that special case in the helper function
 108         // because it doesn't belong there.  Some other
 109         // This is probably optimising for the wrong case since it occurs as the
 110         // dialog will be hidden.  It would have saved a little memory in the
 111         // state machine if I could have gotten map working. ARRae 20000813
 112         if (SMI_CANCEL == input
 113             || SMI_HIDE == input) {
 114                 state_ = INITIAL;
 115         } else {
 116                 nextState(state_,
 117                           input,
 118                           state_machine_,
 119                           "PreferencesPolicy");
 120         }
 121 }
 122
 123
 124 /*-------------------------------OkCancelPolicy------------------------------*/
 125
 126
 127 OkCancelPolicy::OkCancelPolicy()
 128         : state_(INITIAL),
 129           outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
 130           state_machine_(INVALID + 1,
 131                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 132 {
 133         // Build the state output map
 134         outputs_[INITIAL] = CLOSE;
 135         outputs_[VALID] = RESTORE | OKAY | CANCEL;
 136         outputs_[INVALID] = RESTORE | CANCEL;
 137
 138         // Build the state machine one state at a time
 139         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
 140         //        left out of the state machine and handled explicitly
 141         //        in input()
 142         //
 143         // State::INITIAL
 144         state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
 145         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
 146         state_machine_[INITIAL][SMI_VALID] = VALID;
 147         state_machine_[INITIAL][SMI_INVALID] = INVALID;
 148         // State::VALID
 149         state_machine_[VALID][SMI_VALID] = VALID;
 150         state_machine_[VALID][SMI_READ_ONLY] = VALID;
 151         state_machine_[VALID][SMI_READ_WRITE] = VALID;
 152         state_machine_[VALID][SMI_INVALID] = INVALID;
 153         state_machine_[VALID][SMI_OKAY] = INITIAL;
 154         state_machine_[VALID][SMI_RESTORE] = INITIAL;
 155         // State::INVALID
 156         state_machine_[INVALID][SMI_VALID] = VALID;
 157         state_machine_[INVALID][SMI_INVALID] = INVALID;
 158         state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
 159         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
 160         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
 161 }
 162
 163
 164
 165 void OkCancelPolicy::input(SMInput input)
 166 {
 167         //lyxerr << "OkCancelPolicy::input" << endl;
 168
 169         // CANCEL and HIDE always take us to INITIAL for all cases
 170         if (SMI_CANCEL == input
 171             || SMI_HIDE == input) {
 172                 state_ = INITIAL;
 173         } else {
 174                 nextState(state_, input, state_machine_, "OkCancelPolicy");
 175         }
 176 }
 177
 178
 179 /*---------------------------OkCancelReadOnlyPolicy-------------------------*/
 180
 181
 182 OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
 183         : state_(INITIAL),
 184           outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
 185           state_machine_(RO_INVALID + 1,
 186                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 187 {
 188         // Build the state output map
 189         outputs_[INITIAL] = CLOSE;
 190         outputs_[VALID] = RESTORE | OKAY | CANCEL;
 191         outputs_[INVALID] = RESTORE | CANCEL;
 192         outputs_[RO_INITIAL] = CLOSE;
 193         outputs_[RO_VALID] = RESTORE | CANCEL;
 194         outputs_[RO_INVALID] = RESTORE | CANCEL;
 195
 196         // Build the state machine one state at a time
 197         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
 198         //        left out of the state machine and handled explicitly
 199         //        in input()
 200         //
 201         // State::INITIAL
 202         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
 203         state_machine_[INITIAL][SMI_VALID] = VALID;
 204         state_machine_[INITIAL][SMI_INVALID] = INVALID;
 205         state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
 206         // State::VALID
 207         state_machine_[VALID][SMI_VALID] = VALID;
 208         state_machine_[VALID][SMI_READ_WRITE] = VALID;
 209         state_machine_[VALID][SMI_INVALID] = INVALID;
 210         state_machine_[VALID][SMI_OKAY] = INITIAL;
 211         state_machine_[VALID][SMI_RESTORE] = INITIAL;
 212         state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
 213         // State::INVALID
 214         state_machine_[INVALID][SMI_INVALID] = INVALID;
 215         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
 216         state_machine_[INVALID][SMI_VALID] = VALID;
 217         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
 218         state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
 219         // State::RO_INITIAL
 220         state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
 221         state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
 222         state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
 223         state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
 224         // State::RO_VALID
 225         state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
 226         state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
 227         state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
 228         state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
 229         state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
 230         // State::RO_INVALID
 231         state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
 232         state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
 233         state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
 234         state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
 235         state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
 236 }
 237
 238
 239 void OkCancelReadOnlyPolicy::input(SMInput input)
 240 {
 241         //lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
 242
 243         // CANCEL and HIDE always take us to INITIAL for all cases
 244         if (SMI_CANCEL == input
 245             || SMI_HIDE == input) {
 246                 state_ = INITIAL;
 247         } else {
 248                 nextState(state_,
 249                           input,
 250                           state_machine_,
 251                           "OkCancelReadOnlyPolicy");
 252         }
 253 }
 254
 255
 256 /*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
 257
 258
 259 NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
 260         : state_(INITIAL),
 261           outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
 262           state_machine_(RO_INVALID + 1,
 263                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 264 {
 265         // Build the state output map
 266         outputs_[INITIAL] = CLOSE;
 267         outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
 268         outputs_[INVALID] = RESTORE | CANCEL;
 269         outputs_[RO_INITIAL] = CLOSE;
 270         outputs_[RO_VALID] = RESTORE | CANCEL;
 271         outputs_[RO_INVALID] = RESTORE | CANCEL;
 272
 273         // Build the state machine one state at a time
 274         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
 275         //        left out of the state machine and handled explicitly
 276         //        in input()
 277         //
 278         // State::INITIAL
 279         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
 280         state_machine_[INITIAL][SMI_VALID] = VALID;
 281         state_machine_[INITIAL][SMI_INVALID] = INVALID;
 282         state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
 283         // State::VALID
 284         state_machine_[VALID][SMI_VALID] = VALID;
 285         state_machine_[VALID][SMI_READ_WRITE] = VALID;
 286         state_machine_[VALID][SMI_INVALID] = INVALID;
 287         state_machine_[VALID][SMI_OKAY] = INITIAL;
 288         state_machine_[VALID][SMI_APPLY] = INITIAL;
 289         state_machine_[VALID][SMI_RESTORE] = INITIAL;
 290         state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
 291         // State::INVALID
 292         state_machine_[INVALID][SMI_INVALID] = INVALID;
 293         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
 294         state_machine_[INVALID][SMI_VALID] = VALID;
 295         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
 296         state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
 297         // State::RO_INITIAL
 298         state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
 299         state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
 300         state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
 301         state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
 302         // State::RO_VALID
 303         state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
 304         state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
 305         state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
 306         state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
 307         state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
 308         // State::RO_INVALID
 309         state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
 310         state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
 311         state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
 312         state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
 313         state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
 314 }
 315
 316
 317 void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
 318 {
 319         //lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
 320
 321         // CANCEL and HIDE always take us to INITIAL for all cases
 322         if (SMI_CANCEL == input
 323             || SMI_HIDE == input) {
 324                 state_ = INITIAL;
 325         } else {
 326                 nextState(state_,
 327                           input,
 328                           state_machine_,
 329                           "NoRepeatedApplyReadOnlyPolicy");
 330         }
 331 }
 332
 333
 334 /*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
 335
 336
 337 OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
 338         : state_(INITIAL),
 339           outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
 340           state_machine_(RO_APPLIED + 1,
 341                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 342 {
 343         // Build the state output map
 344         outputs_[INITIAL] = CLOSE;
 345         outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
 346         outputs_[INVALID] = RESTORE | CANCEL;
 347         outputs_[APPLIED] = OKAY | APPLY | CLOSE;
 348         outputs_[RO_INITIAL] = CLOSE;
 349         outputs_[RO_VALID] = RESTORE | CANCEL;
 350         outputs_[RO_INVALID] = RESTORE | CANCEL;
 351         outputs_[RO_APPLIED] = CLOSE;
 352
 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
 356         //        in input()
 357         //
 358         // State::INITIAL
 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;
 363         // State::VALID
 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_RESTORE] = INITIAL;
 369         state_machine_[VALID][SMI_APPLY] = APPLIED;
 370         state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
 371         // State::INVALID
 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;
 377         // State::APPLIED
 378         state_machine_[APPLIED][SMI_APPLY] = APPLIED;
 379         state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
 380         state_machine_[APPLIED][SMI_VALID] = VALID;
 381         state_machine_[APPLIED][SMI_INVALID] = INVALID;
 382         state_machine_[APPLIED][SMI_OKAY] = INITIAL;
 383         state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
 384         // State::RO_INITIAL
 385         state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
 386         state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
 387         state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
 388         state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
 389         // State::RO_VALID
 390         state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
 391         state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
 392         state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
 393         state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
 394         state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
 395         // State::RO_INVALID
 396         state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
 397         state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
 398         state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
 399         state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
 400         state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
 401         // State::RO_APPLIED
 402         state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
 403         state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
 404         state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
 405         state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
 406 }
 407
 408
 409 void OkApplyCancelReadOnlyPolicy::input(SMInput input)
 410 {
 411         //lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
 412
 413         // CANCEL and HIDE always take us to INITIAL for all cases
 414         if (SMI_CANCEL == input
 415             || SMI_HIDE == input) {
 416                 state_ = INITIAL;
 417         } else {
 418                 nextState(state_,
 419                           input,
 420                           state_machine_,
 421                           "OkApplyCancelReadOnlyPolicy");
 422         }
 423 }
 424
 425
 426 /*--------------------------OkApplyCancelPolicy----------------------*/
 427
 428
 429 OkApplyCancelPolicy::OkApplyCancelPolicy()
 430         : state_(INITIAL),
 431           outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
 432           state_machine_(APPLIED + 1,
 433                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 434 {
 435         // Build the state output map
 436         outputs_[INITIAL] = CLOSE;
 437         outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
 438         outputs_[INVALID] = RESTORE | CANCEL;
 439         outputs_[APPLIED] = OKAY | APPLY | CLOSE;
 440
 441         // Build the state machine one state at a time
 442         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
 443         //        left out of the state machine and handled explicitly
 444         //        in input()
 445         //
 446         // State::INITIAL
 447         state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
 448         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
 449         state_machine_[INITIAL][SMI_VALID] = VALID;
 450         state_machine_[INITIAL][SMI_INVALID] = INVALID;
 451         // State::VALID
 452         state_machine_[VALID][SMI_VALID] = VALID;
 453         state_machine_[VALID][SMI_READ_ONLY] = VALID;
 454         state_machine_[VALID][SMI_READ_WRITE] = VALID;
 455         state_machine_[VALID][SMI_INVALID] = INVALID;
 456         state_machine_[VALID][SMI_OKAY] = INITIAL;
 457         state_machine_[VALID][SMI_RESTORE] = INITIAL;
 458         state_machine_[VALID][SMI_APPLY] = APPLIED;
 459         // State::INVALID
 460         state_machine_[INVALID][SMI_INVALID] = INVALID;
 461         state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
 462         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
 463         state_machine_[INVALID][SMI_VALID] = VALID;
 464         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
 465         // State::APPLIED
 466         state_machine_[APPLIED][SMI_APPLY] = APPLIED;
 467         state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
 468         state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
 469         state_machine_[APPLIED][SMI_VALID] = VALID;
 470         state_machine_[APPLIED][SMI_INVALID] = INVALID;
 471         state_machine_[APPLIED][SMI_OKAY] = INITIAL;
 472 }
 473
 474
 475 void OkApplyCancelPolicy::input(SMInput input)
 476 {
 477         //lyxerr << "OkApplyCancelPolicy::input" << endl;
 478
 479         // CANCEL and HIDE always take us to INITIAL for all cases
 480         if (SMI_CANCEL == input
 481             || SMI_HIDE == input) {
 482                 state_ = INITIAL;
 483         } else {
 484                 nextState(state_,
 485                           input,
 486                           state_machine_,
 487                           "OkApplyCancelPolicy");
 488         }
 489 }
 490
 491
 492 /*--------------------------NoRepeatedApplyPolicy----------------------*/
 493
 494
 495 NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
 496         : state_(INITIAL),
 497           outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
 498           state_machine_(INVALID + 1,
 499                          StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
 500 {
 501         // Build the state output map
 502         outputs_[INITIAL] = CLOSE;
 503         outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
 504         outputs_[INVALID] = RESTORE | CANCEL;
 505
 506         // Build the state machine one state at a time
 507         // NOTE:  Since CANCEL and HIDE always go to INITIAL they are
 508         //        left out of the state machine and handled explicitly
 509         //        in input()
 510         //
 511         // State::INITIAL
 512         state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
 513         state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
 514         state_machine_[INITIAL][SMI_VALID] = VALID;
 515         state_machine_[INITIAL][SMI_INVALID] = INVALID;
 516         // State::VALID
 517         state_machine_[VALID][SMI_VALID] = VALID;
 518         state_machine_[VALID][SMI_READ_ONLY] = VALID;
 519         state_machine_[VALID][SMI_READ_WRITE] = VALID;
 520         state_machine_[VALID][SMI_INVALID] = INVALID;
 521         state_machine_[VALID][SMI_OKAY] = INITIAL;
 522         state_machine_[VALID][SMI_APPLY] = INITIAL;
 523         state_machine_[VALID][SMI_RESTORE] = INITIAL;
 524         // State::INVALID
 525         state_machine_[INVALID][SMI_INVALID] = INVALID;
 526         state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
 527         state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
 528         state_machine_[INVALID][SMI_VALID] = VALID;
 529         state_machine_[INVALID][SMI_RESTORE] = INITIAL;
 530 }
 531
 532
 533 void NoRepeatedApplyPolicy::input(SMInput input)
 534 {
 535         //lyxerr << "NoRepeatedApplyPolicy::input" << endl;
 536
 537         // CANCEL and HIDE always take us to INITIAL for all cases
 538         if (SMI_CANCEL == input
 539             || SMI_HIDE == input) {
 540                 state_ = INITIAL;
 541         } else {
 542                 nextState(state_,
 543                           input,
 544                           state_machine_,
 545                           "NoRepeatedApplyPolicy");
 546         }
 547 }