src/frontends/controllers/ButtonPolicy.cpp

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