src/frontends/controllers/ButtonPolicies.C

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