tdevdraw.h - plan9port - [fork] Plan 9 from user space | |
git clone git://src.adamsgaard.dk/plan9port | |
Log | |
Files | |
Refs | |
README | |
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 othe… | |
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 fro… | |
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 macO… | |
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 |