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
| | /* 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"
#define PORT_CAP 1200
port_id port_emacs_to_application;
port_id port_application_to_emacs;
void
haiku_io_init (void)
{
port_emacs_to_application = create_port (PORT_CAP, "emacs application port");
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);
}
emacs_abort ();
}
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;
}
int
haiku_read (enum haiku_event_type *type, void *buf, ssize_t len)
{
int32_t 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;
}
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;
}
void
haiku_io_init_in_app_thread (void)
{
sigset_t set;
sigemptyset (&set);
sigaddset (&set, SIGUSR2);
sigaddset (&set, SIGUSR1);
if (pthread_sigmask (SIG_BLOCK, &set, NULL))
perror ("pthread_sigmask");
}
|