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