2 * \file ButtonPolicies.C
3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
8 * Full author contact details are available in file CREDITS.
13 #include "ButtonPolicies.h"
22 void nextState(ButtonPolicy::State & state,
23 ButtonPolicy::SMInput in,
24 ButtonPolicy::StateMachine const & s_m,
25 char const * function_name = "nextState")
27 if (ButtonPolicy::SMI_NOOP == in) return;
29 ButtonPolicy::State tmp = s_m[state][in];
31 lyxerr[Debug::GUI] << "Transition from state "
32 << state << " to state " << tmp << " after input "
35 if (ButtonPolicy::BOGUS != tmp) {
38 lyxerr << function_name
39 << ": No transition for input "
50 /*-----------------------------PreferencesPolicy-----------------------------*/
53 PreferencesPolicy::PreferencesPolicy()
55 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
56 state_machine_(APPLIED + 1,
57 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
59 // Build the state output map
60 outputs_[INITIAL] = CLOSE;
61 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
62 outputs_[INVALID] = RESTORE | CANCEL;
63 outputs_[APPLIED] = OKAY | CLOSE;
65 // Build the state machine one state at a time
66 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
67 // left out of the state machine and handled explicitly
68 // in input(). This won't necessarily be true for all
69 // policies though so I'll leave those two as distinct
70 // inputs rather than merge them. For example, a dialog
71 // that doesn't update it's input fields when reshown
72 // after being hidden needs a policy where CANCEL and
73 // HIDE are treated differently.
76 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
77 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
78 state_machine_[INITIAL][SMI_VALID] = VALID;
79 state_machine_[INITIAL][SMI_INVALID] = INVALID;
81 state_machine_[VALID][SMI_VALID] = VALID;
82 state_machine_[VALID][SMI_READ_ONLY] = VALID;
83 state_machine_[VALID][SMI_READ_WRITE] = VALID;
84 state_machine_[VALID][SMI_INVALID] = INVALID;
85 state_machine_[VALID][SMI_APPLY] = APPLIED;
86 state_machine_[VALID][SMI_OKAY] = INITIAL;
87 state_machine_[VALID][SMI_RESTORE] = INITIAL;
89 state_machine_[INVALID][SMI_VALID] = VALID;
90 state_machine_[INVALID][SMI_INVALID] = INVALID;
91 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
92 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
93 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
95 state_machine_[APPLIED][SMI_VALID] = VALID;
96 state_machine_[APPLIED][SMI_INVALID] = INVALID;
97 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
98 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
99 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
103 void PreferencesPolicy::input(SMInput input)
105 //lyxerr << "PreferencesPolicy::input" << endl;
106 // CANCEL and HIDE always take us to INITIAL for all cases.
107 // Note that I didn't put that special case in the helper function
108 // because it doesn't belong there. Some other
109 // This is probably optimising for the wrong case since it occurs as the
110 // dialog will be hidden. It would have saved a little memory in the
111 // state machine if I could have gotten map working. ARRae 20000813
112 if (SMI_CANCEL == input
113 || SMI_HIDE == input) {
119 "PreferencesPolicy");
124 /*-------------------------------OkCancelPolicy------------------------------*/
127 OkCancelPolicy::OkCancelPolicy()
129 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
130 state_machine_(INVALID + 1,
131 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
133 // Build the state output map
134 outputs_[INITIAL] = CLOSE;
135 outputs_[VALID] = RESTORE | OKAY | CANCEL;
136 outputs_[INVALID] = RESTORE | CANCEL;
138 // Build the state machine one state at a time
139 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
140 // left out of the state machine and handled explicitly
144 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
145 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
146 state_machine_[INITIAL][SMI_VALID] = VALID;
147 state_machine_[INITIAL][SMI_INVALID] = INVALID;
149 state_machine_[VALID][SMI_VALID] = VALID;
150 state_machine_[VALID][SMI_READ_ONLY] = VALID;
151 state_machine_[VALID][SMI_READ_WRITE] = VALID;
152 state_machine_[VALID][SMI_INVALID] = INVALID;
153 state_machine_[VALID][SMI_OKAY] = INITIAL;
154 state_machine_[VALID][SMI_RESTORE] = INITIAL;
156 state_machine_[INVALID][SMI_VALID] = VALID;
157 state_machine_[INVALID][SMI_INVALID] = INVALID;
158 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
159 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
160 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
165 void OkCancelPolicy::input(SMInput input)
167 //lyxerr << "OkCancelPolicy::input" << endl;
169 // CANCEL and HIDE always take us to INITIAL for all cases
170 if (SMI_CANCEL == input
171 || SMI_HIDE == input) {
174 nextState(state_, input, state_machine_, "OkCancelPolicy");
179 /*---------------------------OkCancelReadOnlyPolicy-------------------------*/
182 OkCancelReadOnlyPolicy::OkCancelReadOnlyPolicy()
184 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
185 state_machine_(RO_INVALID + 1,
186 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
188 // Build the state output map
189 outputs_[INITIAL] = CLOSE;
190 outputs_[VALID] = RESTORE | OKAY | CANCEL;
191 outputs_[INVALID] = RESTORE | CANCEL;
192 outputs_[RO_INITIAL] = CLOSE;
193 outputs_[RO_VALID] = RESTORE | CANCEL;
194 outputs_[RO_INVALID] = RESTORE | CANCEL;
196 // Build the state machine one state at a time
197 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
198 // left out of the state machine and handled explicitly
202 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
203 state_machine_[INITIAL][SMI_VALID] = VALID;
204 state_machine_[INITIAL][SMI_INVALID] = INVALID;
205 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
207 state_machine_[VALID][SMI_VALID] = VALID;
208 state_machine_[VALID][SMI_READ_WRITE] = VALID;
209 state_machine_[VALID][SMI_INVALID] = INVALID;
210 state_machine_[VALID][SMI_OKAY] = INITIAL;
211 state_machine_[VALID][SMI_RESTORE] = INITIAL;
212 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
214 state_machine_[INVALID][SMI_INVALID] = INVALID;
215 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
216 state_machine_[INVALID][SMI_VALID] = VALID;
217 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
218 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
220 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
221 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
222 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
223 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
225 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
226 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
227 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
228 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
229 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
231 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
232 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
233 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
234 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
235 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
239 void OkCancelReadOnlyPolicy::input(SMInput input)
241 //lyxerr << "OkCancelReadOnlyPolicy::input" << endl;
243 // CANCEL and HIDE always take us to INITIAL for all cases
244 if (SMI_CANCEL == input
245 || SMI_HIDE == input) {
251 "OkCancelReadOnlyPolicy");
256 /*--------------------------NoRepeatedApplyReadOnlyPolicy----------------------*/
259 NoRepeatedApplyReadOnlyPolicy::NoRepeatedApplyReadOnlyPolicy()
261 outputs_(RO_INVALID + 1, ButtonPolicy::ALL_BUTTONS),
262 state_machine_(RO_INVALID + 1,
263 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
265 // Build the state output map
266 outputs_[INITIAL] = CLOSE;
267 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
268 outputs_[INVALID] = RESTORE | CANCEL;
269 outputs_[RO_INITIAL] = CLOSE;
270 outputs_[RO_VALID] = RESTORE | CANCEL;
271 outputs_[RO_INVALID] = RESTORE | CANCEL;
273 // Build the state machine one state at a time
274 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
275 // left out of the state machine and handled explicitly
279 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
280 state_machine_[INITIAL][SMI_VALID] = VALID;
281 state_machine_[INITIAL][SMI_INVALID] = INVALID;
282 state_machine_[INITIAL][SMI_READ_ONLY] = RO_INITIAL;
284 state_machine_[VALID][SMI_VALID] = VALID;
285 state_machine_[VALID][SMI_READ_WRITE] = VALID;
286 state_machine_[VALID][SMI_INVALID] = INVALID;
287 state_machine_[VALID][SMI_OKAY] = INITIAL;
288 state_machine_[VALID][SMI_APPLY] = INITIAL;
289 state_machine_[VALID][SMI_RESTORE] = INITIAL;
290 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
292 state_machine_[INVALID][SMI_INVALID] = INVALID;
293 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
294 state_machine_[INVALID][SMI_VALID] = VALID;
295 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
296 state_machine_[INVALID][SMI_READ_ONLY] = RO_INVALID;
298 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
299 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
300 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
301 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
303 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
304 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
305 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
306 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
307 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
309 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
310 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
311 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
312 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
313 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
317 void NoRepeatedApplyReadOnlyPolicy::input(SMInput input)
319 //lyxerr << "NoReapeatedApplyReadOnlyPolicy::input" << endl;
321 // CANCEL and HIDE always take us to INITIAL for all cases
322 if (SMI_CANCEL == input
323 || SMI_HIDE == input) {
329 "NoRepeatedApplyReadOnlyPolicy");
334 /*--------------------------OkApplyCancelReadOnlyPolicy----------------------*/
337 OkApplyCancelReadOnlyPolicy::OkApplyCancelReadOnlyPolicy()
339 outputs_(RO_APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
340 state_machine_(RO_APPLIED + 1,
341 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
343 // Build the state output map
344 outputs_[INITIAL] = CLOSE;
345 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
346 outputs_[INVALID] = RESTORE | CANCEL;
347 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
348 outputs_[RO_INITIAL] = CLOSE;
349 outputs_[RO_VALID] = RESTORE | CANCEL;
350 outputs_[RO_INVALID] = RESTORE | CANCEL;
351 outputs_[RO_APPLIED] = CLOSE;
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
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;
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_RESTORE] = INITIAL;
369 state_machine_[VALID][SMI_APPLY] = APPLIED;
370 state_machine_[VALID][SMI_READ_ONLY] = RO_VALID;
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;
378 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
379 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
380 state_machine_[APPLIED][SMI_VALID] = VALID;
381 state_machine_[APPLIED][SMI_INVALID] = INVALID;
382 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
383 state_machine_[APPLIED][SMI_READ_ONLY] = RO_APPLIED;
385 state_machine_[RO_INITIAL][SMI_READ_ONLY] = RO_INITIAL;
386 state_machine_[RO_INITIAL][SMI_VALID] = RO_VALID;
387 state_machine_[RO_INITIAL][SMI_INVALID] = RO_INVALID;
388 state_machine_[RO_INITIAL][SMI_READ_WRITE] = INITIAL;
390 state_machine_[RO_VALID][SMI_VALID] = RO_VALID;
391 state_machine_[RO_VALID][SMI_READ_ONLY] = RO_VALID;
392 state_machine_[RO_VALID][SMI_INVALID] = RO_INVALID;
393 state_machine_[RO_VALID][SMI_READ_WRITE] = VALID;
394 state_machine_[RO_VALID][SMI_RESTORE] = RO_INITIAL;
396 state_machine_[RO_INVALID][SMI_INVALID] = RO_INVALID;
397 state_machine_[RO_INVALID][SMI_READ_ONLY] = RO_INVALID;
398 state_machine_[RO_INVALID][SMI_VALID] = RO_VALID;
399 state_machine_[RO_INVALID][SMI_READ_WRITE] = INVALID;
400 state_machine_[RO_INVALID][SMI_RESTORE] = RO_INITIAL;
402 state_machine_[RO_APPLIED][SMI_READ_ONLY] = RO_APPLIED;
403 state_machine_[RO_APPLIED][SMI_INVALID] = RO_INVALID;
404 state_machine_[RO_APPLIED][SMI_VALID] = RO_VALID;
405 state_machine_[RO_APPLIED][SMI_READ_WRITE] = APPLIED;
409 void OkApplyCancelReadOnlyPolicy::input(SMInput input)
411 //lyxerr << "OkApplyCancelReadOnlyPolicy::input" << endl;
413 // CANCEL and HIDE always take us to INITIAL for all cases
414 if (SMI_CANCEL == input
415 || SMI_HIDE == input) {
421 "OkApplyCancelReadOnlyPolicy");
426 /*--------------------------OkApplyCancelPolicy----------------------*/
429 OkApplyCancelPolicy::OkApplyCancelPolicy()
431 outputs_(APPLIED + 1, ButtonPolicy::ALL_BUTTONS),
432 state_machine_(APPLIED + 1,
433 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
435 // Build the state output map
436 outputs_[INITIAL] = CLOSE;
437 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
438 outputs_[INVALID] = RESTORE | CANCEL;
439 outputs_[APPLIED] = OKAY | APPLY | CLOSE;
441 // Build the state machine one state at a time
442 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
443 // left out of the state machine and handled explicitly
447 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
448 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
449 state_machine_[INITIAL][SMI_VALID] = VALID;
450 state_machine_[INITIAL][SMI_INVALID] = INVALID;
452 state_machine_[VALID][SMI_VALID] = VALID;
453 state_machine_[VALID][SMI_READ_ONLY] = VALID;
454 state_machine_[VALID][SMI_READ_WRITE] = VALID;
455 state_machine_[VALID][SMI_INVALID] = INVALID;
456 state_machine_[VALID][SMI_OKAY] = INITIAL;
457 state_machine_[VALID][SMI_RESTORE] = INITIAL;
458 state_machine_[VALID][SMI_APPLY] = APPLIED;
460 state_machine_[INVALID][SMI_INVALID] = INVALID;
461 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
462 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
463 state_machine_[INVALID][SMI_VALID] = VALID;
464 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
466 state_machine_[APPLIED][SMI_APPLY] = APPLIED;
467 state_machine_[APPLIED][SMI_READ_ONLY] = APPLIED;
468 state_machine_[APPLIED][SMI_READ_WRITE] = APPLIED;
469 state_machine_[APPLIED][SMI_VALID] = VALID;
470 state_machine_[APPLIED][SMI_INVALID] = INVALID;
471 state_machine_[APPLIED][SMI_OKAY] = INITIAL;
475 void OkApplyCancelPolicy::input(SMInput input)
477 //lyxerr << "OkApplyCancelPolicy::input" << endl;
479 // CANCEL and HIDE always take us to INITIAL for all cases
480 if (SMI_CANCEL == input
481 || SMI_HIDE == input) {
487 "OkApplyCancelPolicy");
492 /*--------------------------NoRepeatedApplyPolicy----------------------*/
495 NoRepeatedApplyPolicy::NoRepeatedApplyPolicy()
497 outputs_(INVALID + 1, ButtonPolicy::ALL_BUTTONS),
498 state_machine_(INVALID + 1,
499 StateArray(int(SMI_TOTAL), ButtonPolicy::BOGUS))
501 // Build the state output map
502 outputs_[INITIAL] = CLOSE;
503 outputs_[VALID] = RESTORE | OKAY | APPLY | CANCEL;
504 outputs_[INVALID] = RESTORE | CANCEL;
506 // Build the state machine one state at a time
507 // NOTE: Since CANCEL and HIDE always go to INITIAL they are
508 // left out of the state machine and handled explicitly
512 state_machine_[INITIAL][SMI_READ_ONLY] = INITIAL;
513 state_machine_[INITIAL][SMI_READ_WRITE] = INITIAL;
514 state_machine_[INITIAL][SMI_VALID] = VALID;
515 state_machine_[INITIAL][SMI_INVALID] = INVALID;
517 state_machine_[VALID][SMI_VALID] = VALID;
518 state_machine_[VALID][SMI_READ_ONLY] = VALID;
519 state_machine_[VALID][SMI_READ_WRITE] = VALID;
520 state_machine_[VALID][SMI_INVALID] = INVALID;
521 state_machine_[VALID][SMI_OKAY] = INITIAL;
522 state_machine_[VALID][SMI_APPLY] = INITIAL;
523 state_machine_[VALID][SMI_RESTORE] = INITIAL;
525 state_machine_[INVALID][SMI_INVALID] = INVALID;
526 state_machine_[INVALID][SMI_READ_ONLY] = INVALID;
527 state_machine_[INVALID][SMI_READ_WRITE] = INVALID;
528 state_machine_[INVALID][SMI_VALID] = VALID;
529 state_machine_[INVALID][SMI_RESTORE] = INITIAL;
533 void NoRepeatedApplyPolicy::input(SMInput input)
535 //lyxerr << "NoRepeatedApplyPolicy::input" << endl;
537 // CANCEL and HIDE always take us to INITIAL for all cases
538 if (SMI_CANCEL == input
539 || SMI_HIDE == input) {
545 "NoRepeatedApplyPolicy");