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