← Back to branch summary

~vbursian/research-assistant/intervers

« back to all changes in this revision

Viewing changes to RAGUI/Console.h

  • Committer: Viktor Bursian at blin-Vista
  • Date: 2014-02-19 13:23:07 UTC
  • mto: (4.6.3 DN)
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: vbursian@gmail.com-20140219132307-paqv9dz1gwzg8sm6
multiple changes, mainly in drivers and consoles

Show diffs side-by-side

added added

removed removed

Lines of Context:
RAGUI/Console.h
223
223
                                          );
224
224
    template<class data_type>
225
225
    bool                      SendDirective (rcsDriverLink         receiver
226
 
//                                   ,const sDriver::sDirective &
227
226
                                   ,const sDriver::sDirective<data_type> &
228
227
                                                                directive
229
228
                                   ,data_type                   data
239
238
                                  return false;
240
239
                                }
241
240
    void                      AddTransition (psState           from_state
242
 
                                            ,const char *      signal
 
241
                                            ,literal           signal
243
242
                                            ,QAbstractState *  to_state);
244
243
    template<class data_type>
245
244
    void                      AddTransition (psState           from_state
246
 
                                            ,const char *      signal
 
245
                                            ,literal           signal_with_data
247
246
                                            ,QAbstractState *  to_state
248
247
                                            ,data_type         password)
249
248
                                {
251
250
                                                        <data_type> *   T
252
251
                                        (new sDriver::sGuardedSignalTransition
253
252
                                                                   <data_type>
254
 
                                                        (this,signal,password));
 
253
                                              (this,signal_with_data,password));
255
254
                                  T->setTargetState(to_state);
256
255
                                  from_state->addTransition(T);
257
256
                                }
260
259
                                            ,const char *      slot_or_signal
261
260
                                            ,QAbstractState *  to_state);
262
261
    template<class data_type>
263
 
    void                      AddTransition (psState          from_state
264
 
                                            ,const char *     signal
265
 
                                            ,const char *     slot_or_signal
 
262
    void                      AddTransition (psState    from_state
 
263
                                            ,literal    signal_with_data
 
264
                                            ,literal    slot_or_signal_with_data
266
265
                                            ,QAbstractState * to_state)
267
266
                                {
268
267
                                  sDriver::sSignalTransition<data_type> *     T
269
268
                                      (new sDriver::sSignalTransition<data_type>
270
 
                                                  (this,signal,slot_or_signal));
 
269
                                                  (this,signal_with_data
 
270
                                                  ,slot_or_signal_with_data));
271
271
                                  T->setTargetState(to_state);
272
272
                                  from_state->addTransition(T);
273
273
                                }
275
275
                                          ,const char *  signal
276
276
                                          ,const char *  slot_or_signal);
277
277
    template<class data_type>
 
278
    void                      AddReaction (psState  in_state
 
279
                                          ,literal  signal_with_data
 
280
                                          ,literal  slot_or_signal_with_data)
 
281
                                {
 
282
                                  in_state->addTransition
 
283
                                          (new sDriver::
 
284
                                               sSignalTransition<data_type>
 
285
                                                    (this,signal_with_data
 
286
                                                    ,slot_or_signal_with_data));
 
287
                                }
 
288
    template<class data_type>
278
289
    void                      AddReaction (psState       in_state
279
 
                                          ,const char *  signal
 
290
                                          ,literal       signal_with_data
280
291
                                          ,data_type     password
281
 
                                          ,const char *  slot_or_signal)
 
292
                                          ,literal       slot_or_signal)
282
293
                                {
283
294
                                  in_state->addTransition(
284
295
                                      new sDriver::sGuardedSignalTransition
285
296
                                                        <data_type>
286
 
                                                        (this,signal,password
 
297
                                                        (this,signal_with_data
 
298
                                                        ,password
287
299
                                                        ,slot_or_signal)
288
300
                                                           );
289
301
                                }