src/frontends/ButtonPolicies.C

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