tdevdraw.h - plan9port - [fork] Plan 9 from user space
HTML git clone git://src.adamsgaard.dk/plan9port
DIR Log
DIR Files
DIR Refs
DIR README
DIR LICENSE
---
tdevdraw.h (5270B)
---
1
2 #define NHASH (1<<5)
3 #define HASHMASK (NHASH-1)
4
5 typedef struct Kbdbuf Kbdbuf;
6 typedef struct Mousebuf Mousebuf;
7 typedef struct Tagbuf Tagbuf;
8
9 typedef struct Client Client;
10 typedef struct ClientImpl ClientImpl;
11 typedef struct DImage DImage;
12 typedef struct DScreen DScreen;
13 typedef struct CScreen CScreen;
14 typedef struct FChar FChar;
15 typedef struct Refresh Refresh;
16 typedef struct Refx Refx;
17 typedef struct DName DName;
18
19 struct Kbdbuf
20 {
21 Rune r[256];
22 int ri;
23 int wi;
24 int stall;
25 int alting;
26 Rune k[10];
27 int nk;
28 };
29
30 struct Mousebuf
31 {
32 Mouse m[256];
33 Mouse last;
34 int ri;
35 int wi;
36 int stall;
37 int resized;
38 };
39
40 struct Tagbuf
41 {
42 int t[256];
43 int ri;
44 int wi;
45 };
46
47 struct ClientImpl
48 {
49 void (*rpc_resizeimg)(Client*);
50 void (*rpc_resizewindow)(Client*, Rectangle);
51 void (*rpc_setcursor)(Client*, Cursor*, Cursor2*);
52 void (*rpc_setlabel)(Client*, char*);
53 void (*rpc_setmouse)(Client*, Point);
54 void (*rpc_topwin)(Client*);
55 void (*rpc_bouncemouse)(Client*, Mouse);
56 void (*rpc_flush)(Client*, Rectangle);
57 };
58
59 extern QLock drawlk;
60
61 struct Client
62 {
63 int rfd;
64
65 // wfdlk protects writes to wfd, which can be issued from either
66 // the RPC thread or the graphics thread.
67 QLock wfdlk;
68 int wfd;
69 uchar* mbuf;
70 int nmbuf;
71
72 char* wsysid;
73
74 // drawlk protects the draw data structures for all clients.
75 // It can be acquired by an RPC thread or a graphics thread
76 // but must not be held on one thread while waiting for the other.
77 /*Ref r;*/
78 DImage* dimage[NHASH];
79 CScreen* cscreen;
80 Refresh* refresh;
81 Rendez refrend;
82 uchar* readdata;
83 int nreaddata;
84 int busy;
85 int clientid;
86 int slot;
87 int refreshme;
88 int infoid;
89 int op;
90 int displaydpi;
91 int forcedpi;
92 int waste;
93 Rectangle flushrect;
94 Memimage *screenimage;
95 DScreen* dscreen;
96 int nname;
97 DName* name;
98 int namevers;
99 ClientImpl* impl;
100
101 // Only accessed/modified by the graphics thread.
102 const void* view;
103
104 // eventlk protects the keyboard and mouse events.
105 QLock eventlk;
106 Kbdbuf kbd;
107 Mousebuf mouse;
108 Tagbuf kbdtags;
109 Tagbuf mousetags;
110 Rectangle mouserect;
111 };
112
113 struct Refresh
114 {
115 DImage* dimage;
116 Rectangle r;
117 Refresh* next;
118 };
119
120 struct Refx
121 {
122 Client* client;
123 DImage* dimage;
124 };
125
126 struct DName
127 {
128 char *name;
129 Client *client;
130 DImage* dimage;
131 int vers;
132 };
133
134 struct FChar
135 {
136 int minx; /* left edge of bits */
137 int maxx; /* right edge of bits */
138 uchar miny; /* first non-zero scan-line */
139 uchar maxy; /* last non-zero scan-line + 1 */
140 schar left; /* offset of baseline */
141 uchar width; /* width of baseline */
142 };
143
144 /*
145 * Reference counts in DImages:
146 * one per open by original client
147 * one per screen image or fill
148 * one per image derived from this one by name
149 */
150 struct DImage
151 {
152 int id;
153 int ref;
154 char *name;
155 int vers;
156 Memimage* image;
157 int ascent;
158 int nfchar;
159 FChar* fchar;
160 DScreen* dscreen; /* 0 if not a window */
161 DImage* fromname; /* image this one is derived from, by name */
162 DImage* next;
163 };
164
165 struct CScreen
166 {
167 DScreen* dscreen;
168 CScreen* next;
169 };
170
171 struct DScreen
172 {
173 int id;
174 int public;
175 int ref;
176 DImage *dimage;
177 DImage *dfill;
178 Memscreen* screen;
179 Client* owner;
180 DScreen* next;
181 };
182
183 // For the most part, the graphics driver-specific code in files
184 // like mac-screen.m runs in the graphics library's main thread,
185 // while the RPC service code in srv.c runs on the RPC service thread.
186 // The exceptions in each file, which are called by the other,
187 // are marked with special prefixes: gfx_* indicates code that
188 // is in srv.c but nonetheless runs on the main graphics thread,
189 // while rpc_* indicates code that is in, say, mac-screen.m but
190 // nonetheless runs on the RPC service thread.
191 //
192 // The gfx_* and rpc_* calls typically synchronize with the other
193 // code in the file by acquiring a lock (or running a callback on the
194 // target thread, which amounts to the same thing).
195 // To avoid deadlock, callers of those routines must not hold any locks.
196
197 // gfx_* routines are called on the graphics thread,
198 // invoked from graphics driver callbacks to do RPC work.
199 // No locks are held on entry.
200 void gfx_abortcompose(Client*);
201 void gfx_keystroke(Client*, int);
202 void gfx_main(void);
203 void gfx_mousetrack(Client*, int, int, int, uint);
204 void gfx_replacescreenimage(Client*, Memimage*);
205 void gfx_mouseresized(Client*);
206 void gfx_started(void);
207
208 // rpc_* routines are called on the RPC thread,
209 // invoked by the RPC server code to do graphics work.
210 // No locks are held on entry.
211 Memimage *rpc_attach(Client*, char*, char*);
212 char* rpc_getsnarf(void);
213 void rpc_putsnarf(char*);
214 void rpc_shutdown(void);
215 void rpc_main(void);
216
217 // rpc_gfxdrawlock and rpc_gfxdrawunlock
218 // are called around drawing operations to lock and unlock
219 // access to the graphics display, for systems where the
220 // individual memdraw operations use the graphics display (X11, not macOS).
221 void rpc_gfxdrawlock(void);
222 void rpc_gfxdrawunlock(void);
223
224 // draw* routines are called on the RPC thread,
225 // invoked by the RPC server to do pixel pushing.
226 // No locks are held on entry.
227 int draw_dataread(Client*, void*, int);
228 int draw_datawrite(Client*, void*, int);
229 void draw_initdisplaymemimage(Client*, Memimage*);
230
231 // utility routines
232 int latin1(Rune*, int);
233 int mouseswap(int);
234 int parsewinsize(char*, Rectangle*, int*);
235
236 extern Client *client0; // set in single-client mode