xref: /haiku/src/servers/app/Desktop.h (revision e9c4d47ad719d6fd67cd9b75b41ebbec563e7a79) 
1 /*
2  * Copyright 2001-2008, Haiku.
3  * Distributed under the terms of the MIT License.
4  *
5  * Authors:
6  *		Adrian Oanca <adioanca@cotty.iren.ro>
7  *		Stephan Aßmus <superstippi@gmx.de>
8  *		Axel Dörfler, axeld@pinc-software.de
9  *		Andrej Spielmann, <andrej.spielmann@seh.ox.ac.uk>
10  */
11 #ifndef DESKTOP_H
12 #define DESKTOP_H
13 
14 
15 #include "CursorManager.h"
16 #include "DesktopSettings.h"
17 #include "EventDispatcher.h"
18 #include "MessageLooper.h"
19 #include "Screen.h"
20 #include "ScreenManager.h"
21 #include "ServerCursor.h"
22 #include "VirtualScreen.h"
23 #include "WindowList.h"
24 #include "Workspace.h"
25 #include "WorkspacePrivate.h"
26 
27 #include <ObjectList.h>
28 
29 #include <Autolock.h>
30 #include <InterfaceDefs.h>
31 #include <List.h>
32 #include <Menu.h>
33 #include <Region.h>
34 #include <Window.h>
35 
36 #define USE_MULTI_LOCKER 1
37 
38 #if USE_MULTI_LOCKER
39 #  include "MultiLocker.h"
40 #else
41 #  include <Locker.h>
42 #endif
43 
44 class BMessage;
45 
46 class DrawingEngine;
47 class HWInterface;
48 class ServerApp;
49 class Window;
50 class WorkspacesView;
51 struct server_read_only_memory;
52 
53 namespace BPrivate {
54 	class LinkSender;
55 };
56 
57 class Desktop : public MessageLooper, public ScreenOwner {
58 	public:
59 								Desktop(uid_t userID);
60 		virtual					~Desktop();
61 
62 		status_t				Init();
63 
64 		uid_t					UserID() const { return fUserID; }
65 		virtual port_id			MessagePort() const { return fMessagePort; }
66 		area_id					SharedReadOnlyArea() const
67 									{ return fSharedReadOnlyArea; }
68 
69 		::EventDispatcher&		EventDispatcher() { return fEventDispatcher; }
70 
71 		void					BroadcastToAllApps(int32 code);
72 
73 		// Screen and drawing related methods
74 
75 		Screen*					ScreenAt(int32 index) const
76 									{ return fActiveScreen; }
77 		Screen*					ActiveScreen() const
78 									{ return fActiveScreen; }
79 
80 		CursorManager&			GetCursorManager() { return fCursorManager; }
81 
82 		void					SetCursor(ServerCursor* cursor);
83 		ServerCursorReference	Cursor() const;
84 		void					SetLastMouseState(const BPoint& position,
85 									int32 buttons);
86 									// for use by the mouse filter only
87 									// both mouse position calls require
88 									// the Desktop object to be locked
89 									// already
90 		void					GetLastMouseState(BPoint* position,
91 									int32* buttons) const;
92 									// for use by ServerWindow
93 
94 		void					ScreenChanged(Screen* screen, bool makeDefault);
95 
96 		void					ScreenRemoved(Screen* screen) {}
97 		void					ScreenAdded(Screen* screen) {}
98 		bool					ReleaseScreen(Screen* screen) { return false; }
99 
100 		const ::VirtualScreen&	VirtualScreen() const { return fVirtualScreen; }
101 		DrawingEngine*			GetDrawingEngine() const
102 									{ return fVirtualScreen.DrawingEngine(); }
103 		::HWInterface*			HWInterface() const
104 									{ return fVirtualScreen.HWInterface(); }
105 
106 		// Workspace methods
107 
108 		void					SetWorkspaceAsync(int32 index);
109 		void					SetWorkspace(int32 index);
110 		int32					CurrentWorkspace()
111 									{ return fCurrentWorkspace; }
112 		Workspace::Private&		WorkspaceAt(int32 index)
113 									{ return fWorkspaces[index]; }
114 		status_t				SetWorkspacesCount(int32 newCount);
115 
116 		// Window methods
117 
118 		void					ActivateWindow(Window* window);
119 		void					SendWindowBehind(Window* window,
120 									Window* behindOf = NULL);
121 
122 		void					ShowWindow(Window* window);
123 		void					HideWindow(Window* window);
124 
125 		void					MoveWindowBy(Window* window, float x, float y,
126 									int32 workspace = -1);
127 		void					ResizeWindowBy(Window* window, float x,
128 									float y);
129 		bool					SetWindowTabLocation(Window* window,
130 									float location);
131 		bool					SetWindowDecoratorSettings(Window* window,
132 									const BMessage& settings);
133 
134 		void					SetWindowWorkspaces(Window* window,
135 									uint32 workspaces);
136 
137 		void					AddWindow(Window* window);
138 		void					RemoveWindow(Window* window);
139 
140 		bool					AddWindowToSubset(Window* subset,
141 									Window* window);
142 		void					RemoveWindowFromSubset(Window* subset,
143 									Window* window);
144 
145 		void					SetWindowLook(Window* window, window_look look);
146 		void					SetWindowFeel(Window* window, window_feel feel);
147 		void					SetWindowFlags(Window* window, uint32 flags);
148 		void					SetWindowTitle(Window* window,
149 									const char* title);
150 
151 		Window*					FocusWindow() const { return fFocus; }
152 		Window*					FrontWindow() const { return fFront; }
153 		Window*					BackWindow() const { return fBack; }
154 
155 		Window*					WindowAt(BPoint where);
156 
157 		Window*					MouseEventWindow() const
158 									{ return fMouseEventWindow; }
159 		void					SetMouseEventWindow(Window* window);
160 
161 		void					SetViewUnderMouse(const Window* window,
162 									int32 viewToken);
163 		int32					ViewUnderMouse(const Window* window);
164 
165 		void					SetFocusWindow(Window* window = NULL);
166 		EventTarget*			KeyboardEventTarget();
167 
168 		Window*					FindWindowByClientToken(int32 token,
169 									team_id teamID);
170 
171 #if USE_MULTI_LOCKER
172 		bool					LockSingleWindow()
173 									{ return fWindowLock.ReadLock(); }
174 		void					UnlockSingleWindow()
175 									{ fWindowLock.ReadUnlock(); }
176 
177 		bool					LockAllWindows()
178 									{ return fWindowLock.WriteLock(); }
179 		void					UnlockAllWindows()
180 									{ fWindowLock.WriteUnlock(); }
181 #else // USE_MULTI_LOCKER
182 		bool					LockSingleWindow()
183 									{ return fWindowLock.Lock(); }
184 		void					UnlockSingleWindow()
185 									{ fWindowLock.Unlock(); }
186 
187 		bool					LockAllWindows()
188 									{ return fWindowLock.Lock(); }
189 		void					UnlockAllWindows()
190 									{ fWindowLock.Unlock(); }
191 #endif // USE_MULTI_LOCKER
192 
193 		void					MarkDirty(BRegion& region);
194 		void					Redraw();
195 
196 		BRegion&				BackgroundRegion()
197 									{ return fBackgroundRegion; }
198 
199 		void					RedrawBackground();
200 		void					StoreWorkspaceConfiguration(int32 index);
201 
202 		void					AddWorkspacesView(WorkspacesView* view);
203 		void					RemoveWorkspacesView(WorkspacesView* view);
204 
205 		void					MinimizeApplication(team_id team);
206 		void					BringApplicationToFront(team_id team);
207 		void					WindowAction(int32 windowToken, int32 action);
208 
209 		void					WriteWindowList(team_id team,
210 									BPrivate::LinkSender& sender);
211 		void					WriteWindowInfo(int32 serverToken,
212 									BPrivate::LinkSender& sender);
213 		void					WriteApplicationOrder(int32 workspace,
214 									BPrivate::LinkSender& sender);
215 		void					WriteWindowOrder(int32 workspace,
216 									BPrivate::LinkSender& sender);
217 
218 	private:
219 		void					_LaunchInputServer();
220 		void					_SetWorkspace(int32 index);
221 		void					_ShowWindow(Window* window,
222 									bool affectsOtherWindows = true);
223 		void					_HideWindow(Window* window);
224 
225 		void					_UpdateSubsetWorkspaces(Window* window,
226 									int32 previousIndex = -1,
227 									int32 newIndex = -1);
228 		void					_ChangeWindowWorkspaces(Window* window,
229 									uint32 oldWorkspaces, uint32 newWorkspaces);
230 		void					_BringWindowsToFront(WindowList& windows,
231 									int32 list, bool wereVisible);
232  		status_t				_ActivateApp(team_id team);
233  		void					_SendFakeMouseMoved(Window* window = NULL);
234 
235 		void					_RebuildClippingForAllWindows(
236 									BRegion& stillAvailableOnScreen);
237 		void					_TriggerWindowRedrawing(
238 									BRegion& newDirtyRegion);
239 		void					_SetBackground(BRegion& background);
240 
241 		void					_UpdateFloating(int32 previousWorkspace = -1,
242 									int32 nextWorkspace = -1,
243 									Window* mouseEventWindow = NULL);
244 		void					_UpdateBack();
245 		void					_UpdateFront(bool updateFloating = true);
246 		void					_UpdateFronts(bool updateFloating = true);
247 		bool					_WindowHasModal(Window* window);
248 
249 		void					_WindowChanged(Window* window);
250 		void					_WindowRemoved(Window* window);
251 
252 		void					_GetLooperName(char* name, size_t size);
253 		void					_PrepareQuit();
254 		void					_DispatchMessage(int32 code,
255 									BPrivate::LinkReceiver &link);
256 
257 		WindowList&				_CurrentWindows();
258 		WindowList&				_Windows(int32 index);
259 
260 	private:
261 		friend class DesktopSettings;
262 		friend class LockedDesktopSettings;
263 
264 		uid_t					fUserID;
265 		::VirtualScreen			fVirtualScreen;
266 		DesktopSettingsPrivate*	fSettings;
267 		port_id					fMessagePort;
268 		::EventDispatcher		fEventDispatcher;
269 		port_id					fInputPort;
270 		area_id					fSharedReadOnlyArea;
271 		server_read_only_memory* fServerReadOnlyMemory;
272 
273 		BLocker					fApplicationsLock;
274 		BObjectList<ServerApp>	fApplications;
275 
276 		sem_id					fShutdownSemaphore;
277 		int32					fShutdownCount;
278 
279 		::Workspace::Private	fWorkspaces[kMaxWorkspaces];
280 		int32					fCurrentWorkspace;
281 
282 		WindowList				fAllWindows;
283 		WindowList				fSubsetWindows;
284 		WindowList				fFocusList;
285 
286 		BObjectList<WorkspacesView> fWorkspacesViews;
287 		BLocker					fWorkspacesLock;
288 
289 		Screen*					fActiveScreen;
290 
291 		CursorManager			fCursorManager;
292 
293 #if USE_MULTI_LOCKER
294 		MultiLocker				fWindowLock;
295 #else
296 		BLocker					fWindowLock;
297 #endif
298 
299 		BRegion					fBackgroundRegion;
300 		BRegion					fScreenRegion;
301 
302 		Window*					fMouseEventWindow;
303 		const Window*			fWindowUnderMouse;
304 		int32					fViewUnderMouse;
305 		BPoint					fLastMousePosition;
306 		int32					fLastMouseButtons;
307 
308 		Window*					fFocus;
309 		Window*					fFront;
310 		Window*					fBack;
311 };
312 
313 #endif	// DESKTOP_H
314