diff options
author | fluxgen <fluxgen> | 2002-11-14 00:23:19 (GMT) |
---|---|---|
committer | fluxgen <fluxgen> | 2002-11-14 00:23:19 (GMT) |
commit | e13cb99bd05db49f116b8f1a4925c034dfae60a2 (patch) | |
tree | e0645e213619d38ddadffaf22a11d6ec597e1630 | |
parent | cade394b91433589df935298ba0ea1562e4aee68 (diff) | |
download | fluxbox-e13cb99bd05db49f116b8f1a4925c034dfae60a2.zip fluxbox-e13cb99bd05db49f116b8f1a4925c034dfae60a2.tar.bz2 |
cleaning
-rw-r--r-- | src/Slit.cc | 711 |
1 files changed, 359 insertions, 352 deletions
diff --git a/src/Slit.cc b/src/Slit.cc index fe6711b..6aaea47 100644 --- a/src/Slit.cc +++ b/src/Slit.cc | |||
@@ -1,3 +1,6 @@ | |||
1 | // Slit.cc for fluxbox | ||
2 | // Copyright (c) 2002 Henrik Kinnunen (fluxgen at linuxmail.org) | ||
3 | // | ||
1 | // Slit.cc for Blackbox - an X11 Window manager | 4 | // Slit.cc for Blackbox - an X11 Window manager |
2 | // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net) | 5 | // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net) |
3 | // | 6 | // |
@@ -19,7 +22,7 @@ | |||
19 | // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | 22 | // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
20 | // DEALINGS IN THE SOFTWARE. | 23 | // DEALINGS IN THE SOFTWARE. |
21 | 24 | ||
22 | // $Id: Slit.cc,v 1.23 2002/10/29 15:59:35 fluxgen Exp $ | 25 | // $Id: Slit.cc,v 1.24 2002/11/14 00:23:19 fluxgen Exp $ |
23 | 26 | ||
24 | //use GNU extensions | 27 | //use GNU extensions |
25 | #ifndef _GNU_SOURCE | 28 | #ifndef _GNU_SOURCE |
@@ -32,8 +35,6 @@ | |||
32 | 35 | ||
33 | #ifdef SLIT | 36 | #ifdef SLIT |
34 | 37 | ||
35 | #include <X11/keysym.h> | ||
36 | |||
37 | #include "i18n.hh" | 38 | #include "i18n.hh" |
38 | #include "fluxbox.hh" | 39 | #include "fluxbox.hh" |
39 | #include "Image.hh" | 40 | #include "Image.hh" |
@@ -50,57 +51,64 @@ | |||
50 | # include <sys/stat.h> | 51 | # include <sys/stat.h> |
51 | #endif // HAVE_SYS_STAT_H | 52 | #endif // HAVE_SYS_STAT_H |
52 | 53 | ||
54 | #include <X11/keysym.h> | ||
53 | 55 | ||
54 | // Utility method for extracting name from window | 56 | // Utility method for extracting name from window |
55 | namespace { | 57 | namespace { |
56 | void getWMName(BScreen *screen, Window window, std::string& name) { | 58 | |
57 | name = ""; | 59 | void getWMName(BScreen *screen, Window window, std::string& name) { |
58 | 60 | name = ""; | |
59 | if (screen != 0 && window != None) { | 61 | |
60 | Display *display = screen->getBaseDisplay()->getXDisplay(); | 62 | if (screen == 0 || window == None) |
61 | 63 | return; | |
62 | XTextProperty text_prop; | 64 | |
63 | char **list; | 65 | Display *display = BaseDisplay::getXDisplay(); |
64 | int num; | 66 | |
65 | I18n *i18n = I18n::instance(); | 67 | XTextProperty text_prop; |
66 | 68 | char **list; | |
67 | if (XGetWMName(display, window, &text_prop)) { | 69 | int num; |
68 | if (text_prop.value && text_prop.nitems > 0) { | 70 | I18n *i18n = I18n::instance(); |
69 | if (text_prop.encoding != XA_STRING) { | 71 | |
70 | 72 | if (XGetWMName(display, window, &text_prop)) { | |
71 | text_prop.nitems = strlen((char *) text_prop.value); | 73 | if (text_prop.value && text_prop.nitems > 0) { |
72 | 74 | if (text_prop.encoding != XA_STRING) { | |
73 | if ((XmbTextPropertyToTextList(display, &text_prop, | 75 | |
74 | &list, &num) == Success) && | 76 | text_prop.nitems = strlen((char *) text_prop.value); |
75 | (num > 0) && *list) { | 77 | |
76 | name = static_cast<char *>(*list); | 78 | if ((XmbTextPropertyToTextList(display, &text_prop, |
77 | XFreeStringList(list); | 79 | &list, &num) == Success) && |
78 | } else | 80 | (num > 0) && *list) { |
79 | name = (char *)text_prop.value; | 81 | name = static_cast<char *>(*list); |
80 | 82 | XFreeStringList(list); | |
81 | } else | ||
82 | name = (char *)text_prop.value; | ||
83 | } else | 83 | } else |
84 | name = i18n->getMessage( | 84 | name = (char *)text_prop.value; |
85 | FBNLS::WindowSet, FBNLS::WindowUnnamed, | 85 | |
86 | "Unnamed"); | 86 | } else |
87 | } else { | 87 | name = (char *)text_prop.value; |
88 | name = i18n->getMessage( | 88 | } else { // default name |
89 | FBNLS::WindowSet, FBNLS::WindowUnnamed, | 89 | name = i18n->getMessage( |
90 | "Unnamed"); | 90 | FBNLS::WindowSet, FBNLS::WindowUnnamed, |
91 | } | 91 | "Unnamed"); |
92 | } | 92 | } |
93 | } else { | ||
94 | // default name | ||
95 | name = i18n->getMessage( | ||
96 | FBNLS::WindowSet, FBNLS::WindowUnnamed, | ||
97 | "Unnamed"); | ||
93 | } | 98 | } |
99 | |||
100 | } | ||
101 | |||
94 | }; // End anonymous namespace | 102 | }; // End anonymous namespace |
95 | 103 | ||
96 | Slit::Slit(BScreen *scr):screen(scr), timer(this), slitmenu(*this) { | 104 | Slit::Slit(BScreen *scr):m_screen(scr), timer(this), slitmenu(*this) { |
97 | assert(scr); | 105 | assert(scr); |
98 | fluxbox = Fluxbox::instance(); | 106 | Fluxbox * const fluxbox = Fluxbox::instance(); |
99 | 107 | ||
100 | on_top = screen->isSlitOnTop(); | 108 | on_top = screen()->isSlitOnTop(); |
101 | hidden = do_auto_hide = screen->doSlitAutoHide(); | 109 | hidden = do_auto_hide = screen()->doSlitAutoHide(); |
102 | 110 | ||
103 | display = screen->getBaseDisplay()->getXDisplay(); | 111 | |
104 | frame.window = frame.pixmap = None; | 112 | frame.window = frame.pixmap = None; |
105 | 113 | ||
106 | 114 | ||
@@ -112,8 +120,8 @@ Slit::Slit(BScreen *scr):screen(scr), timer(this), slitmenu(*this) { | |||
112 | CWColormap | CWOverrideRedirect | CWEventMask; | 120 | CWColormap | CWOverrideRedirect | CWEventMask; |
113 | attrib.background_pixmap = None; | 121 | attrib.background_pixmap = None; |
114 | attrib.background_pixel = attrib.border_pixel = | 122 | attrib.background_pixel = attrib.border_pixel = |
115 | screen->getBorderColor()->pixel(); | 123 | screen()->getBorderColor()->pixel(); |
116 | attrib.colormap = screen->colormap(); | 124 | attrib.colormap = screen()->colormap(); |
117 | attrib.override_redirect = True; | 125 | attrib.override_redirect = True; |
118 | attrib.event_mask = SubstructureRedirectMask | ButtonPressMask | | 126 | attrib.event_mask = SubstructureRedirectMask | ButtonPressMask | |
119 | EnterWindowMask | LeaveWindowMask; | 127 | EnterWindowMask | LeaveWindowMask; |
@@ -122,9 +130,9 @@ Slit::Slit(BScreen *scr):screen(scr), timer(this), slitmenu(*this) { | |||
122 | frame.width = frame.height = 1; | 130 | frame.width = frame.height = 1; |
123 | 131 | ||
124 | frame.window = | 132 | frame.window = |
125 | XCreateWindow(display, screen->getRootWindow(), frame.x, frame.y, | 133 | XCreateWindow(BaseDisplay::getXDisplay(), screen()->getRootWindow(), frame.x, frame.y, |
126 | frame.width, frame.height, screen->getBorderWidth(), | 134 | frame.width, frame.height, screen()->getBorderWidth(), |
127 | screen->getDepth(), InputOutput, screen->getVisual(), | 135 | screen()->getDepth(), InputOutput, screen()->getVisual(), |
128 | create_mask, &attrib); | 136 | create_mask, &attrib); |
129 | fluxbox->saveSlitSearch(frame.window, this); | 137 | fluxbox->saveSlitSearch(frame.window, this); |
130 | 138 | ||
@@ -136,15 +144,11 @@ Slit::Slit(BScreen *scr):screen(scr), timer(this), slitmenu(*this) { | |||
136 | 144 | ||
137 | 145 | ||
138 | Slit::~Slit() { | 146 | Slit::~Slit() { |
139 | fluxbox->grab(); | 147 | screen()->getImageControl()->removeImage(frame.pixmap); |
140 | |||
141 | screen->getImageControl()->removeImage(frame.pixmap); | ||
142 | 148 | ||
143 | fluxbox->removeSlitSearch(frame.window); | 149 | Fluxbox::instance()->removeSlitSearch(frame.window); |
144 | 150 | ||
145 | XDestroyWindow(display, frame.window); | 151 | XDestroyWindow(BaseDisplay::getXDisplay(), frame.window); |
146 | |||
147 | fluxbox->ungrab(); | ||
148 | } | 152 | } |
149 | 153 | ||
150 | 154 | ||
@@ -153,133 +157,132 @@ void Slit::addClient(Window w) { | |||
153 | if (w == None) | 157 | if (w == None) |
154 | return; | 158 | return; |
155 | 159 | ||
156 | fluxbox->grab(); | 160 | if (!Fluxbox::instance()->validateWindow(w)) |
157 | if (fluxbox->validateWindow(w)) { | 161 | return; |
158 | // Look for slot in client list by name | 162 | |
159 | SlitClient *client = 0; | 163 | // Look for slot in client list by name |
160 | std::string match_name; | 164 | SlitClient *client = 0; |
161 | ::getWMName(screen, w, match_name); | 165 | std::string match_name; |
162 | SlitClients::iterator it = clientList.begin(); | 166 | ::getWMName(screen(), w, match_name); |
163 | SlitClients::iterator it_end = clientList.end(); | 167 | SlitClients::iterator it = clientList.begin(); |
164 | bool found_match = false; | 168 | SlitClients::iterator it_end = clientList.end(); |
165 | for (; it != it_end; ++it) { | 169 | bool found_match = false; |
166 | // If the name matches... | 170 | for (; it != it_end; ++it) { |
167 | if ((*it)->match_name == match_name) { | 171 | // If the name matches... |
168 | // Use the slot if no window is assigned | 172 | if ((*it)->match_name == match_name) { |
169 | if ((*it)->window == None) { | 173 | // Use the slot if no window is assigned |
170 | client = (*it); | 174 | if ((*it)->window == None) { |
171 | client->initialize(screen, w); | 175 | client = (*it); |
172 | break; | 176 | client->initialize(screen(), w); |
173 | } | ||
174 | // Otherwise keep looking for an unused match or a non-match | ||
175 | found_match = true; // Possibly redundant | ||
176 | |||
177 | } else if (found_match) { | ||
178 | // Insert before first non-match after a previously found match? | ||
179 | client = new SlitClient(screen, w); | ||
180 | clientList.insert(it, client); | ||
181 | break; | 177 | break; |
182 | } | 178 | } |
179 | // Otherwise keep looking for an unused match or a non-match | ||
180 | found_match = true; // Possibly redundant | ||
181 | |||
182 | } else if (found_match) { | ||
183 | // Insert before first non-match after a previously found match? | ||
184 | client = new SlitClient(screen(), w); | ||
185 | clientList.insert(it, client); | ||
186 | break; | ||
183 | } | 187 | } |
184 | // Append to client list? | 188 | } |
185 | if (client == 0) { | 189 | // Append to client list? |
186 | client = new SlitClient(screen, w); | 190 | if (client == 0) { |
187 | clientList.push_back(client); | 191 | client = new SlitClient(screen(), w); |
188 | } | 192 | clientList.push_back(client); |
189 | 193 | } | |
190 | XWMHints *wmhints = XGetWMHints(display, w); | 194 | Display *disp = BaseDisplay::getXDisplay(); |
191 | 195 | XWMHints *wmhints = XGetWMHints(disp, w); | |
192 | if (wmhints) { | 196 | |
193 | if ((wmhints->flags & IconWindowHint) && | 197 | if (wmhints) { |
194 | (wmhints->icon_window != None)) { | 198 | if ((wmhints->flags & IconWindowHint) && |
195 | XMoveWindow(display, client->client_window, screen->getWidth() + 10, | 199 | (wmhints->icon_window != None)) { |
196 | screen->getHeight() + 10); | 200 | XMoveWindow(disp, client->client_window, screen()->getWidth() + 10, |
197 | XMapWindow(display, client->client_window); | 201 | screen()->getHeight() + 10); |
198 | client->icon_window = wmhints->icon_window; | 202 | XMapWindow(disp, client->client_window); |
199 | client->window = client->icon_window; | 203 | client->icon_window = wmhints->icon_window; |
200 | } else { | 204 | client->window = client->icon_window; |
201 | client->icon_window = None; | ||
202 | client->window = client->client_window; | ||
203 | } | ||
204 | |||
205 | XFree(wmhints); | ||
206 | } else { | 205 | } else { |
207 | client->icon_window = None; | 206 | client->icon_window = None; |
208 | client->window = client->client_window; | 207 | client->window = client->client_window; |
209 | } | 208 | } |
210 | XWindowAttributes attrib; | 209 | |
211 | #ifdef KDE | 210 | XFree(wmhints); |
212 | //Check and see if new client is a KDE dock applet | 211 | } else { |
213 | //If so force reasonable size | 212 | client->icon_window = None; |
214 | bool iskdedockapp=false; | 213 | client->window = client->client_window; |
215 | Atom ajunk; | 214 | } |
216 | int ijunk; | 215 | XWindowAttributes attrib; |
217 | unsigned long *data = (unsigned long *) 0, uljunk; | 216 | #ifdef KDE |
218 | 217 | //Check and see if new client is a KDE dock applet | |
219 | // Check if KDE v2.x dock applet | 218 | //If so force reasonable size |
220 | if (XGetWindowProperty(fluxbox->getXDisplay(), w, | 219 | bool iskdedockapp=false; |
221 | fluxbox->getKWM2DockwindowAtom(), 0l, 1l, False, | 220 | Atom ajunk; |
222 | fluxbox->getKWM2DockwindowAtom(), | 221 | int ijunk; |
222 | unsigned long *data = (unsigned long *) 0, uljunk; | ||
223 | |||
224 | // Check if KDE v2.x dock applet | ||
225 | if (XGetWindowProperty(disp, w, | ||
226 | fluxbox->getKWM2DockwindowAtom(), 0l, 1l, False, | ||
227 | fluxbox->getKWM2DockwindowAtom(), | ||
228 | &ajunk, &ijunk, &uljunk, &uljunk, | ||
229 | (unsigned char **) &data) == Success) { | ||
230 | iskdedockapp = (data && data[0] != 0); | ||
231 | XFree((char *) data); | ||
232 | } | ||
233 | |||
234 | // Check if KDE v1.x dock applet | ||
235 | if (!iskdedockapp) { | ||
236 | if (XGetWindowProperty(disp, w, | ||
237 | fluxbox->getKWM1DockwindowAtom(), 0l, 1l, False, | ||
238 | fluxbox->getKWM1DockwindowAtom(), | ||
223 | &ajunk, &ijunk, &uljunk, &uljunk, | 239 | &ajunk, &ijunk, &uljunk, &uljunk, |
224 | (unsigned char **) &data) == Success) { | 240 | (unsigned char **) &data) == Success) { |
225 | iskdedockapp = (data && data[0] != 0); | 241 | iskdedockapp = (data && data[0] != 0); |
226 | XFree((char *) data); | 242 | XFree((char *) data); |
227 | } | 243 | } |
228 | 244 | } | |
229 | // Check if KDE v1.x dock applet | ||
230 | if (!iskdedockapp) { | ||
231 | if (XGetWindowProperty(fluxbox->getXDisplay(), w, | ||
232 | fluxbox->getKWM1DockwindowAtom(), 0l, 1l, False, | ||
233 | fluxbox->getKWM1DockwindowAtom(), | ||
234 | &ajunk, &ijunk, &uljunk, &uljunk, | ||
235 | (unsigned char **) &data) == Success) { | ||
236 | iskdedockapp = (data && data[0] != 0); | ||
237 | XFree((char *) data); | ||
238 | } | ||
239 | } | ||
240 | 245 | ||
241 | if (iskdedockapp) | 246 | if (iskdedockapp) |
242 | client->width = client->height = 24; | 247 | client->width = client->height = 24; |
243 | else | 248 | else |
244 | #endif // KDE | 249 | #endif // KDE |
245 | { | 250 | { |
246 | if (XGetWindowAttributes(display, client->window, &attrib)) { | 251 | if (XGetWindowAttributes(disp, client->window, &attrib)) { |
247 | client->width = attrib.width; | 252 | client->width = attrib.width; |
248 | client->height = attrib.height; | 253 | client->height = attrib.height; |
249 | } else { | 254 | } else { |
250 | client->width = client->height = 64; | 255 | client->width = client->height = 64; |
251 | } | ||
252 | } | 256 | } |
257 | } | ||
253 | 258 | ||
254 | XSetWindowBorderWidth(display, client->window, 0); | 259 | XSetWindowBorderWidth(disp, client->window, 0); |
255 | 260 | ||
256 | XSelectInput(display, frame.window, NoEventMask); | 261 | XSelectInput(disp, frame.window, NoEventMask); |
257 | XSelectInput(display, client->window, NoEventMask); | 262 | XSelectInput(disp, client->window, NoEventMask); |
258 | 263 | ||
259 | XReparentWindow(display, client->window, frame.window, 0, 0); | 264 | XReparentWindow(disp, client->window, frame.window, 0, 0); |
260 | XMapRaised(display, client->window); | 265 | XMapRaised(disp, client->window); |
261 | XChangeSaveSet(display, client->window, SetModeInsert); | 266 | XChangeSaveSet(disp, client->window, SetModeInsert); |
262 | 267 | ||
263 | XSelectInput(display, frame.window, SubstructureRedirectMask | | 268 | XSelectInput(disp, frame.window, SubstructureRedirectMask | |
264 | ButtonPressMask | EnterWindowMask | LeaveWindowMask); | 269 | ButtonPressMask | EnterWindowMask | LeaveWindowMask); |
265 | XSelectInput(display, client->window, StructureNotifyMask | | 270 | XSelectInput(disp, client->window, StructureNotifyMask | |
266 | SubstructureNotifyMask | EnterWindowMask); | 271 | SubstructureNotifyMask | EnterWindowMask); |
267 | XFlush(display); | 272 | XFlush(disp); |
268 | 273 | ||
269 | fluxbox->saveSlitSearch(client->client_window, this); | 274 | Fluxbox::instance()->saveSlitSearch(client->client_window, this); |
270 | fluxbox->saveSlitSearch(client->icon_window, this); | 275 | Fluxbox::instance()->saveSlitSearch(client->icon_window, this); |
271 | reconfigure(); | 276 | reconfigure(); |
272 | 277 | ||
273 | saveClientList(); | 278 | saveClientList(); |
274 | } | ||
275 | 279 | ||
276 | fluxbox->ungrab(); | ||
277 | } | 280 | } |
278 | 281 | ||
279 | 282 | ||
280 | void Slit::removeClient(SlitClient *client, bool remap, bool destroy) { | 283 | void Slit::removeClient(SlitClient *client, bool remap, bool destroy) { |
281 | fluxbox->removeSlitSearch(client->client_window); | 284 | Fluxbox::instance()->removeSlitSearch(client->client_window); |
282 | fluxbox->removeSlitSearch(client->icon_window); | 285 | Fluxbox::instance()->removeSlitSearch(client->icon_window); |
283 | 286 | ||
284 | // Destructive removal? | 287 | // Destructive removal? |
285 | if (destroy) | 288 | if (destroy) |
@@ -287,17 +290,18 @@ void Slit::removeClient(SlitClient *client, bool remap, bool destroy) { | |||
287 | else // Clear the window info, but keep around to help future sorting? | 290 | else // Clear the window info, but keep around to help future sorting? |
288 | client->initialize(); | 291 | client->initialize(); |
289 | 292 | ||
290 | screen->removeNetizen(client->window); | 293 | screen()->removeNetizen(client->window); |
291 | 294 | ||
292 | if (remap && fluxbox->validateWindow(client->window)) { | 295 | if (remap && Fluxbox::instance()->validateWindow(client->window)) { |
293 | XSelectInput(display, frame.window, NoEventMask); | 296 | Display *disp = BaseDisplay::getXDisplay(); |
294 | XSelectInput(display, client->window, NoEventMask); | 297 | XSelectInput(disp, frame.window, NoEventMask); |
295 | XReparentWindow(display, client->window, screen->getRootWindow(), | 298 | XSelectInput(disp, client->window, NoEventMask); |
299 | XReparentWindow(disp, client->window, screen()->getRootWindow(), | ||
296 | client->x, client->y); | 300 | client->x, client->y); |
297 | XChangeSaveSet(display, client->window, SetModeDelete); | 301 | XChangeSaveSet(disp, client->window, SetModeDelete); |
298 | XSelectInput(display, frame.window, SubstructureRedirectMask | | 302 | XSelectInput(disp, frame.window, SubstructureRedirectMask | |
299 | ButtonPressMask | EnterWindowMask | LeaveWindowMask); | 303 | ButtonPressMask | EnterWindowMask | LeaveWindowMask); |
300 | XFlush(display); | 304 | XFlush(disp); |
301 | } | 305 | } |
302 | 306 | ||
303 | // Destructive removal? | 307 | // Destructive removal? |
@@ -307,7 +311,6 @@ void Slit::removeClient(SlitClient *client, bool remap, bool destroy) { | |||
307 | 311 | ||
308 | 312 | ||
309 | void Slit::removeClient(Window w, bool remap) { | 313 | void Slit::removeClient(Window w, bool remap) { |
310 | fluxbox->grab(); | ||
311 | 314 | ||
312 | bool reconf = false; | 315 | bool reconf = false; |
313 | 316 | ||
@@ -321,13 +324,13 @@ void Slit::removeClient(Window w, bool remap) { | |||
321 | break; | 324 | break; |
322 | } | 325 | } |
323 | } | 326 | } |
324 | if (reconf) reconfigure(); | 327 | if (reconf) |
328 | reconfigure(); | ||
325 | 329 | ||
326 | fluxbox->ungrab(); | ||
327 | } | 330 | } |
328 | 331 | ||
329 | 332 | ||
330 | void Slit::reconfigure(void) { | 333 | void Slit::reconfigure() { |
331 | frame.width = 0; | 334 | frame.width = 0; |
332 | frame.height = 0; | 335 | frame.height = 0; |
333 | 336 | ||
@@ -335,8 +338,8 @@ void Slit::reconfigure(void) { | |||
335 | // actually correspond to mapped windows. | 338 | // actually correspond to mapped windows. |
336 | int num_windows = 0; | 339 | int num_windows = 0; |
337 | 340 | ||
338 | switch (screen->getSlitDirection()) { | 341 | switch (screen()->getSlitDirection()) { |
339 | case VERTICAL: | 342 | case VERTICAL: |
340 | { | 343 | { |
341 | SlitClients::iterator it = clientList.begin(); | 344 | SlitClients::iterator it = clientList.begin(); |
342 | SlitClients::iterator it_end = clientList.end(); | 345 | SlitClients::iterator it_end = clientList.end(); |
@@ -344,7 +347,7 @@ void Slit::reconfigure(void) { | |||
344 | //client created window? | 347 | //client created window? |
345 | if ((*it)->window != None) { | 348 | if ((*it)->window != None) { |
346 | num_windows++; | 349 | num_windows++; |
347 | frame.height += (*it)->height + screen->getBevelWidth(); | 350 | frame.height += (*it)->height + screen()->getBevelWidth(); |
348 | 351 | ||
349 | //frame width < client window? | 352 | //frame width < client window? |
350 | if (frame.width < (*it)->width) | 353 | if (frame.width < (*it)->width) |
@@ -356,16 +359,16 @@ void Slit::reconfigure(void) { | |||
356 | if (frame.width < 1) | 359 | if (frame.width < 1) |
357 | frame.width = 1; | 360 | frame.width = 1; |
358 | else | 361 | else |
359 | frame.width += (screen->getBevelWidth() * 2); | 362 | frame.width += (screen()->getBevelWidth() * 2); |
360 | 363 | ||
361 | if (frame.height < 1) | 364 | if (frame.height < 1) |
362 | frame.height = 1; | 365 | frame.height = 1; |
363 | else | 366 | else |
364 | frame.height += screen->getBevelWidth(); | 367 | frame.height += screen()->getBevelWidth(); |
365 | 368 | ||
366 | break; | 369 | break; |
367 | 370 | ||
368 | case HORIZONTAL: | 371 | case HORIZONTAL: |
369 | { | 372 | { |
370 | SlitClients::iterator it = clientList.begin(); | 373 | SlitClients::iterator it = clientList.begin(); |
371 | SlitClients::iterator it_end = clientList.end(); | 374 | SlitClients::iterator it_end = clientList.end(); |
@@ -373,7 +376,7 @@ void Slit::reconfigure(void) { | |||
373 | //client created window? | 376 | //client created window? |
374 | if ((*it)->window != None) { | 377 | if ((*it)->window != None) { |
375 | num_windows++; | 378 | num_windows++; |
376 | frame.width += (*it)->width + screen->getBevelWidth(); | 379 | frame.width += (*it)->width + screen()->getBevelWidth(); |
377 | //frame height < client height? | 380 | //frame height < client height? |
378 | if (frame.height < (*it)->height) | 381 | if (frame.height < (*it)->height) |
379 | frame.height = (*it)->height; | 382 | frame.height = (*it)->height; |
@@ -384,51 +387,52 @@ void Slit::reconfigure(void) { | |||
384 | if (frame.width < 1) | 387 | if (frame.width < 1) |
385 | frame.width = 1; | 388 | frame.width = 1; |
386 | else | 389 | else |
387 | frame.width += screen->getBevelWidth(); | 390 | frame.width += screen()->getBevelWidth(); |
388 | 391 | ||
389 | if (frame.height < 1) | 392 | if (frame.height < 1) |
390 | frame.height = 1; | 393 | frame.height = 1; |
391 | else | 394 | else |
392 | frame.height += (screen->getBevelWidth() * 2); | 395 | frame.height += (screen()->getBevelWidth() * 2); |
393 | 396 | ||
394 | break; | 397 | break; |
395 | } | 398 | } |
396 | 399 | ||
397 | reposition(); | 400 | reposition(); |
401 | Display *disp = BaseDisplay::getXDisplay(); | ||
398 | 402 | ||
399 | XSetWindowBorderWidth(display ,frame.window, screen->getBorderWidth()); | 403 | XSetWindowBorderWidth(disp, frame.window, screen()->getBorderWidth()); |
400 | XSetWindowBorder(display, frame.window, | 404 | XSetWindowBorder(disp, frame.window, |
401 | screen->getBorderColor()->pixel()); | 405 | screen()->getBorderColor()->pixel()); |
402 | 406 | ||
403 | //did we actually use slit slots | 407 | //did we actually use slit slots |
404 | if (num_windows == 0) | 408 | if (num_windows == 0) |
405 | XUnmapWindow(display, frame.window); | 409 | XUnmapWindow(disp, frame.window); |
406 | else | 410 | else |
407 | XMapWindow(display, frame.window); | 411 | XMapWindow(disp, frame.window); |
408 | 412 | ||
409 | Pixmap tmp = frame.pixmap; | 413 | Pixmap tmp = frame.pixmap; |
410 | BImageControl *image_ctrl = screen->getImageControl(); | 414 | BImageControl *image_ctrl = screen()->getImageControl(); |
411 | const FbTk::Texture *texture = &(screen->getTheme()->getSlitTexture()); | 415 | const FbTk::Texture *texture = &(screen()->getTheme()->getSlitTexture()); |
412 | if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { | 416 | if (texture->type() == (FbTk::Texture::FLAT | FbTk::Texture::SOLID)) { |
413 | frame.pixmap = None; | 417 | frame.pixmap = None; |
414 | XSetWindowBackground(display, frame.window, | 418 | XSetWindowBackground(disp, frame.window, |
415 | texture->color().pixel()); | 419 | texture->color().pixel()); |
416 | } else { | 420 | } else { |
417 | frame.pixmap = image_ctrl->renderImage(frame.width, frame.height, | 421 | frame.pixmap = image_ctrl->renderImage(frame.width, frame.height, |
418 | texture); | 422 | texture); |
419 | XSetWindowBackgroundPixmap(display, frame.window, frame.pixmap); | 423 | XSetWindowBackgroundPixmap(disp, frame.window, frame.pixmap); |
420 | } | 424 | } |
421 | 425 | ||
422 | if (tmp) | 426 | if (tmp) |
423 | image_ctrl->removeImage(tmp); | 427 | image_ctrl->removeImage(tmp); |
424 | XClearWindow(display, frame.window); | 428 | XClearWindow(disp, frame.window); |
425 | 429 | ||
426 | int x, y; | 430 | int x, y; |
427 | 431 | ||
428 | switch (screen->getSlitDirection()) { | 432 | switch (screen()->getSlitDirection()) { |
429 | case VERTICAL: | 433 | case VERTICAL: |
430 | x = 0; | 434 | x = 0; |
431 | y = screen->getBevelWidth(); | 435 | y = screen()->getBevelWidth(); |
432 | 436 | ||
433 | { | 437 | { |
434 | SlitClients::iterator it = clientList.begin(); | 438 | SlitClients::iterator it = clientList.begin(); |
@@ -439,10 +443,10 @@ void Slit::reconfigure(void) { | |||
439 | continue; | 443 | continue; |
440 | 444 | ||
441 | x = (frame.width - (*it)->width) / 2; | 445 | x = (frame.width - (*it)->width) / 2; |
442 | 446 | Display *disp = BaseDisplay::getXDisplay(); | |
443 | XMoveResizeWindow(display, (*it)->window, x, y, | 447 | XMoveResizeWindow(disp, (*it)->window, x, y, |
444 | (*it)->width, (*it)->height); | 448 | (*it)->width, (*it)->height); |
445 | XMapWindow(display, (*it)->window); | 449 | XMapWindow(disp, (*it)->window); |
446 | 450 | ||
447 | // for ICCCM compliance | 451 | // for ICCCM compliance |
448 | (*it)->x = x; | 452 | (*it)->x = x; |
@@ -451,7 +455,7 @@ void Slit::reconfigure(void) { | |||
451 | XEvent event; | 455 | XEvent event; |
452 | event.type = ConfigureNotify; | 456 | event.type = ConfigureNotify; |
453 | 457 | ||
454 | event.xconfigure.display = display; | 458 | event.xconfigure.display = disp; |
455 | event.xconfigure.event = (*it)->window; | 459 | event.xconfigure.event = (*it)->window; |
456 | event.xconfigure.window = (*it)->window; | 460 | event.xconfigure.window = (*it)->window; |
457 | event.xconfigure.x = x; | 461 | event.xconfigure.x = x; |
@@ -462,17 +466,17 @@ void Slit::reconfigure(void) { | |||
462 | event.xconfigure.above = frame.window; | 466 | event.xconfigure.above = frame.window; |
463 | event.xconfigure.override_redirect = False; | 467 | event.xconfigure.override_redirect = False; |
464 | 468 | ||
465 | XSendEvent(display, (*it)->window, False, StructureNotifyMask, | 469 | XSendEvent(disp, (*it)->window, False, StructureNotifyMask, |
466 | &event); | 470 | &event); |
467 | 471 | ||
468 | y += (*it)->height + screen->getBevelWidth(); | 472 | y += (*it)->height + screen()->getBevelWidth(); |
469 | } | 473 | } |
470 | } | 474 | } |
471 | 475 | ||
472 | break; | 476 | break; |
473 | 477 | ||
474 | case HORIZONTAL: | 478 | case HORIZONTAL: |
475 | x = screen->getBevelWidth(); | 479 | x = screen()->getBevelWidth(); |
476 | y = 0; | 480 | y = 0; |
477 | 481 | ||
478 | { | 482 | { |
@@ -485,9 +489,9 @@ void Slit::reconfigure(void) { | |||
485 | 489 | ||
486 | y = (frame.height - (*it)->height) / 2; | 490 | y = (frame.height - (*it)->height) / 2; |
487 | 491 | ||
488 | XMoveResizeWindow(display, (*it)->window, x, y, | 492 | XMoveResizeWindow(disp, (*it)->window, x, y, |
489 | (*it)->width, (*it)->height); | 493 | (*it)->width, (*it)->height); |
490 | XMapWindow(display, (*it)->window); | 494 | XMapWindow(disp, (*it)->window); |
491 | 495 | ||
492 | // for ICCCM compliance | 496 | // for ICCCM compliance |
493 | (*it)->x = x; | 497 | (*it)->x = x; |
@@ -496,21 +500,21 @@ void Slit::reconfigure(void) { | |||
496 | XEvent event; | 500 | XEvent event; |
497 | event.type = ConfigureNotify; | 501 | event.type = ConfigureNotify; |
498 | 502 | ||
499 | event.xconfigure.display = display; | 503 | event.xconfigure.display = disp; |
500 | event.xconfigure.event = (*it)->window; | 504 | event.xconfigure.event = (*it)->window; |
501 | event.xconfigure.window = (*it)->window; | 505 | event.xconfigure.window = (*it)->window; |
502 | event.xconfigure.x = frame.x + x + screen->getBorderWidth(); | 506 | event.xconfigure.x = frame.x + x + screen()->getBorderWidth(); |
503 | event.xconfigure.y = frame.y + y + screen->getBorderWidth(); | 507 | event.xconfigure.y = frame.y + y + screen()->getBorderWidth(); |
504 | event.xconfigure.width = (*it)->width; | 508 | event.xconfigure.width = (*it)->width; |
505 | event.xconfigure.height = (*it)->height; | 509 | event.xconfigure.height = (*it)->height; |
506 | event.xconfigure.border_width = 0; | 510 | event.xconfigure.border_width = 0; |
507 | event.xconfigure.above = frame.window; | 511 | event.xconfigure.above = frame.window; |
508 | event.xconfigure.override_redirect = False; | 512 | event.xconfigure.override_redirect = False; |
509 | 513 | ||
510 | XSendEvent(display, (*it)->window, False, StructureNotifyMask, | 514 | XSendEvent(disp, (*it)->window, False, StructureNotifyMask, |
511 | &event); | 515 | &event); |
512 | 516 | ||
513 | x += (*it)->width + screen->getBevelWidth(); | 517 | x += (*it)->width + screen()->getBevelWidth(); |
514 | } | 518 | } |
515 | } | 519 | } |
516 | 520 | ||
@@ -527,57 +531,57 @@ void Slit::reposition() { | |||
527 | head_w, | 531 | head_w, |
528 | head_h; | 532 | head_h; |
529 | #ifdef XINERAMA | 533 | #ifdef XINERAMA |
530 | if (screen->hasXinerama()) { | 534 | if (screen()->hasXinerama()) { |
531 | unsigned int head = screen->getSlitOnHead(); | 535 | unsigned int head = screen()->getSlitOnHead(); |
532 | 536 | ||
533 | head_x = screen->getHeadX(head); | 537 | head_x = screen()->getHeadX(head); |
534 | head_y = screen->getHeadY(head); | 538 | head_y = screen()->getHeadY(head); |
535 | head_w = screen->getHeadWidth(head); | 539 | head_w = screen()->getHeadWidth(head); |
536 | head_h = screen->getHeadHeight(head); | 540 | head_h = screen()->getHeadHeight(head); |
537 | } else { | 541 | } else { |
538 | head_w = screen->getWidth(); | 542 | head_w = screen()->getWidth(); |
539 | head_h = screen->getHeight(); | 543 | head_h = screen()->getHeight(); |
540 | } | 544 | } |
541 | #else // !XINERAMA | 545 | #else // !XINERAMA |
542 | head_w = screen->getWidth(); | 546 | head_w = screen()->getWidth(); |
543 | head_h = screen->getHeight(); | 547 | head_h = screen()->getHeight(); |
544 | #endif // XINERAMA | 548 | #endif // XINERAMA |
545 | 549 | ||
546 | // place the slit in the appropriate place | 550 | // place the slit in the appropriate place |
547 | switch (screen->getSlitPlacement()) { | 551 | switch (screen()->getSlitPlacement()) { |
548 | case TOPLEFT: | 552 | case TOPLEFT: |
549 | frame.x = head_x; | 553 | frame.x = head_x; |
550 | frame.y = head_y; | 554 | frame.y = head_y; |
551 | if (screen->getSlitDirection() == VERTICAL) { | 555 | if (screen()->getSlitDirection() == VERTICAL) { |
552 | frame.x_hidden = screen->getBevelWidth() - | 556 | frame.x_hidden = screen()->getBevelWidth() - |
553 | screen->getBorderWidth() - frame.width; | 557 | screen()->getBorderWidth() - frame.width; |
554 | frame.y_hidden = head_y; | 558 | frame.y_hidden = head_y; |
555 | } else { | 559 | } else { |
556 | frame.x_hidden = head_x; | 560 | frame.x_hidden = head_x; |
557 | frame.y_hidden = screen->getBevelWidth() - | 561 | frame.y_hidden = screen()->getBevelWidth() - |
558 | screen->getBorderWidth() - frame.height; | 562 | screen()->getBorderWidth() - frame.height; |
559 | } | 563 | } |
560 | break; | 564 | break; |
561 | 565 | ||
562 | case CENTERLEFT: | 566 | case CENTERLEFT: |
563 | frame.x = head_x; | 567 | frame.x = head_x; |
564 | frame.y = head_y + (head_h - frame.height) / 2; | 568 | frame.y = head_y + (head_h - frame.height) / 2; |
565 | frame.x_hidden = head_x + screen->getBevelWidth() - | 569 | frame.x_hidden = head_x + screen()->getBevelWidth() - |
566 | screen->getBorderWidth() - frame.width; | 570 | screen()->getBorderWidth() - frame.width; |
567 | frame.y_hidden = frame.y; | 571 | frame.y_hidden = frame.y; |
568 | break; | 572 | break; |
569 | 573 | ||
570 | case BOTTOMLEFT: | 574 | case BOTTOMLEFT: |
571 | frame.x = head_x; | 575 | frame.x = head_x; |
572 | frame.y = head_h - frame.height - screen->getBorderWidth2x(); | 576 | frame.y = head_h - frame.height - screen()->getBorderWidth2x(); |
573 | if (screen->getSlitDirection() == VERTICAL) { | 577 | if (screen()->getSlitDirection() == VERTICAL) { |
574 | frame.x_hidden = head_x + screen->getBevelWidth() - | 578 | frame.x_hidden = head_x + screen()->getBevelWidth() - |
575 | screen->getBorderWidth() - frame.width; | 579 | screen()->getBorderWidth() - frame.width; |
576 | frame.y_hidden = frame.y; | 580 | frame.y_hidden = frame.y; |
577 | } else { | 581 | } else { |
578 | frame.x_hidden = head_x; | 582 | frame.x_hidden = head_x; |
579 | frame.y_hidden = head_y + head_h - | 583 | frame.y_hidden = head_y + head_h - |
580 | screen->getBevelWidth() - screen->getBorderWidth(); | 584 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
581 | } | 585 | } |
582 | break; | 586 | break; |
583 | 587 | ||
@@ -585,85 +589,88 @@ void Slit::reposition() { | |||
585 | frame.x = head_x + ((head_w - frame.width) / 2); | 589 | frame.x = head_x + ((head_w - frame.width) / 2); |
586 | frame.y = head_y; | 590 | frame.y = head_y; |
587 | frame.x_hidden = frame.x; | 591 | frame.x_hidden = frame.x; |
588 | frame.y_hidden = head_y + screen->getBevelWidth() - | 592 | frame.y_hidden = head_y + screen()->getBevelWidth() - |
589 | screen->getBorderWidth() - frame.height; | 593 | screen()->getBorderWidth() - frame.height; |
590 | break; | 594 | break; |
591 | 595 | ||
592 | case BOTTOMCENTER: | 596 | case BOTTOMCENTER: |
593 | frame.x = head_x + ((head_w - frame.width) / 2); | 597 | frame.x = head_x + ((head_w - frame.width) / 2); |
594 | frame.y = head_y + head_h - frame.height - screen->getBorderWidth2x(); | 598 | frame.y = head_y + head_h - frame.height - screen()->getBorderWidth2x(); |
595 | frame.x_hidden = frame.x; | 599 | frame.x_hidden = frame.x; |
596 | frame.y_hidden = head_y + head_h - | 600 | frame.y_hidden = head_y + head_h - |
597 | screen->getBevelWidth() - screen->getBorderWidth(); | 601 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
598 | break; | 602 | break; |
599 | 603 | ||
600 | case TOPRIGHT: | 604 | case TOPRIGHT: |
601 | frame.x = head_x + head_w - frame.width - screen->getBorderWidth2x(); | 605 | frame.x = head_x + head_w - frame.width - screen()->getBorderWidth2x(); |
602 | frame.y = head_y; | 606 | frame.y = head_y; |
603 | if (screen->getSlitDirection() == VERTICAL) { | 607 | if (screen()->getSlitDirection() == VERTICAL) { |
604 | frame.x_hidden = head_x + head_w - | 608 | frame.x_hidden = head_x + head_w - |
605 | screen->getBevelWidth() - screen->getBorderWidth(); | 609 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
606 | frame.y_hidden = head_y; | 610 | frame.y_hidden = head_y; |
607 | } else { | 611 | } else { |
608 | frame.x_hidden = frame.x; | 612 | frame.x_hidden = frame.x; |
609 | frame.y_hidden = head_y + screen->getBevelWidth() - | 613 | frame.y_hidden = head_y + screen()->getBevelWidth() - |
610 | screen->getBorderWidth() - frame.height; | 614 | screen()->getBorderWidth() - frame.height; |
611 | } | 615 | } |
612 | break; | 616 | break; |
613 | 617 | ||
614 | case CENTERRIGHT: | 618 | case CENTERRIGHT: |
615 | default: | 619 | default: |
616 | frame.x = head_x + head_w - frame.width - screen->getBorderWidth2x(); | 620 | frame.x = head_x + head_w - frame.width - screen()->getBorderWidth2x(); |
617 | frame.y = head_y + ((head_h - frame.height) / 2); | 621 | frame.y = head_y + ((head_h - frame.height) / 2); |
618 | frame.x_hidden = head_x + head_w - | 622 | frame.x_hidden = head_x + head_w - |
619 | screen->getBevelWidth() - screen->getBorderWidth(); | 623 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
620 | frame.y_hidden = frame.y; | 624 | frame.y_hidden = frame.y; |
621 | break; | 625 | break; |
622 | 626 | ||
623 | case BOTTOMRIGHT: | 627 | case BOTTOMRIGHT: |
624 | frame.x = head_x + head_w - frame.width - screen->getBorderWidth2x(); | 628 | frame.x = head_x + head_w - frame.width - screen()->getBorderWidth2x(); |
625 | frame.y = head_y + head_h - frame.height - screen->getBorderWidth2x(); | 629 | frame.y = head_y + head_h - frame.height - screen()->getBorderWidth2x(); |
626 | if (screen->getSlitDirection() == VERTICAL) { | 630 | if (screen()->getSlitDirection() == VERTICAL) { |
627 | frame.x_hidden = head_x + head_w - | 631 | frame.x_hidden = head_x + head_w - |
628 | screen->getBevelWidth() - screen->getBorderWidth(); | 632 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
629 | frame.y_hidden = frame.y; | 633 | frame.y_hidden = frame.y; |
630 | } else { | 634 | } else { |
631 | frame.x_hidden = frame.x; | 635 | frame.x_hidden = frame.x; |
632 | frame.y_hidden = head_y + head_h - | 636 | frame.y_hidden = head_y + head_h - |
633 | screen->getBevelWidth() - screen->getBorderWidth(); | 637 | screen()->getBevelWidth() - screen()->getBorderWidth(); |
634 | } | 638 | } |
635 | break; | 639 | break; |
636 | } | 640 | } |
637 | 641 | ||
638 | const Toolbar * const tbar = screen->getToolbar(); | 642 | const Toolbar * const tbar = screen()->getToolbar(); |
639 | int sw = frame.width + screen->getBorderWidth2x(), | 643 | int sw = frame.width + screen()->getBorderWidth2x(), |
640 | sh = frame.height + screen->getBorderWidth2x(), | 644 | sh = frame.height + screen()->getBorderWidth2x(), |
641 | tw = tbar->width() + screen->getBorderWidth(), | 645 | tw = tbar->width() + screen()->getBorderWidth(), |
642 | th = tbar->height() + screen->getBorderWidth(); | 646 | th = tbar->height() + screen()->getBorderWidth(); |
643 | 647 | ||
644 | if (tbar->x() < frame.x + sw && tbar->x() + tw > frame.x && | 648 | if (tbar->x() < frame.x + sw && tbar->x() + tw > frame.x && |
645 | tbar->y() < frame.y + sh && tbar->y() + th > frame.y) { | 649 | tbar->y() < frame.y + sh && tbar->y() + th > frame.y) { |
646 | if (frame.y < th) { | 650 | if (frame.y < th) { |
647 | frame.y += tbar->getExposedHeight(); | 651 | frame.y += tbar->getExposedHeight(); |
648 | if (screen->getSlitDirection() == VERTICAL) | 652 | if (screen()->getSlitDirection() == VERTICAL) |
649 | frame.y_hidden += tbar->getExposedHeight(); | 653 | frame.y_hidden += tbar->getExposedHeight(); |
650 | else | 654 | else |
651 | frame.y_hidden = frame.y; | 655 | frame.y_hidden = frame.y; |
652 | } else { | 656 | } else { |
653 | frame.y -= tbar->getExposedHeight(); | 657 | frame.y -= tbar->getExposedHeight(); |
654 | if (screen->getSlitDirection() == VERTICAL) | 658 | if (screen()->getSlitDirection() == VERTICAL) |
655 | frame.y_hidden -= tbar->getExposedHeight(); | 659 | frame.y_hidden -= tbar->getExposedHeight(); |
656 | else | 660 | else |
657 | frame.y_hidden = frame.y; | 661 | frame.y_hidden = frame.y; |
658 | } | 662 | } |
659 | } | 663 | } |
660 | 664 | ||
661 | if (hidden) | 665 | Display *disp = BaseDisplay::getXDisplay(); |
662 | XMoveResizeWindow(display, frame.window, frame.x_hidden, | 666 | |
667 | if (hidden) { | ||
668 | XMoveResizeWindow(disp, frame.window, frame.x_hidden, | ||
663 | frame.y_hidden, frame.width, frame.height); | 669 | frame.y_hidden, frame.width, frame.height); |
664 | else | 670 | } else { |
665 | XMoveResizeWindow(display, frame.window, frame.x, | 671 | XMoveResizeWindow(disp, frame.window, frame.x, |
666 | frame.y, frame.width, frame.height); | 672 | frame.y, frame.width, frame.height); |
673 | } | ||
667 | } | 674 | } |
668 | 675 | ||
669 | 676 | ||
@@ -675,14 +682,15 @@ void Slit::shutdown() { | |||
675 | 682 | ||
676 | 683 | ||
677 | void Slit::buttonPressEvent(XButtonEvent *e) { | 684 | void Slit::buttonPressEvent(XButtonEvent *e) { |
678 | if (e->window != frame.window) return; | 685 | if (e->window != frame.window) |
686 | return; | ||
679 | 687 | ||
680 | if (e->button == Button1 && (! on_top)) { | 688 | if (e->button == Button1 && (! on_top)) { |
681 | Workspace::Stack st; | 689 | Workspace::Stack st; |
682 | st.push_back(frame.window); | 690 | st.push_back(frame.window); |
683 | screen->raiseWindows(st); | 691 | screen()->raiseWindows(st); |
684 | } else if (e->button == Button2 && (! on_top)) { | 692 | } else if (e->button == Button2 && (! on_top)) { |
685 | XLowerWindow(display, frame.window); | 693 | XLowerWindow(BaseDisplay::getXDisplay(), frame.window); |
686 | } else if (e->button == Button3) { | 694 | } else if (e->button == Button3) { |
687 | if (! slitmenu.isVisible()) { | 695 | if (! slitmenu.isVisible()) { |
688 | int x = e->x_root - (slitmenu.width() / 2), | 696 | int x = e->x_root - (slitmenu.width() / 2), |
@@ -690,13 +698,13 @@ void Slit::buttonPressEvent(XButtonEvent *e) { | |||
690 | 698 | ||
691 | if (x < 0) | 699 | if (x < 0) |
692 | x = 0; | 700 | x = 0; |
693 | else if (x + slitmenu.width() > screen->getWidth()) | 701 | else if (x + slitmenu.width() > screen()->getWidth()) |
694 | x = screen->getWidth() - slitmenu.width(); | 702 | x = screen()->getWidth() - slitmenu.width(); |
695 | 703 | ||
696 | if (y < 0) | 704 | if (y < 0) |
697 | y = 0; | 705 | y = 0; |
698 | else if (y + slitmenu.height() > screen->getHeight()) | 706 | else if (y + slitmenu.height() > screen()->getHeight()) |
699 | y = screen->getHeight() - slitmenu.height(); | 707 | y = screen()->getHeight() - slitmenu.height(); |
700 | 708 | ||
701 | slitmenu.move(x, y); | 709 | slitmenu.move(x, y); |
702 | slitmenu.show(); | 710 | slitmenu.show(); |
@@ -735,57 +743,58 @@ void Slit::leaveNotifyEvent(XCrossingEvent *) { | |||
735 | 743 | ||
736 | 744 | ||
737 | void Slit::configureRequestEvent(XConfigureRequestEvent *e) { | 745 | void Slit::configureRequestEvent(XConfigureRequestEvent *e) { |
738 | fluxbox->grab(); | ||
739 | |||
740 | if (fluxbox->validateWindow(e->window)) { | ||
741 | bool reconf = false; | ||
742 | XWindowChanges xwc; | ||
743 | |||
744 | xwc.x = e->x; | ||
745 | xwc.y = e->y; | ||
746 | xwc.width = e->width; | ||
747 | xwc.height = e->height; | ||
748 | xwc.border_width = 0; | ||
749 | xwc.sibling = e->above; | ||
750 | xwc.stack_mode = e->detail; | ||
751 | |||
752 | XConfigureWindow(display, e->window, e->value_mask, &xwc); | ||
753 | |||
754 | SlitClients::iterator it = clientList.begin(); | ||
755 | SlitClients::iterator it_end = clientList.end(); | ||
756 | for (; it != it_end; ++it) | ||
757 | if ((*it)->window == e->window) | ||
758 | if ((*it)->width != ((unsigned) e->width) || | ||
759 | (*it)->height != ((unsigned) e->height)) { | ||
760 | (*it)->width = (unsigned) e->width; | ||
761 | (*it)->height = (unsigned) e->height; | ||
762 | |||
763 | reconf = true; | ||
764 | |||
765 | break; | ||
766 | } | ||
767 | 746 | ||
768 | if (reconf) reconfigure(); | 747 | if (!Fluxbox::instance()->validateWindow(e->window)) |
748 | return; | ||
749 | |||
750 | bool reconf = false; | ||
751 | XWindowChanges xwc; | ||
752 | |||
753 | xwc.x = e->x; | ||
754 | xwc.y = e->y; | ||
755 | xwc.width = e->width; | ||
756 | xwc.height = e->height; | ||
757 | xwc.border_width = 0; | ||
758 | xwc.sibling = e->above; | ||
759 | xwc.stack_mode = e->detail; | ||
760 | |||
761 | XConfigureWindow(BaseDisplay::getXDisplay(), e->window, e->value_mask, &xwc); | ||
762 | |||
763 | SlitClients::iterator it = clientList.begin(); | ||
764 | SlitClients::iterator it_end = clientList.end(); | ||
765 | for (; it != it_end; ++it) { | ||
766 | if ((*it)->window == e->window) { | ||
767 | if ((*it)->width != ((unsigned) e->width) || | ||
768 | (*it)->height != ((unsigned) e->height)) { | ||
769 | (*it)->width = (unsigned) e->width; | ||
770 | (*it)->height = (unsigned) e->height; | ||
771 | |||
772 | reconf = true; //requires reconfiguration | ||
769 | 773 | ||
774 | break; | ||
775 | } | ||
776 | } | ||
770 | } | 777 | } |
771 | 778 | ||
772 | fluxbox->ungrab(); | 779 | if (reconf) |
780 | reconfigure(); | ||
773 | } | 781 | } |
774 | 782 | ||
775 | 783 | ||
776 | void Slit::timeout() { | 784 | void Slit::timeout() { |
777 | hidden = ! hidden; | 785 | hidden = ! hidden; |
786 | Display *disp = BaseDisplay::getXDisplay(); | ||
778 | if (hidden) | 787 | if (hidden) |
779 | XMoveWindow(display, frame.window, frame.x_hidden, frame.y_hidden); | 788 | XMoveWindow(disp, frame.window, frame.x_hidden, frame.y_hidden); |
780 | else | 789 | else |
781 | XMoveWindow(display, frame.window, frame.x, frame.y); | 790 | XMoveWindow(disp, frame.window, frame.x, frame.y); |
782 | } | 791 | } |
783 | 792 | ||
784 | void Slit::loadClientList() { | 793 | void Slit::loadClientList() { |
785 | const std::string &filename = fluxbox->getSlitlistFilename(); | 794 | const std::string &filename = Fluxbox::instance()->getSlitlistFilename(); |
786 | struct stat buf; | 795 | struct stat buf; |
787 | if (!stat(filename.c_str(), &buf)) { | 796 | if (!stat(filename.c_str(), &buf)) { |
788 | std::ifstream file(fluxbox->getSlitlistFilename().c_str()); | 797 | std::ifstream file(Fluxbox::instance()->getSlitlistFilename().c_str()); |
789 | std::string name; | 798 | std::string name; |
790 | while (! file.eof()) { | 799 | while (! file.eof()) { |
791 | name = ""; | 800 | name = ""; |
@@ -798,8 +807,8 @@ void Slit::loadClientList() { | |||
798 | } | 807 | } |
799 | } | 808 | } |
800 | 809 | ||
801 | void Slit::saveClientList(void) { | 810 | void Slit::saveClientList() { |
802 | const std::string &filename = fluxbox->getSlitlistFilename(); | 811 | const std::string &filename = Fluxbox::instance()->getSlitlistFilename(); |
803 | std::ofstream file(filename.c_str()); | 812 | std::ofstream file(filename.c_str()); |
804 | SlitClients::iterator it = clientList.begin(); | 813 | SlitClients::iterator it = clientList.begin(); |
805 | SlitClients::iterator it_end = clientList.end(); | 814 | SlitClients::iterator it_end = clientList.end(); |
@@ -813,10 +822,28 @@ void Slit::saveClientList(void) { | |||
813 | prevName = name; | 822 | prevName = name; |
814 | } | 823 | } |
815 | } | 824 | } |
825 | void Slit::setOnTop(bool val) { | ||
826 | on_top = val; | ||
827 | screen()->saveSlitOnTop(val); | ||
828 | |||
829 | if (isOnTop()) | ||
830 | screen()->raiseWindows(Workspace::Stack()); | ||
831 | |||
832 | } | ||
816 | 833 | ||
817 | 834 | ||
818 | Slitmenu::Slitmenu(Slit &sl) : Basemenu(sl.screen), | 835 | void Slit::setAutoHide(bool val) { |
819 | slit(sl) { | 836 | do_auto_hide = val; |
837 | screen()->saveSlitAutoHide(val); | ||
838 | } | ||
839 | |||
840 | Slitmenu::Slitmenu(Slit &sl) : Basemenu(sl.screen()), | ||
841 | slit(sl), | ||
842 | #ifdef XINERAMA | ||
843 | m_headmenu(0), | ||
844 | #endif // XINERAMA | ||
845 | m_placementmenu(*this), | ||
846 | m_directionmenu(*this) { | ||
820 | 847 | ||
821 | I18n *i18n = I18n::instance(); | 848 | I18n *i18n = I18n::instance(); |
822 | using namespace FBNLS; | 849 | using namespace FBNLS; |
@@ -825,27 +852,25 @@ slit(sl) { | |||
825 | "Slit")); | 852 | "Slit")); |
826 | setInternalMenu(); | 853 | setInternalMenu(); |
827 | 854 | ||
828 | directionmenu = new Directionmenu(this); | 855 | |
829 | placementmenu = new Placementmenu(this); | ||
830 | #ifdef XINERAMA | 856 | #ifdef XINERAMA |
831 | if (screen()->hasXinerama()) { // only create if we need | 857 | if (screen()->hasXinerama()) { // only create if we need |
832 | headmenu = new Headmenu(this); | 858 | m_headmenu.reset(new Headmenu(this)); |
833 | } | 859 | } |
834 | #endif // XINERAMA | 860 | #endif // XINERAMA |
835 | 861 | ||
836 | insert(i18n->getMessage( | 862 | insert(i18n->getMessage( |
837 | CommonSet, CommonDirectionTitle, | 863 | CommonSet, CommonDirectionTitle, |
838 | "Direction"), | 864 | "Direction"), |
839 | directionmenu); | 865 | &m_directionmenu); |
840 | insert(i18n->getMessage( | 866 | insert(i18n->getMessage( |
841 | CommonSet, CommonPlacementTitle, | 867 | CommonSet, CommonPlacementTitle, |
842 | "Placement"), | 868 | "Placement"), |
843 | placementmenu); | 869 | &m_placementmenu); |
844 | 870 | ||
845 | #ifdef XINERAMA | 871 | #ifdef XINERAMA |
846 | //TODO: NLS | ||
847 | if (screen()->hasXinerama()) { | 872 | if (screen()->hasXinerama()) { |
848 | insert(i18n->getMessage(0, 0, "Place on Head"), headmenu); | 873 | insert(i18n->getMessage(0, 0, "Place on Head"), m_headmenu.get()); |
849 | } | 874 | } |
850 | #endif // XINERAMA | 875 | #endif // XINERAMA |
851 | 876 | ||
@@ -865,13 +890,7 @@ slit(sl) { | |||
865 | 890 | ||
866 | 891 | ||
867 | Slitmenu::~Slitmenu() { | 892 | Slitmenu::~Slitmenu() { |
868 | delete directionmenu; | 893 | |
869 | delete placementmenu; | ||
870 | #ifdef XINERAMA | ||
871 | if (screen()->hasXinerama()) { | ||
872 | delete headmenu; | ||
873 | } | ||
874 | #endif // XINERAMA | ||
875 | } | 894 | } |
876 | 895 | ||
877 | 896 | ||
@@ -881,28 +900,17 @@ void Slitmenu::itemSelected(int button, unsigned int index) { | |||
881 | if (! item) return; | 900 | if (! item) return; |
882 | 901 | ||
883 | switch (item->function()) { | 902 | switch (item->function()) { |
884 | case 1: // always on top | 903 | case 1: |
885 | { | 904 | // toggle on top |
886 | bool change = ((slit.isOnTop()) ? false : true); | 905 | slit.setOnTop(slit.isOnTop() ? false : true); |
887 | slit.on_top = change; | 906 | setItemSelected(2, slit.isOnTop()); |
888 | screen()->saveSlitOnTop(change); | ||
889 | setItemSelected(2, change); | ||
890 | |||
891 | if (slit.isOnTop()) | ||
892 | screen()->raiseWindows(Workspace::Stack()); | ||
893 | |||
894 | break; | 907 | break; |
895 | } | ||
896 | |||
897 | case 2: // auto hide | 908 | case 2: // auto hide |
898 | { | 909 | slit.setAutoHide(slit.doAutoHide() ? false : true); |
899 | bool change = (slit.doAutoHide() ? false : true); | 910 | setItemSelected(3, slit.doAutoHide()); |
900 | slit.do_auto_hide = change; | ||
901 | screen()->saveSlitAutoHide(change); | ||
902 | setItemSelected(3, change); | ||
903 | break; | 911 | break; |
904 | } | 912 | } |
905 | } | 913 | |
906 | //save the new configuration | 914 | //save the new configuration |
907 | Fluxbox::instance()->save_rc(); | 915 | Fluxbox::instance()->save_rc(); |
908 | update(); | 916 | update(); |
@@ -910,19 +918,19 @@ void Slitmenu::itemSelected(int button, unsigned int index) { | |||
910 | } | 918 | } |
911 | 919 | ||
912 | 920 | ||
913 | void Slitmenu::internal_hide(void) { | 921 | void Slitmenu::internal_hide() { |
914 | Basemenu::internal_hide(); | 922 | Basemenu::internal_hide(); |
915 | if (slit.doAutoHide()) | 923 | if (slit.doAutoHide()) |
916 | slit.timeout(); | 924 | slit.timeout(); |
917 | } | 925 | } |
918 | 926 | ||
919 | 927 | ||
920 | void Slitmenu::reconfigure(void) { | 928 | void Slitmenu::reconfigure() { |
921 | directionmenu->reconfigure(); | 929 | m_directionmenu.reconfigure(); |
922 | placementmenu->reconfigure(); | 930 | m_placementmenu.reconfigure(); |
923 | #ifdef XINERAMA | 931 | #ifdef XINERAMA |
924 | if (screen()->hasXinerama()) { | 932 | if (m_headmenu.get() != 0) { |
925 | headmenu->reconfigure(); | 933 | m_headmenu->reconfigure(); |
926 | } | 934 | } |
927 | #endif // XINERAMA | 935 | #endif // XINERAMA |
928 | setItemSelected(2, slit.isOnTop()); | 936 | setItemSelected(2, slit.isOnTop()); |
@@ -932,7 +940,7 @@ void Slitmenu::reconfigure(void) { | |||
932 | } | 940 | } |
933 | 941 | ||
934 | 942 | ||
935 | Slitmenu::Directionmenu::Directionmenu(Slitmenu *sm) : Basemenu(sm->screen()), | 943 | Slitmenu::Directionmenu::Directionmenu(Slitmenu &sm) : Basemenu(sm.screen()), |
936 | slitmenu(sm) { | 944 | slitmenu(sm) { |
937 | 945 | ||
938 | I18n *i18n = I18n::instance(); | 946 | I18n *i18n = I18n::instance(); |
@@ -963,7 +971,8 @@ slitmenu(sm) { | |||
963 | void Slitmenu::Directionmenu::itemSelected(int button, unsigned int index) { | 971 | void Slitmenu::Directionmenu::itemSelected(int button, unsigned int index) { |
964 | if (button == 1) { | 972 | if (button == 1) { |
965 | BasemenuItem *item = find(index); | 973 | BasemenuItem *item = find(index); |
966 | if (! item) return; | 974 | if (item == 0) |
975 | return; | ||
967 | 976 | ||
968 | screen()->saveSlitDirection(item->function()); | 977 | screen()->saveSlitDirection(item->function()); |
969 | 978 | ||
@@ -976,12 +985,12 @@ void Slitmenu::Directionmenu::itemSelected(int button, unsigned int index) { | |||
976 | } | 985 | } |
977 | Fluxbox::instance()->save_rc(); | 986 | Fluxbox::instance()->save_rc(); |
978 | hide(); | 987 | hide(); |
979 | slitmenu->slit.reconfigure(); | 988 | slitmenu.slit.reconfigure(); |
980 | } | 989 | } |
981 | } | 990 | } |
982 | 991 | ||
983 | 992 | ||
984 | Slitmenu::Placementmenu::Placementmenu(Slitmenu *sm) : Basemenu(sm->screen()), | 993 | Slitmenu::Placementmenu::Placementmenu(Slitmenu &sm) : Basemenu(sm.screen()), |
985 | slitmenu(sm) { | 994 | slitmenu(sm) { |
986 | 995 | ||
987 | I18n *i18n = I18n::instance(); | 996 | I18n *i18n = I18n::instance(); |
@@ -1038,7 +1047,7 @@ void Slitmenu::Placementmenu::itemSelected(int button, unsigned int index) { | |||
1038 | if (item->function()) { | 1047 | if (item->function()) { |
1039 | screen()->saveSlitPlacement(item->function()); | 1048 | screen()->saveSlitPlacement(item->function()); |
1040 | hide(); | 1049 | hide(); |
1041 | slitmenu->slit.reconfigure(); | 1050 | slitmenu.slit.reconfigure(); |
1042 | Fluxbox::instance()->save_rc(); | 1051 | Fluxbox::instance()->save_rc(); |
1043 | } | 1052 | } |
1044 | } | 1053 | } |
@@ -1080,14 +1089,12 @@ void Slitmenu::Headmenu::itemSelected(int button, unsigned int index) { | |||
1080 | 1089 | ||
1081 | #endif // XINERAMA | 1090 | #endif // XINERAMA |
1082 | 1091 | ||
1083 | Slit::SlitClient::SlitClient(const char *name) | 1092 | Slit::SlitClient::SlitClient(const char *name) { |
1084 | { | ||
1085 | initialize(); | 1093 | initialize(); |
1086 | match_name = name; | 1094 | match_name = (name == 0 ? "" : name); |
1087 | } | 1095 | } |
1088 | 1096 | ||
1089 | Slit::SlitClient::SlitClient(BScreen *screen, Window w) | 1097 | Slit::SlitClient::SlitClient(BScreen *screen, Window w) { |
1090 | { | ||
1091 | initialize(screen, w); | 1098 | initialize(screen, w); |
1092 | } | 1099 | } |
1093 | 1100 | ||