Mercurial > projects > dynamin
annotate dynamin/gui/x_window.d @ 33:329ce1001936
Refactor painting on X by using PaintQueue.
| author | Jordan Miner <jminer7@gmail.com> |
|---|---|
| date | Sat, 25 Jul 2009 22:49:17 -0500 |
| parents | b48d3f2f570d |
| children | e4d290aaa7ed |
| rev | line source |
|---|---|
| 0 | 1 // Written in the D programming language |
| 2 // www.digitalmars.com/d/ | |
| 3 | |
| 4 /* | |
| 5 * The contents of this file are subject to the Mozilla Public License Version | |
| 6 * 1.1 (the "License"); you may not use this file except in compliance with | |
| 7 * the License. You may obtain a copy of the License at | |
| 8 * http://www.mozilla.org/MPL/ | |
| 9 * | |
| 10 * Software distributed under the License is distributed on an "AS IS" basis, | |
| 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License | |
| 12 * for the specific language governing rights and limitations under the | |
| 13 * License. | |
| 14 * | |
| 15 * The Original Code is the Dynamin library. | |
| 16 * | |
| 17 * The Initial Developer of the Original Code is Jordan Miner. | |
| 18 * Portions created by the Initial Developer are Copyright (C) 2007-2009 | |
| 19 * the Initial Developer. All Rights Reserved. | |
| 20 * | |
| 21 * Contributor(s): | |
| 22 * Jordan Miner <jminer7@gmail.com> | |
| 23 * | |
| 24 */ | |
| 25 | |
| 26 module dynamin.gui.x_window; | |
| 27 | |
| 28 public import dynamin.core.string; | |
| 29 public import dynamin.core.global; | |
| 30 public import dynamin.core.math; | |
| 31 public import dynamin.gui.window; | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
32 public import dynamin.gui.key; |
| 0 | 33 public import dynamin.c.xlib; |
| 34 public import dynamin.c.xlib : XWindow = Window; | |
| 35 public import dynamin.c.xmu; | |
| 36 public import dynamin.c.cairo; | |
| 37 public import dynamin.c.cairo_xlib; | |
| 38 public import tango.stdc.string; | |
| 39 public import tango.io.Stdout; | |
| 40 | |
| 41 /* | |
| 42 ** Window property: | |
| 43 ** _NET_FRAME_EXTENTS(CARDINAL) = 4, 4, 23, 4 | |
| 44 ** left, right, top and bottom border sizes | |
| 45 */ | |
| 46 | |
| 47 Window[XWindow] windows; | |
| 48 void setControl(XWindow handle, Window win) { | |
| 49 if(win is null) | |
| 50 windows.remove(handle); | |
| 51 else | |
| 52 windows[handle] = win; | |
| 53 } | |
| 54 | |
| 55 Window getControl(XWindow handle) { | |
| 56 auto tmp = handle in windows; | |
| 57 return tmp is null ? null : *tmp; | |
| 58 } | |
| 59 | |
| 60 /** | |
| 61 * A simpler method that returns all the data in a property. | |
| 62 * NOTE: the returned data still has to be freed with XFree() | |
| 63 */ | |
| 64 void* getXWindowProperty(XDisplay* d, XWindow w, XAtom prop, int* numRet = null) { | |
| 65 XAtom actualType; | |
| 66 int actualFormat; | |
| 67 uint nitems, bytesAfter; | |
| 68 void* ptr; | |
| 69 XGetWindowProperty(d, w, prop, | |
| 70 0, 0xFFFFFFFF, false, AnyPropertyType, | |
| 71 &actualType, &actualFormat, &nitems, &bytesAfter, | |
| 72 &ptr); | |
| 73 if(numRet) *numRet = nitems; | |
| 74 return ptr; | |
| 75 } | |
| 76 bool isWMPropertySupported(XAtom prop) { | |
| 77 int count; | |
| 78 XAtom* atoms = cast(XAtom*)getXWindowProperty(display, | |
| 79 root, XA._NET_SUPPORTED, &count); | |
| 80 scope(exit) XFree(atoms); | |
| 81 for(int i = 0; i < count; ++i) | |
| 82 if(atoms[i] == prop) | |
| 83 return true; | |
| 84 return false; | |
| 85 } | |
| 86 bool isTopLevelReparented(XWindow w) { | |
| 87 XWindow root, parent; | |
| 88 XWindow* children; | |
| 89 uint numChildren; | |
| 90 XQueryTree(display, w, | |
| 91 &root, &parent, &children, &numChildren); | |
| 92 return parent != root; | |
| 93 } | |
| 94 | |
| 95 XDisplay* display; | |
| 96 XWindow root; | |
| 97 XWindow msgWin; | |
| 98 abstract class XA { // X atoms | |
| 99 static: | |
| 100 XAtom _NET_SUPPORTED, _NET_WM_NAME, _NET_WORKAREA, _NET_FRAME_EXTENTS; | |
| 101 XAtom _NET_REQUEST_FRAME_EXTENTS; | |
| 102 XAtom _NET_MOVERESIZE_WINDOW; | |
| 103 XAtom _NET_WM_WINDOW_TYPE; | |
| 104 XAtom _NET_WM_WINDOW_TYPE_MENU, _NET_WM_WINDOW_TYPE_UTILITY; | |
| 105 XAtom _NET_WM_WINDOW_TYPE_SPLASH; | |
| 106 XAtom _NET_WM_WINDOW_TYPE_DIALOG, _NET_WM_WINDOW_TYPE_NORMAL; | |
| 107 XAtom WM_PROTOCOLS, WM_DELETE_WINDOW, _NET_WM_SYNC_REQUEST; | |
| 108 XAtom UTF8_STRING, ATOM; | |
| 109 XAtom _MOTIF_WM_HINTS; | |
| 110 XAtom CLIPBOARD, PRIMARY, TARGETS, CLIPBOARD_MANAGER, SAVE_TARGETS; | |
| 111 XAtom DYNAMIN_SELECTION; | |
| 112 } | |
| 113 static this() { | |
| 114 display = XOpenDisplay(null); | |
| 115 if(!display) | |
| 116 Stdout("XOpenDisplay() failed").newline; | |
| 117 root = XRootWindow(display, XDefaultScreen(display)); | |
| 118 | |
| 119 msgWin = XCreateSimpleWindow(display, root, 0, 0, 1, 1, 0, 0, 0); | |
| 120 | |
| 121 XA._NET_SUPPORTED = XInternAtom(display, "_NET_SUPPORTED", false); | |
| 122 XA._NET_WM_NAME = XInternAtom(display, "_NET_WM_NAME", false); | |
| 123 XA._NET_WORKAREA = XInternAtom(display, "_NET_WORKAREA", false); | |
| 124 XA._NET_FRAME_EXTENTS = XInternAtom(display, "_NET_FRAME_EXTENTS", false); | |
| 125 XA._NET_REQUEST_FRAME_EXTENTS = | |
| 126 XInternAtom(display, "_NET_REQUEST_FRAME_EXTENTS", false); | |
| 127 XA._NET_MOVERESIZE_WINDOW = | |
| 128 XInternAtom(display, "_NET_MOVERESIZE_WINDOW", false); | |
| 129 XA._NET_WM_WINDOW_TYPE = | |
| 130 XInternAtom(display, "_NET_WM_WINDOW_TYPE", false); | |
| 131 XA._NET_WM_WINDOW_TYPE_MENU = | |
| 132 XInternAtom(display, "_NET_WM_WINDOW_TYPE_MENU", false); | |
| 133 XA._NET_WM_WINDOW_TYPE_UTILITY = | |
| 134 XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", false); | |
| 135 XA._NET_WM_WINDOW_TYPE_SPLASH = | |
| 136 XInternAtom(display, "_NET_WM_WINDOW_TYPE_SPLASH", false); | |
| 137 XA._NET_WM_WINDOW_TYPE_DIALOG = | |
| 138 XInternAtom(display, "_NET_WM_WINDOW_TYPE_DIALOG", false); | |
| 139 XA._NET_WM_WINDOW_TYPE_NORMAL = | |
| 140 XInternAtom(display, "_NET_WM_WINDOW_TYPE_NORMAL", false); | |
| 141 XA.WM_PROTOCOLS = XInternAtom(display, "WM_PROTOCOLS", false); | |
| 142 XA.WM_DELETE_WINDOW = XInternAtom(display, "WM_DELETE_WINDOW", false); | |
| 143 XA._NET_WM_SYNC_REQUEST = | |
| 144 XInternAtom(display, "_NET_WM_SYNC_REQUEST", false); | |
| 145 XA.UTF8_STRING = XInternAtom(display, "UTF8_STRING", false); | |
| 146 XA.ATOM = XInternAtom(display, "ATOM", false); | |
| 147 XA._MOTIF_WM_HINTS = XInternAtom(display, "_MOTIF_WM_HINTS", false); | |
| 148 XA.CLIPBOARD = XInternAtom(display, "CLIPBOARD", false); | |
| 149 XA.PRIMARY = XInternAtom(display, "PRIMARY", false); | |
| 150 XA.TARGETS = XInternAtom(display, "TARGETS", false); | |
| 151 XA.CLIPBOARD_MANAGER = XInternAtom(display, "CLIPBOARD_MANAGER", false); | |
| 152 XA.SAVE_TARGETS = XInternAtom(display, "SAVE_TARGETS", false); | |
| 153 | |
| 154 XA.DYNAMIN_SELECTION = XInternAtom(display, "DYNAMIN_SELECTION", false); | |
| 155 if(!isWMPropertySupported(XA._NET_WM_NAME)) | |
| 156 Stdout("warning: WM does not support _NET_WM_NAME").newline; | |
| 157 if(!isWMPropertySupported(XA._NET_WORKAREA)) | |
| 158 Stdout("warning: WM does not support _NET_WORKAREA").newline; | |
| 159 if(!isWMPropertySupported(XA._NET_FRAME_EXTENTS)) | |
| 160 Stdout("warning: WM does not support _NET_FRAME_EXTENTS").newline; | |
| 161 if(!isWMPropertySupported(XA._NET_WORKAREA)) | |
| 162 Stdout("warning: WM does not support _NET_WORKAREA").newline; | |
| 163 } | |
| 164 | |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
165 struct InvalidRect { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
166 Window window; |
| 0 | 167 int x, y, width, height; |
| 168 } | |
| 169 | |
| 170 static class PaintQueue { | |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
171 import tango.util.container.LinkedList; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
172 import dynamin.painting.graphics; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
173 import dynamin.gui.events; |
| 0 | 174 static: |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
175 LinkedList!(InvalidRect) rects; |
| 0 | 176 static this() { |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
177 rects = new LinkedList!(InvalidRect)(); |
| 0 | 178 } |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
179 void add(Window win, int x, int y, int width, int height) { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
180 auto iter = rects.iterator; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
181 InvalidRect* r; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
182 while((r = iter.next()) !is null) { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
183 if(r.window == win && shouldMerge(r.x, r.y, r.width, r.height, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
184 x, y, width, height)) { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
185 join(r.x, r.y, r.width, r.height, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
186 x, y, width, height); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
187 return; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
188 } |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
189 } |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
190 InvalidRect rect; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
191 rect.window = win; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
192 rect.x = x; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
193 rect.y = y; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
194 rect.width = width; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
195 rect.height = height; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
196 rects.add(rect); |
| 0 | 197 } |
| 198 bool shouldMerge(int x1, int y1, int width1, int height1, | |
| 199 int x2, int y2, int width2, int height2) { | |
| 200 return x2 <= x1 + width1 && y2 <= y1 + height1 && | |
| 201 x2 + width2 >= x1 && y2 + height2 >= y1; | |
| 202 } | |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
203 void join(inout int x, inout int y, inout int width, inout int height, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
204 int x2, int y2, int width2, int height2) { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
205 auto minx = min(x, x2); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
206 auto miny = min(y, y2); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
207 width = max(x+width, x2+width2)-minx; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
208 height = max(y+height, y2+height2)-miny; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
209 x = minx; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
210 y = miny; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
211 } |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
212 void paint() { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
213 if(rects.size == 0) |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
214 return; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
215 auto iter = rects.iterator; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
216 InvalidRect* r; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
217 while((r = iter.next()) !is null) |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
218 paint(r); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
219 rects.clear(); |
| 0 | 220 } |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
221 void paint(InvalidRect* rect) { |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
222 auto surfaceWin = cairo_xlib_surface_create( |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
223 display, rect.window.handle, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
224 XDefaultVisual(display, XDefaultScreen(display)), |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
225 cast(int)rect.window.width, cast(int)rect.window.height); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
226 // TODO: ^ should be contentWidth/height or got from evWindow |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
227 auto crWin = cairo_create(surfaceWin); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
228 cairo_surface_destroy(surfaceWin); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
229 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
230 auto surfaceBuff = cairo_surface_create_similar(surfaceWin, CAIRO_CONTENT_COLOR, rect.width, rect.height); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
231 auto crBuff = cairo_create(surfaceBuff); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
232 cairo_translate(crBuff, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
233 -rect.x-rect.window.borderSize.left, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
234 -rect.y-rect.window.borderSize.top); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
235 cairo_surface_destroy(surfaceBuff); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
236 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
237 cairo_set_source_rgb(crBuff, rect.window.content.backColor.R/255.0, rect.window.content.backColor.G/255.0, rect.window.content.backColor.B/255.0); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
238 cairo_paint(crBuff); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
239 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
240 cairo_set_source_rgb(crBuff, 0, 0, 0); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
241 cairo_set_line_width(crBuff, 1.0); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
242 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
243 auto g = new Graphics(crBuff); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
244 scope args = new PaintingEventArgs(g); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
245 rect.window.painting(args); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
246 delete g; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
247 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
248 cairo_set_source_surface(crWin, surfaceBuff, rect.x, rect.y); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
249 cairo_rectangle(crWin, rect.x, rect.y, rect.width, rect.height); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
250 cairo_fill(crWin); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
251 |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
252 cairo_destroy(crBuff); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
253 cairo_destroy(crWin); |
| 0 | 254 } |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
255 } |
| 0 | 256 |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
257 Key prevKey = Key.None; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
258 |
| 0 | 259 //{{{ ApplicationBackend |
| 260 template ApplicationBackend() { | |
| 261 void backend_run(Window w) { | |
| 262 bool isWindowVisible() { | |
| 263 if(w is null) return true; | |
| 264 return w.visible; | |
| 265 } | |
| 266 XEvent ev; | |
| 267 while(isWindowVisible()) { | |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
268 if(XEventsQueued(display, QueuedAlready) == 0) |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
269 PaintQueue.paint(); |
| 0 | 270 XNextEvent(display, &ev); |
| 271 auto evDisplay = ev.xany.display; | |
| 272 auto evWindow = ev.xany.window; | |
| 273 Window c = getControl(evWindow); | |
| 274 // c will be null for SelectionRequest events | |
| 275 //if(c is null) | |
| 276 // continue; | |
| 277 //{{{ helper functions | |
| 278 void createMouseEvent(void delegate(MouseEventArgs args) func) { | |
| 279 MouseButton button; | |
| 280 auto buttonEv = ev.xbutton; | |
| 281 switch(buttonEv.button) { | |
| 282 case 1: button = MouseButton.Left; break; | |
| 283 case 2: button = MouseButton.Middle; break; | |
| 284 case 3: button = MouseButton.Right; break; | |
| 285 default: return; | |
| 286 } | |
| 287 scope args = new MouseEventArgs(buttonEv.x+c._borderSize.left, buttonEv.y+c._borderSize.top, button); | |
| 288 func(args); | |
| 289 } | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
290 bool isKeyDown(uint keycode) { |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
291 ubyte[32] keys; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
292 XQueryKeymap(display, keys.ptr); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
293 return cast(bool)( (keys[keycode / 8] >> (keycode % 8)) & 1 ); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
294 } |
| 0 | 295 //}}} |
| 296 switch(ev.type) { | |
| 297 case MapNotify: | |
| 298 c.mapped = true; | |
| 299 break; | |
| 300 case UnmapNotify: | |
| 301 c.mapped = false; | |
| 302 break; | |
| 303 case DestroyNotify: | |
| 304 setControl(evWindow, null); | |
| 305 break; | |
| 306 case ClientMessage: | |
| 307 auto clientEv = ev.xclient; | |
| 308 if(clientEv.message_type != XA.WM_PROTOCOLS) | |
| 309 break; | |
| 310 if(clientEv.data.l[0] == XA.WM_DELETE_WINDOW) { | |
| 311 XDestroyWindow(evDisplay, evWindow); | |
| 312 return; // TODO: check event, and figure out what to do | |
| 313 } | |
| 314 break; | |
| 315 case KeyPress: | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
316 auto sym = XLookupKeysym(&ev.xkey, 0); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
317 if(sym == NoSymbol) |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
318 break; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
319 // Since X gives no way to tell if a KeyPress is generated by |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
320 // auto-repeat, prevKey is used here to tell. |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
321 auto k = KeysymToKey(sym); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
322 scope args = new KeyEventArgs(k, k == prevKey); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
323 prevKey = k; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
324 Control focused = c.focusedControl ? c.focusedControl : c; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
325 focused.keyDown(args); |
| 0 | 326 break; |
| 327 case KeyRelease: | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
328 // When X does auto-repeat for a held down key, it sends |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
329 // a KeyPress and KeyRelease every time, even though the key is |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
330 // down constantly. Here we check if the key is down, and if so, |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
331 // not send a keyUp event. |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
332 if(isKeyDown(ev.xkey.keycode)) |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
333 break; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
334 auto sym = XLookupKeysym(&ev.xkey, 0); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
335 if(sym == NoSymbol) |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
336 break; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
337 auto k = KeysymToKey(sym); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
338 if(k == prevKey) |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
339 prevKey = Key.None; // can't repeat after released |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
340 scope args = new KeyEventArgs(k, false); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
341 Control focused = c.focusedControl ? c.focusedControl : c; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
342 focused.keyUp(args); |
| 0 | 343 break; |
| 344 case ButtonPress: | |
|
32
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
345 // 4 = scroll up, 5 = scroll down |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
346 // 6 = scroll left, 7 = scroll right |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
347 auto b = ev.xbutton.button; |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
348 if(b == 4 || b == 5) { |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
349 scope args = new MouseTurnedEventArgs(b == 4 ? -3:3, false); |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
350 c.getDescendantAtPoint( |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
351 ev.xbutton.x+c._borderSize.left, |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
352 ev.xbutton.y+c._borderSize.top).mouseTurned(args); |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
353 break; |
|
b48d3f2f570d
Implement mouseTurned event with X.
Jordan Miner <jminer7@gmail.com>
parents:
25
diff
changeset
|
354 } |
| 0 | 355 createMouseEvent((MouseEventArgs args) { c.mouseDown(args); }); |
| 356 break; | |
| 357 case ButtonRelease: | |
| 358 createMouseEvent((MouseEventArgs args) { c.mouseUp(args); }); | |
| 359 break; | |
| 360 case MotionNotify: | |
| 361 auto motionEv = ev.xmotion; | |
| 362 Control captor = getCaptorControl(); | |
| 363 Point pt = Point(motionEv.x+c.borderSize.left, motionEv.y+c.borderSize.top); | |
| 364 if(captor) | |
| 365 pt = c.contentToContent(pt, captor); | |
| 366 else | |
| 367 captor = c; | |
| 368 scope args = new MouseEventArgs(pt.x, pt.y, MouseButton.None); | |
| 369 if(motionEv.state & | |
| 370 (Button1Mask | Button2Mask | Button3Mask)) { | |
| 371 captor.mouseDragged(args); | |
| 372 } else | |
| 373 captor.mouseMoved(args); | |
| 374 break; | |
| 375 case EnterNotify: | |
|
25
0577e8738dc8
Handle EnterNotify and LeaveNotify in the X backend,
Jordan Miner <jminer7@gmail.com>
parents:
24
diff
changeset
|
376 auto enterEv = ev.xcrossing; |
|
0577e8738dc8
Handle EnterNotify and LeaveNotify in the X backend,
Jordan Miner <jminer7@gmail.com>
parents:
24
diff
changeset
|
377 scope args = new MouseEventArgs(enterEv.x+c.borderSize.left, |
|
0577e8738dc8
Handle EnterNotify and LeaveNotify in the X backend,
Jordan Miner <jminer7@gmail.com>
parents:
24
diff
changeset
|
378 enterEv.y+c.borderSize.top, MouseButton.None); |
|
0577e8738dc8
Handle EnterNotify and LeaveNotify in the X backend,
Jordan Miner <jminer7@gmail.com>
parents:
24
diff
changeset
|
379 c.mouseMoved(args); |
| 0 | 380 break; |
| 381 case LeaveNotify: | |
|
25
0577e8738dc8
Handle EnterNotify and LeaveNotify in the X backend,
Jordan Miner <jminer7@gmail.com>
parents:
24
diff
changeset
|
382 setHotControl(null); |
| 0 | 383 break; |
| 384 case FocusIn: | |
| 385 break; | |
| 386 case FocusOut: | |
| 387 break; | |
| 388 case Expose: | |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
389 auto exposeEv = &ev.xexpose; |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
390 PaintQueue.add(c, exposeEv.x, exposeEv.y, exposeEv.width, exposeEv.height); |
| 0 | 391 break; |
| 392 case PropertyNotify: | |
| 393 auto propertyEv = ev.xproperty; | |
| 394 if(propertyEv.atom == XA._NET_FRAME_EXTENTS && | |
| 395 propertyEv.state != PropertyDelete) | |
| 396 c.backend_nativeToBorderSize(); | |
| 397 break; | |
| 398 case ConfigureNotify: | |
| 399 auto configureEv = ev.xconfigure; | |
| 400 c.repaint(); | |
| 401 c.backend_nativeToLocationSize(); | |
| 402 break; | |
| 403 case SelectionRequest: | |
| 404 auto selReqEv = ev.xselectionrequest; | |
| 405 XEvent fullEv; | |
| 406 auto selEv = &fullEv.xselection; | |
| 407 selEv.type = SelectionNotify; | |
| 408 selEv.requestor = selReqEv.requestor; | |
| 409 selEv.selection = selReqEv.selection; | |
| 410 selEv.target = selReqEv.target; | |
| 411 if(selReqEv.property != None) | |
| 412 selEv.property = selReqEv.property; | |
| 413 else | |
| 414 selEv.property = XA.DYNAMIN_SELECTION; | |
| 415 selEv.time = selReqEv.time; | |
| 416 Stdout.format("requestor: {}", selReqEv.requestor).newline; | |
| 417 Stdout.format("target: {}", selReqEv.target).newline; | |
| 418 ClipboardData* data; // change to array when supporting multiple | |
| 419 if(selReqEv.selection == XA.CLIPBOARD) | |
| 420 data = &Clipboard.data; | |
| 421 else if(selReqEv.selection == XA.PRIMARY) | |
| 422 data = &Selection.data; | |
| 423 else { | |
| 424 selEv.property = None; | |
| 425 XSendEvent(display, selEv.requestor, false, 0, &fullEv); | |
| 426 break; | |
| 427 } | |
| 428 if(selReqEv.target == XA.TARGETS) { | |
| 429 XChangeProperty(display, selEv.requestor, selEv.property, | |
| 430 selEv.target, 32, PropModeReplace, &data.target, 1); | |
| 431 XSendEvent(display, selEv.requestor, false, 0, &fullEv); | |
| 432 break; | |
| 433 } else if(selReqEv.target != data.target) { | |
| 434 selEv.property = None; | |
| 435 XSendEvent(display, selEv.requestor, false, 0, &fullEv); | |
| 436 break; | |
| 437 } | |
| 438 XChangeProperty(display, selEv.requestor, selEv.property, | |
| 439 data.target, 8, PropModeReplace, data.data, data.length); | |
| 440 XSendEvent(display, selEv.requestor, false, 0, &fullEv); | |
| 441 break; | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
442 case MappingNotify: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
443 XRefreshKeyboardMapping(&ev.xmapping); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
444 break; |
| 0 | 445 default: |
| 446 break; | |
| 447 } | |
| 448 } | |
| 449 } | |
|
18
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
450 void backend_invoke(void delegate() dg) { |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
451 // TODO: |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
452 } |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
453 void backend_invokeNow(void delegate() dg) { |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
454 // TODO: |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
455 } |
|
836a064828e8
Implement FileDialog/DirectoryDialog with GTK
Jordan Miner <jminer7@gmail.com>
parents:
0
diff
changeset
|
456 |
| 0 | 457 } |
| 458 //}}} | |
| 459 | |
|
24
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
460 //{{{ KeysymToKey() |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
461 Key KeysymToKey(int sym) { |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
462 switch(sym) { |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
463 case XK_parenright: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
464 case XK_0: return Key.D0; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
465 case XK_exclam: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
466 case XK_1: return Key.D1; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
467 case XK_at: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
468 case XK_2: return Key.D2; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
469 case XK_numbersign: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
470 case XK_3: return Key.D3; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
471 case XK_dollar: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
472 case XK_4: return Key.D4; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
473 case XK_percent: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
474 case XK_5: return Key.D5; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
475 case XK_asciicircum: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
476 case XK_6: return Key.D6; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
477 case XK_ampersand: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
478 case XK_7: return Key.D7; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
479 case XK_asterisk: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
480 case XK_8: return Key.D8; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
481 case XK_parenleft: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
482 case XK_9: return Key.D9; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
483 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
484 case XK_F1: return Key.F1; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
485 case XK_F2: return Key.F2; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
486 case XK_F3: return Key.F3; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
487 case XK_F4: return Key.F4; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
488 case XK_F5: return Key.F5; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
489 case XK_F6: return Key.F6; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
490 case XK_F7: return Key.F7; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
491 case XK_F8: return Key.F8; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
492 case XK_F9: return Key.F9; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
493 case XK_F10: return Key.F10; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
494 case XK_F11: return Key.F11; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
495 case XK_F12: return Key.F12; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
496 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
497 case XK_Escape: return Key.Escape; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
498 case XK_Tab: return Key.Tab; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
499 case XK_BackSpace: return Key.Backspace; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
500 case XK_Return: return Key.Enter; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
501 case XK_KP_Enter: return Key.Enter; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
502 case XK_space: return Key.Space; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
503 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
504 case XK_KP_Left: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
505 case XK_Left: return Key.Left; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
506 case XK_KP_Right: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
507 case XK_Right: return Key.Right; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
508 case XK_KP_Up: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
509 case XK_Up: return Key.Up; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
510 case XK_KP_Down: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
511 case XK_Down: return Key.Down; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
512 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
513 case XK_KP_Insert: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
514 case XK_Insert: return Key.Insert; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
515 case XK_KP_Delete: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
516 case XK_Delete: return Key.Delete; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
517 case XK_KP_Home: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
518 case XK_Home: return Key.Home; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
519 case XK_KP_End: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
520 case XK_End: return Key.End; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
521 case XK_KP_Prior: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
522 case XK_Prior: return Key.PageUp; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
523 case XK_KP_Next: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
524 case XK_Next: return Key.PageDown; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
525 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
526 case XK_Print: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
527 case XK_Sys_Req: return Key.PrintScreen; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
528 case XK_Pause: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
529 case XK_Break: return Key.Pause; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
530 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
531 case XK_Caps_Lock: return Key.CapsLock; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
532 case XK_Num_Lock: return Key.NumLock; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
533 case XK_Scroll_Lock: return Key.ScrollLock; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
534 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
535 case XK_KP_0: return Key.NumPad0; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
536 case XK_KP_1: return Key.NumPad1; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
537 case XK_KP_2: return Key.NumPad2; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
538 case XK_KP_3: return Key.NumPad3; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
539 case XK_KP_4: return Key.NumPad4; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
540 case XK_KP_5: return Key.NumPad5; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
541 case XK_KP_6: return Key.NumPad6; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
542 case XK_KP_7: return Key.NumPad7; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
543 case XK_KP_8: return Key.NumPad8; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
544 case XK_KP_9: return Key.NumPad9; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
545 case XK_KP_Divide: return Key.NumPadDivide; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
546 case XK_KP_Multiply: return Key.NumPadMultiply; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
547 case XK_KP_Subtract: return Key.NumPadSubtract; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
548 case XK_KP_Add: return Key.NumPadAdd; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
549 case XK_KP_Decimal: return Key.NumPadDecimal; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
550 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
551 case XK_grave: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
552 case XK_asciitilde: return Key.Backquote; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
553 case XK_minus: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
554 case XK_underscore: return Key.Minus; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
555 case XK_equal: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
556 case XK_plus: return Key.Equals; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
557 case XK_bracketleft: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
558 case XK_braceleft: return Key.OpenBracket; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
559 case XK_bracketright: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
560 case XK_braceright: return Key.CloseBracket; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
561 case XK_backslash: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
562 case XK_bar: return Key.Backslash; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
563 case XK_semicolon: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
564 case XK_colon: return Key.Semicolon; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
565 case XK_apostrophe: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
566 case XK_quotedbl: return Key.Quote; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
567 case XK_comma: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
568 case XK_less: return Key.Comma; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
569 case XK_period: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
570 case XK_greater: return Key.Period; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
571 case XK_slash: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
572 case XK_question: return Key.Slash; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
573 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
574 //case XK_Menu: return Key.Menu; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
575 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
576 case XK_Shift_L: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
577 case XK_Shift_R: return Key.Shift; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
578 case XK_Control_L: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
579 case XK_Control_R: return Key.Control; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
580 case XK_Alt_L: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
581 case XK_Alt_R: return Key.Alt; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
582 |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
583 //case XK_: return Key.; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
584 default: |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
585 if(sym >= 0x41 && sym <= 0x5A) // Key.A - Key.Z |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
586 return cast(Key)sym; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
587 if(sym >= 0x61 && sym <= 0x7A) // Key.A - Key.Z |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
588 return cast(Key)(sym-32); |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
589 return cast(Key)0; |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
590 } |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
591 } |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
592 //}}} |
|
43a88caead16
Implement keyDown and keyUp events with X.
Jordan Miner <jminer7@gmail.com>
parents:
23
diff
changeset
|
593 |
| 0 | 594 public import tango.stdc.time; |
| 595 template WindowBackend() { | |
| 596 invariant { | |
| 597 //if(_handle == 0) | |
| 598 // return; | |
| 599 //XWindow root, parent; | |
| 600 //XWindow* children; | |
| 601 //uint numChildren; | |
| 602 //XQueryTree(display, _handle, | |
| 603 // &root, &parent, &children, &numChildren); | |
| 604 //XFree(children); | |
| 605 //int x, y; | |
| 606 //XWindow child; | |
| 607 //XTranslateCoordinates(display, _handle, root, 0, 0, &x, &y, &child); | |
| 608 //assert(_location.X == x-_borderSize.Left); | |
| 609 //assert(_location.Y == y-_borderSize.Top); | |
| 610 //XWindowAttributes attribs; | |
| 611 //XGetWindowAttributes(display, _handle, &attribs); | |
| 612 } | |
| 613 XWindow _handle; | |
| 614 bool mapped = false; | |
| 615 bool backend_handleCreated() { return _handle > 0; } | |
| 616 void backend_recreateHandle() { | |
| 617 auto primaryScreenNum = XDefaultScreen(display); | |
| 618 //XColor color; | |
| 619 //color.red = 65535*backColor.R/255; | |
| 620 //color.green = 65535*backColor.G/255; | |
| 621 //color.blue = 65535*backColor.B/255; | |
| 622 //if(XAllocColor(display, XDefaultColormap(display, primaryScreenNum), &color)) | |
| 623 // printf("XAllocColor() failed\n"); | |
| 624 | |
| 625 XSetWindowAttributes attribs; | |
| 626 attribs.bit_gravity = NorthWestGravity; | |
| 627 // TODO: should be backColor, and should change when backColor changes | |
| 628 // call XSetWindowBackground() for this | |
| 629 attribs.background_pixel = XWhitePixel(display, primaryScreenNum); | |
| 630 attribs.event_mask = | |
| 631 KeyPressMask | | |
| 632 KeyReleaseMask | | |
| 633 ButtonPressMask | | |
| 634 ButtonReleaseMask | | |
| 635 EnterWindowMask | | |
| 636 LeaveWindowMask | | |
| 637 PointerMotionMask | | |
| 638 ButtonMotionMask | | |
| 639 ExposureMask | | |
| 640 FocusChangeMask | | |
| 641 StructureNotifyMask | | |
| 642 PropertyChangeMask; | |
| 643 XWindow newHandle = XCreateWindow( | |
| 644 display, root, | |
| 645 cast(int)x, cast(int)y, | |
| 646 backend_insideWidth, backend_insideHeight, | |
| 647 0, CopyFromParent, InputOutput, null, | |
| 648 CWBitGravity | CWBackPixel | CWEventMask, &attribs); | |
| 649 | |
| 650 setControl(newHandle, this); | |
| 651 auto protocols = [XA.WM_DELETE_WINDOW]; | |
| 652 XSetWMProtocols(display, newHandle, protocols.ptr, protocols.length); | |
| 653 if(handleCreated) { | |
| 654 XDestroyWindow(display, _handle); | |
| 655 XSync(display, false); | |
| 656 } | |
| 657 _handle = newHandle; | |
| 658 text = _text; // move the text over to the new window | |
| 659 visible = _visible; | |
| 660 borderStyle = _borderStyle; | |
| 661 //backend_nativeToBorderSize(); | |
| 662 } | |
| 663 Graphics backend_quickCreateGraphics() { | |
| 664 auto surface = cairo_xlib_surface_create(display, _handle, | |
| 665 XDefaultVisual(display, XDefaultScreen(display)), | |
| 666 cast(int)width, cast(int)height); | |
| 667 auto cr = cairo_create(surface); | |
| 668 cairo_surface_destroy(surface); | |
| 669 cairo_translate(cr, -borderSize.left, -borderSize.top); | |
| 670 auto g = new Graphics(cr); | |
| 671 cairo_destroy(cr); | |
| 672 return g; | |
| 673 } | |
| 674 void backend_visible(bool b) { | |
| 675 if(b) | |
| 676 // if not created, create the handle by calling handle() | |
| 677 XMapWindow(display, handle); | |
| 678 else | |
| 679 XUnmapWindow(display, _handle); | |
| 680 } | |
| 681 void backend_borderStyle(WindowBorderStyle border) { | |
| 682 backend_update_NET_WM_WINDOW_TYPE(); | |
| 683 backend_update_MOTIF_WM_HINTS(); | |
| 684 backend_nativeToBorderSize(); | |
| 685 } | |
|
23
d55b5b998412
Implement built-in mouse cursors with X.
Jordan Miner <jminer7@gmail.com>
parents:
18
diff
changeset
|
686 void backend_setCurrentCursor(Cursor cur) { |
|
d55b5b998412
Implement built-in mouse cursors with X.
Jordan Miner <jminer7@gmail.com>
parents:
18
diff
changeset
|
687 XDefineCursor(display, _handle, cur.handle); |
|
d55b5b998412
Implement built-in mouse cursors with X.
Jordan Miner <jminer7@gmail.com>
parents:
18
diff
changeset
|
688 } |
|
d55b5b998412
Implement built-in mouse cursors with X.
Jordan Miner <jminer7@gmail.com>
parents:
18
diff
changeset
|
689 |
| 0 | 690 void backend_repaint(Rect rect) { |
|
33
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
691 PaintQueue.add(this, |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
692 cast(int)(rect.x-borderSize.left), cast(int)(rect.y-borderSize.top), |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
693 cast(int)rect.width+1, cast(int)rect.height+1); |
|
329ce1001936
Refactor painting on X by using PaintQueue.
Jordan Miner <jminer7@gmail.com>
parents:
32
diff
changeset
|
694 //Stdout.format("invalidating x={}, y={}, width={}, height={}", rect.x, rect.y, rect.width, rect.height).newline; |
| 0 | 695 } |
| 696 void backend_resizable(bool b) { | |
| 697 backend_updateWM_NORMAL_HINTS(); | |
| 698 } | |
| 699 void backend_contentMinSizeChanged() { | |
| 700 backend_updateWM_NORMAL_HINTS(); | |
| 701 } | |
| 702 void backend_contentMaxSizeChanged() { | |
| 703 backend_updateWM_NORMAL_HINTS(); | |
| 704 } | |
| 705 void backend_location(Point pt) { | |
| 706 backend_updateWM_NORMAL_HINTS(); | |
| 707 backend_locationSizeToNative(); | |
| 708 } | |
| 709 void backend_size(Size size) { | |
| 710 backend_updateWM_NORMAL_HINTS(); | |
| 711 backend_locationSizeToNative(); | |
| 712 } | |
| 713 void backend_text(string str) { | |
| 714 //auto tmp = str.ToCharPtr(); | |
| 715 //XTextProperty strProperty; | |
| 716 //if(!XStringListToTextProperty(&tmp, 1, &strProperty)) | |
| 717 //printf("XStringListToTextProperty() failed - out of memory\n"); | |
| 718 //XSetWMName(display, _handle, &strProperty); | |
| 719 XChangeProperty(display, _handle, XA._NET_WM_NAME, XA.UTF8_STRING, 8, PropModeReplace, str.ptr, str.length); | |
| 720 } | |
| 721 //{{{ backend specific | |
| 722 void backend_updateWM_NORMAL_HINTS() { | |
| 723 XSizeHints* sizeHints = XAllocSizeHints(); | |
| 724 scope(exit) XFree(sizeHints); | |
| 725 sizeHints.flags = PMinSize | PMaxSize | PPosition | PSize; | |
| 726 if(resizable) { | |
| 727 sizeHints.min_width = cast(int)content.minWidth; | |
| 728 sizeHints.min_height = cast(int)content.minHeight; | |
| 729 sizeHints.max_width = | |
| 730 content.maxWidth > 0 ? cast(int)content.maxWidth : 30_000; | |
| 731 sizeHints.max_height = | |
| 732 content.maxHeight > 0 ? cast(int)content.maxHeight : 30_000; | |
| 733 } else { | |
| 734 sizeHints.min_width = sizeHints.max_width = backend_insideWidth; | |
| 735 sizeHints.min_height = sizeHints.max_height = backend_insideHeight; | |
| 736 } | |
| 737 sizeHints.x = cast(int)x; | |
| 738 sizeHints.y = cast(int)y; | |
| 739 sizeHints.width = backend_insideWidth; | |
| 740 sizeHints.height = backend_insideHeight; | |
| 741 XSetWMNormalHints(display, _handle, sizeHints); | |
| 742 } | |
| 743 void backend_update_MOTIF_WM_HINTS() { | |
| 744 int[4] mwmHints; | |
| 745 mwmHints[0] = 1 << 1; // flags | |
| 746 mwmHints[2] = borderStyle == WindowBorderStyle.None ? 0 : 1; // decor | |
| 747 XChangeProperty(display, _handle, | |
| 748 XA._MOTIF_WM_HINTS, XA._MOTIF_WM_HINTS, 32, PropModeReplace, mwmHints.ptr, mwmHints.length); | |
| 749 } | |
| 750 void backend_update_NET_WM_WINDOW_TYPE() { | |
| 751 XAtom[] atoms; | |
| 752 // with Metacity, the decor is not being repainted from normal>dialog | |
| 753 // because they are the same size | |
| 754 if(borderStyle == WindowBorderStyle.Dialog) | |
| 755 atoms = [XA._NET_WM_WINDOW_TYPE_DIALOG]; | |
| 756 else if(borderStyle == WindowBorderStyle.Tool) | |
| 757 atoms = [XA._NET_WM_WINDOW_TYPE_UTILITY]; | |
| 758 else | |
| 759 atoms = [XA._NET_WM_WINDOW_TYPE_NORMAL]; | |
| 760 XChangeProperty(display, _handle, | |
| 761 XA._NET_WM_WINDOW_TYPE, XA.ATOM, 32, PropModeReplace, atoms.ptr, atoms.length); | |
| 762 } | |
| 763 // returns what width the x window should be...not including borders | |
| 764 int backend_insideWidth() { | |
| 765 return cast(int)(size.width-borderSize.left-borderSize.right); | |
| 766 } | |
| 767 // returns what height the x window should be...not including borders | |
| 768 int backend_insideHeight() { | |
| 769 return cast(int)(size.height-borderSize.top-borderSize.bottom); | |
| 770 } | |
| 771 // applies the currently set location and size to the native X Window | |
| 772 void backend_locationSizeToNative() { | |
| 773 Point pt = _location; | |
| 774 if(!isTopLevelReparented(_handle)) { | |
| 775 pt.x = pt.x + _borderSize.left; | |
| 776 pt.y = pt.y + _borderSize.top; | |
| 777 } | |
| 778 XMoveResizeWindow(display, _handle, cast(int)pt.x, cast(int)pt.y, | |
| 779 backend_insideWidth, backend_insideHeight); | |
| 780 // XMoveWindow: | |
| 781 // Under Metacity, sets the location of the WM's frame. | |
| 782 // Under Compiz, sets the location of the window. | |
| 783 // XResizeWindow: | |
| 784 // Under Metacity and Compiz, sets the size of the window not | |
| 785 // including the WM's frame. | |
| 786 } | |
| 787 // sets location and size based on where the native X Window is | |
| 788 void backend_nativeToLocationSize() { | |
| 789 XWindow root, parent; | |
| 790 XWindow* children; | |
| 791 uint numChildren; | |
| 792 XQueryTree(display, _handle, | |
| 793 &root, &parent, &children, &numChildren); | |
| 794 XFree(children); | |
| 795 | |
| 796 int x, y; | |
| 797 XWindow child; | |
| 798 XTranslateCoordinates(display, _handle, root, 0, 0, &x, &y, &child); | |
| 799 _location.x = x - _borderSize.left; | |
| 800 _location.y = y - _borderSize.top; | |
| 801 scope args = new EventArgs; | |
| 802 moved(args); | |
| 803 XWindowAttributes attribs; | |
| 804 XGetWindowAttributes(display, _handle, &attribs); | |
| 805 _size.width = attribs.width+_borderSize.left+_borderSize.right; | |
| 806 _size.height = attribs.height+_borderSize.top+_borderSize.bottom; | |
| 807 resized(args); | |
| 808 | |
| 809 //content._location = Point(_borderSize.Left, _borderSize.Top); | |
| 810 //content._size = Size(attribs.width, attribs.height); | |
| 811 //Stdout.format("location updated to {}", _location).newline; | |
| 812 //Stdout.format("size updated to {}", _size).newline; | |
| 813 } | |
| 814 void backend_nativeToBorderSize() { | |
| 815 _borderSize = backend_getBorderSize(); | |
| 816 //Stdout("borderSize updated to ", _borderSize).newline; | |
| 817 backend_nativeToLocationSize(); | |
| 818 } | |
| 819 BorderSize backend_getBorderSize() { | |
| 820 if(!isWMPropertySupported(XA._NET_FRAME_EXTENTS) || | |
| 821 borderStyle == WindowBorderStyle.None) | |
| 822 return BorderSize(); | |
| 823 // create handle if necessary | |
| 824 auto reqHandle = handle; | |
| 825 bool requested = false; | |
| 826 | |
| 827 //{{{ requestExtents() | |
| 828 void requestExtents() { | |
| 829 if(isWMPropertySupported(XA._NET_REQUEST_FRAME_EXTENTS)) { | |
| 830 XEvent ev; | |
| 831 ev.xclient.type = ClientMessage; | |
| 832 ev.xclient.window = handle; | |
| 833 ev.xclient.message_type = XA._NET_REQUEST_FRAME_EXTENTS; | |
| 834 ev.xclient.format = 8; | |
| 835 XSendEvent(display, root, false, | |
| 836 SubstructureNotifyMask | SubstructureRedirectMask, &ev); | |
| 837 } else { // compiz and beryl do not yet support requesting | |
| 838 XSetWindowAttributes attribs; | |
| 839 reqHandle = XCreateWindow(display, | |
| 840 root, 0, 0, 1, 1, | |
| 841 0, CopyFromParent, InputOnly, null, 0, &attribs); | |
| 842 | |
| 843 XWMHints* hints = XAllocWMHints(); | |
| 844 scope(exit) XFree(hints); | |
| 845 hints.flags = InputHint; | |
| 846 hints.input = false; | |
| 847 XSetWMHints(display, reqHandle, hints); | |
| 848 | |
| 849 auto mainHandle = _handle; | |
| 850 _handle = reqHandle; | |
| 851 backend_updateWM_NORMAL_HINTS(); | |
| 852 backend_update_NET_WM_WINDOW_TYPE(); | |
| 853 backend_update_MOTIF_WM_HINTS(); | |
| 854 backend_visible = true; | |
| 855 backend_visible = false; | |
| 856 _handle = mainHandle; | |
| 857 } | |
| 858 requested = true; | |
| 859 } | |
| 860 //}}} | |
| 861 | |
| 862 if(!mapped) | |
| 863 requestExtents(); | |
| 864 int* extents; | |
| 865 while(true) { | |
| 866 XSync(display, false); | |
| 867 extents = cast(int*)getXWindowProperty(display, reqHandle, | |
| 868 XA._NET_FRAME_EXTENTS); | |
| 869 if(extents !is null) | |
| 870 break; | |
| 871 if(!requested) | |
| 872 requestExtents(); | |
| 873 } | |
| 874 scope(exit) XFree(extents); | |
| 875 if(reqHandle != _handle) | |
| 876 XDestroyWindow(display, reqHandle); | |
| 877 return BorderSize(extents[0], extents[2], extents[1], extents[3]); | |
| 878 } | |
| 879 //}}} | |
| 880 } | |
| 881 |