src/frontends/controllers/ButtonPolicies.C

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