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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
| | /* Haiku window system support.
Copyright (C) 2021 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
#include <config.h>
#include <signal.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <OS.h>
#include "haiku_support.h"
#include "lisp.h"
#include "haikuterm.h"
#include "blockinput.h"
#define PORT_CAP 1200
/* The port used to send messages from the application thread to
Emacs. */
port_id port_application_to_emacs;
void
haiku_io_init (void)
{
port_application_to_emacs = create_port (PORT_CAP, "application emacs port");
}
static ssize_t
haiku_len (enum haiku_event_type type)
{
switch (type)
{
case QUIT_REQUESTED:
return sizeof (struct haiku_quit_requested_event);
case FRAME_RESIZED:
return sizeof (struct haiku_resize_event);
case FRAME_EXPOSED:
return sizeof (struct haiku_expose_event);
case KEY_DOWN:
case KEY_UP:
return sizeof (struct haiku_key_event);
case ACTIVATION:
return sizeof (struct haiku_activation_event);
case MOUSE_MOTION:
return sizeof (struct haiku_mouse_motion_event);
case BUTTON_DOWN:
case BUTTON_UP:
return sizeof (struct haiku_button_event);
case ICONIFICATION:
return sizeof (struct haiku_iconification_event);
case MOVE_EVENT:
return sizeof (struct haiku_move_event);
case SCROLL_BAR_VALUE_EVENT:
return sizeof (struct haiku_scroll_bar_value_event);
case SCROLL_BAR_DRAG_EVENT:
return sizeof (struct haiku_scroll_bar_drag_event);
case WHEEL_MOVE_EVENT:
return sizeof (struct haiku_wheel_move_event);
case MENU_BAR_RESIZE:
return sizeof (struct haiku_menu_bar_resize_event);
case MENU_BAR_OPEN:
case MENU_BAR_CLOSE:
return sizeof (struct haiku_menu_bar_state_event);
case MENU_BAR_SELECT_EVENT:
return sizeof (struct haiku_menu_bar_select_event);
case FILE_PANEL_EVENT:
return sizeof (struct haiku_file_panel_event);
case MENU_BAR_HELP_EVENT:
return sizeof (struct haiku_menu_bar_help_event);
case ZOOM_EVENT:
return sizeof (struct haiku_zoom_event);
case REFS_EVENT:
return sizeof (struct haiku_refs_event);
case APP_QUIT_REQUESTED_EVENT:
return sizeof (struct haiku_app_quit_requested_event);
}
emacs_abort ();
}
/* Read the size of the next message into len, returning -1 if the
query fails or there is no next message. */
void
haiku_read_size (ssize_t *len)
{
port_id from = port_application_to_emacs;
ssize_t size;
size = port_buffer_size_etc (from, B_TIMEOUT, 0);
if (size < B_OK)
*len = -1;
else
*len = size;
}
/* Read the next message into BUF, putting its type into TYPE,
assuming the message is at most LEN long. Return 0 if successful
and -1 if the read fails. */
int
haiku_read (enum haiku_event_type *type, void *buf, ssize_t len)
{
int32 typ;
port_id from = port_application_to_emacs;
if (read_port (from, &typ, buf, len) < B_OK)
return -1;
*type = (enum haiku_event_type) typ;
eassert (len >= haiku_len (typ));
return 0;
}
/* The same as haiku_read, but time out after TIMEOUT microseconds.
Input is blocked when an attempt to read is in progress. */
int
haiku_read_with_timeout (enum haiku_event_type *type, void *buf, ssize_t len,
time_t timeout)
{
int32 typ;
port_id from = port_application_to_emacs;
block_input ();
if (read_port_etc (from, &typ, buf, len,
B_TIMEOUT, (bigtime_t) timeout) < B_OK)
{
unblock_input ();
return -1;
}
unblock_input ();
*type = (enum haiku_event_type) typ;
eassert (len >= haiku_len (typ));
return 0;
}
/* Write a message with type TYPE into BUF. */
int
haiku_write (enum haiku_event_type type, void *buf)
{
port_id to = port_application_to_emacs;
if (write_port (to, (int32_t) type, buf, haiku_len (type)) < B_OK)
return -1;
kill (getpid (), SIGPOLL);
return 0;
}
int
haiku_write_without_signal (enum haiku_event_type type, void *buf)
{
port_id to = port_application_to_emacs;
if (write_port (to, (int32_t) type, buf, haiku_len (type)) < B_OK)
return -1;
return 0;
}
void
haiku_io_init_in_app_thread (void)
{
sigset_t set;
sigfillset (&set);
if (pthread_sigmask (SIG_BLOCK, &set, NULL))
perror ("pthread_sigmask");
}
/* Record an unwind protect from C++ code. */
void
record_c_unwind_protect_from_cxx (void (*fn) (void *), void *r)
{
record_unwind_protect_ptr (fn, r);
}
/* SPECPDL_IDX that is safe from C++ code. */
ptrdiff_t
c_specpdl_idx_from_cxx (void)
{
return SPECPDL_INDEX ();
}
/* unbind_to (IDX, Qnil), but safe from C++ code. */
void
c_unbind_to_nil_from_cxx (ptrdiff_t idx)
{
unbind_to (idx, Qnil);
}
|