arzmq-sys 0.6.3

Low-level bindings to the zeromq library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#include "wxProtoApp.h"

#define WXPROTO_USE_THREADING 1
#ifndef WXPROTO_USE_THREADING
#include "wx/apptrait.h"
#include "wx/cmdline.h"
#include "wx/evtloop.h"
#include "wx/msgout.h"
#include "wx/thread.h"
#include "wx/utils.h"
#include "wx/ptr_scpd.h"
#endif  // !WXPROTO_USE_THREADING

/*BEGIN_DECLARE_EVENT_TYPES()
    DECLARE_EVENT_TYPE(wxPROTO_DISPATCH_EVENT, -1)
END_DECLARE_EVENT_TYPES()

DEFINE_EVENT_TYPE(wxPROTO_DISPATCH_EVENT)*/

const wxEventType wxProtoApp::wxPROTO_DISPATCH_EVENT = wxNewEventType();

// it may also be convenient to define an event table macro for this event type
#define EVT_PROTO_DISPATCH_COMMAND(id, fn) \
    DECLARE_EVENT_TABLE_ENTRY( \
        wxProtoApp::wxPROTO_DISPATCH_EVENT, id, -1, \
        (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)&fn, \
        (wxObject *) NULL \
    ),

DECLARE_APP(wxProtoApp)

BEGIN_EVENT_TABLE(wxProtoApp, wxApp)
    EVT_PROTO_DISPATCH_COMMAND(-1, wxProtoApp::OnDispatchEvent)
#ifndef WXPROTO_USE_THREADING
    EVT_IDLE(wxProtoApp::OnIdleEvent)
#endif // WXPROTO_USE_THREADING
END_EVENT_TABLE()


wxProtoApp::wxProtoApp(bool appDispatch)
 : ProtoDispatcher::Controller(dispatcher), app_dispatch(appDispatch)
{
   
}

wxProtoApp::~wxProtoApp()
{
    dispatcher.Stop();
}

int wxProtoApp::MainLoop()
{
#if WXPROTO_USE_THREADING
    // 1) Start ProtoDispatcher thread
    if (app_dispatch)
        dispatcher.StartThread(true, this);
    else
        dispatcher.StartThread(true);
    
    // 2) Enter standard wxWidgets event loop
    int result = wxApp::MainLoop();
    
    // Stop ProtoDispatcher thread
    dispatcher.Stop();
    
    return result;
#else
    
    TRACE("Using unstable, non-threaded wxProtoApp main loop ...\n");
   
#ifndef WIN32
    // The "guiTimer" makes sure we check for
    // wxWindows GUI events regularly
    // (TBD) asynchronously monitor for GUI events instead
    // (this already works on Win32)
    ProtoTimer guiTimer;  
    guiTimer.SetRepeat(-1);
    guiTimer.SetInterval(0.5);
    dispatcher.ActivateTimer(guiTimer);
#endif // !WIN32
    return wxApp::MainLoop();
/*    
    while (1)
    {
        TRACE("guiTimer.IsActive(): %d\n", guiTimer.IsActive());
        if (wxApp::Pending())
        {
            TRACE("dispatching ...\n");
            wxApp::Dispatch();   
        }
        else
        {
            TRACE("wx not pending ...\n");
            if (dispatcher.IsPending())
            {
                dispatcher.Run(true);  // one-shot wait/dispatch
            }
#ifdef WIN32  
            else
            {
                // (Win32 ProtoDispatcher breaks on messages)
                TRACE(" dispatcher.Wait() ...\n");
                dispatcher.Wait();
                TRACE(" dispatcher.Dispatch() ...\n");
                dispatcher.Dispatch();
            }
#endif // WIN32
        }
        if (NULL == GetTopWindow())
        { 
#ifndef WIN32
            if (guiTimer.IsActive()) guiTimer.Deactivate();
#endif // !WIN32
            if (!dispatcher.IsPending())
            {   
                dispatcher.Stop();
                break;
            }            
        }
#ifndef WIN32
        else if (!guiTimer.IsActive())
        {
             ActivateTimer(guiTimer);
        }
#endif // !WIN32
    }
    return wxApp::MainLoop();
    */
#endif
}  // end wxProtoApp::MainLoop()

bool wxProtoApp::SignalDispatchReady()
{
    wxCommandEvent dispatchEvent(wxPROTO_DISPATCH_EVENT);
    //AddPendingEvent(dispatchEvent);   
    wxPostEvent(this, dispatchEvent);
    return true;
}  // end wxProtoApp::SignalDispatchReady()


void wxProtoApp::OnDispatchEvent(wxCommandEvent& /*event*/)
{
    OnDispatch();
}

void wxProtoApp::OnIdleEvent(wxIdleEvent& event)
{
    TRACE("wxProtoApp::OnIdleEvent() ...\n");
    if (dispatcher.IsPending())
    {
        dispatcher.Run(true);   
    }
    event.RequestMore();
}