src/frontends/qt4/InGuiThread.h

   1 // -*- C++ -*-
   2 /**
   3  * \file InGuiThread.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Peter Kümmel
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef INGUITHREAD_H
  13 #define INGUITHREAD_H
  14
  15 #include <QMutex>
  16 #include <QObject>
  17 #include <QWaitCondition>
  18
  19 #include "support/bind.h"
  20 #include "support/functional.h"
  21
  22 namespace lyx {
  23 namespace frontend {
  24
  25
  26 class IntoGuiThreadMover : public QObject
  27 {
  28         Q_OBJECT
  29
  30 protected:
  31
  32         IntoGuiThreadMover();
  33
  34         void callInGuiThread();
  35
  36 Q_SIGNALS:
  37         void triggerFunctionCall();
  38
  39 private Q_SLOTS:
  40         void doFunctionCall();
  41
  42 private:
  43         virtual void synchronousFunctionCall() = 0;
  44
  45         QWaitCondition condition_;
  46         QMutex sync_mutex_;
  47 };
  48
  49
  50 template<class R>
  51 class InGuiThread : private IntoGuiThreadMover
  52 {
  53 public:
  54
  55         InGuiThread() {}
  56
  57         template<class F>
  58         R call(F f)
  59         {
  60                 func_ = f;
  61                 callInGuiThread();
  62                 return return_value_;
  63         }
  64
  65         template<class F, class P1>
  66         R call(F f, P1 p1)
  67         {
  68                 return call(bind(f, p1));
  69         }
  70
  71         template<class F, class P1, class P2>
  72         R call(F f, P1 p1, P2 p2)
  73         {
  74                 return call(bind(f, p1, p2));
  75         }
  76
  77         template<class F, class P1, class P2, class P3>
  78         R call(F f, P1 p1, P2 p2, P3 p3)
  79         {
  80                 return call(bind(f, p1, p2, p3));
  81         }
  82
  83         template<class F, class P1, class P2, class P3, class P4>
  84         R call(F f, P1 p1, P2 p2, P3 p3, P4 p4)
  85         {
  86                 return call(bind(f, p1, p2, p3, p4));
  87         }
  88
  89         /*
  90           ...
  91         */
  92
  93         template<class F, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
  94         R call(F f, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
  95         {
  96                 return call(bind(f, p1, p2, p3, p4, p5, p6, p7, p8));
  97         }
  98
  99 private:
 100
 101         void synchronousFunctionCall()
 102         {
 103                 return_value_ = func_();
 104         }
 105
 106 private:
 107         R return_value_;
 108         function<R()> func_;
 109 };
 110
 111
 112 // void specialisation
 113 template<>
 114 class InGuiThread<void> : private IntoGuiThreadMover
 115 {
 116 public:
 117
 118         InGuiThread() {}
 119
 120         template<class F>
 121         void call(F f)
 122         {
 123                 func_ = f;
 124                 callInGuiThread();
 125         }
 126
 127         template<class F, class P1>
 128         void call(F f, P1 p1)
 129         {
 130                 call(bind(f, p1));
 131         }
 132
 133         template<class F, class P1, class P2>
 134         void call(F f, P1 p1, P2 p2)
 135         {
 136                 call(bind(f, p1, p2));
 137         }
 138
 139         template<class F, class P1, class P2, class P3>
 140         void call(F f, P1 p1, P2 p2, P3 p3)
 141         {
 142                 call(bind(f, p1, p2, p3));
 143         }
 144
 145         template<class F, class P1, class P2, class P3, class P4>
 146         void call(F f, P1 p1, P2 p2, P3 p3, P4 p4)
 147         {
 148                 call(bind(f, p1, p2, p3, p4));
 149         }
 150
 151         /*
 152           ...
 153         */
 154
 155         template<class F, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
 156         void call(F f, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
 157         {
 158                 call(bind(f, p1, p2, p3, p4, p5, p6, p7, p8));
 159         }
 160
 161 private:
 162
 163         void synchronousFunctionCall()
 164         {
 165                 func_();
 166         }
 167
 168 private:
 169         function<void()> func_;
 170 };
 171
 172
 173 } // namespace frontend
 174 } // namespace lyx
 175
 176 #endif // INGUITHREAD_H