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 #if QT_VERSION < 0x040400
  23 #define Q_EMIT
  24 #endif
  25
  26 namespace lyx {
  27 namespace frontend {
  28
  29
  30 class IntoGuiThreadMover : public QObject
  31 {
  32         Q_OBJECT
  33
  34 protected:
  35
  36         IntoGuiThreadMover();
  37
  38         void callInGuiThread();
  39
  40 Q_SIGNALS:
  41         void triggerFunctionCall();
  42
  43 private Q_SLOTS:
  44         void doFunctionCall();
  45
  46 private:
  47         virtual void synchronousFunctionCall() = 0;
  48
  49         QWaitCondition condition_;
  50         QMutex sync_mutex_;
  51 };
  52
  53
  54 template<class R>
  55 class InGuiThread : private IntoGuiThreadMover
  56 {
  57 public:
  58
  59         InGuiThread() {}
  60
  61         template<class F>
  62         R call(F f)
  63         {
  64                 func_ = f;
  65                 callInGuiThread();
  66                 return return_value_;
  67         }
  68
  69         template<class F, class P1>
  70         R call(F f, P1& p1)
  71         {
  72                 return call(bind(f, ref(p1)));
  73         }
  74
  75         template<class F, class P1, class P2>
  76         R call(F f, P1& p1, P2& p2)
  77         {
  78                 return call(bind(f, ref(p1), ref(p2)));
  79         }
  80
  81         template<class F, class P1, class P2, class P3>
  82         R call(F f, P1& p1, P2& p2, P3& p3)
  83         {
  84                 return call(bind(f, ref(p1), ref(p2), ref(p3)));
  85         }
  86
  87         template<class F, class P1, class P2, class P3, class P4>
  88         R call(F f, P1& p1, P2& p2, P3& p3, P4& p4)
  89         {
  90                 return call(bind(f, ref(p1), ref(p2), ref(p3), ref(p4)));
  91         }
  92
  93         /*
  94           ...
  95         */
  96
  97         template<class F, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
  98         R call(F f, P1& p1, P2& p2, P3& p3, P4& p4, P5& p5, P6& p6, P7& p7, P8& p8)
  99         {
 100                 return call(bind(f, ref(p1), ref(p2), ref(p3), ref(p4), ref(p5), ref(p6), ref(p7), ref(p8)));
 101         }
 102
 103 private:
 104
 105         void synchronousFunctionCall()
 106         {
 107                 return_value_ = func_();
 108         }
 109
 110 private:
 111         R return_value_;
 112         function<R()> func_;
 113 };
 114
 115
 116 // void specialisation
 117 template<>
 118 class InGuiThread<void> : private IntoGuiThreadMover
 119 {
 120 public:
 121
 122         InGuiThread() {}
 123
 124         template<class F>
 125         void call(F f)
 126         {
 127                 func_ = f;
 128                 callInGuiThread();
 129         }
 130
 131         template<class F, class P1>
 132         void call(F f, P1& p1)
 133         {
 134                 call(bind(f, ref(p1)));
 135         }
 136
 137         template<class F, class P1, class P2>
 138         void call(F f, P1& p1, P2& p2)
 139         {
 140                 call(bind(f, ref(p1), ref(p2)));
 141         }
 142
 143         template<class F, class P1, class P2, class P3>
 144         void call(F f, P1& p1, P2& p2, P3& p3)
 145         {
 146                 call(bind(f, ref(p1), ref(p2), ref(p3)));
 147         }
 148
 149         template<class F, class P1, class P2, class P3, class P4>
 150         void call(F f, P1& p1, P2& p2, P3& p3, P4& p4)
 151         {
 152                 call(bind(f, ref(p1), ref(p2), ref(p3), ref(p4)));
 153         }
 154
 155         /*
 156           ...
 157         */
 158
 159         template<class F, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
 160         void call(F f, P1& p1, P2& p2, P3& p3, P4& p4, P5& p5, P6& p6, P7& p7, P8& p8)
 161         {
 162                 call(bind(f, ref(p1), ref(p2), ref(p3), ref(p4), ref(p5), ref(p6), ref(p7), ref(p8)));
 163         }
 164
 165 private:
 166
 167         void synchronousFunctionCall()
 168         {
 169                 func_();
 170         }
 171
 172 private:
 173         function<void()> func_;
 174 };
 175
 176
 177 } // namespace frontend
 178 } // namespace lyx
 179
 180 #endif // INGUITHREAD_H