← Back to branch summary

~vorlon/platform-api/lp.1465958

« back to all changes in this revision

Viewing changes to src/ubuntu/application/common/mirserver/ubuntu_application_api_mirserver.cpp

  • Committer: CI bot
  • Author(s): Alberto Aguirre
  • Date: 2014-11-26 17:40:42 UTC
  • mfrom: (283.2.2 stub-mirserver)
  • Revision ID: ps-jenkins@lists.canonical.com-20141126174042-t4fzmnag9rujcppz
Stub out mirserver backend 
Approved by: Gerry Boland, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ubuntu/application/common/mirserver/ubuntu_application_api_mirserver.cpp
1
1
/*
2
 
 * Copyright (C) 2013 Canonical Ltd
 
2
 * Copyright (C) 2013-2014 Canonical Ltd
3
3
 *
4
4
 * This program is free software: you can redistribute it and/or modify
5
5
 * it under the terms of the GNU Lesser General Public License version 3 as
16
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
17
17
 */
18
18
 
19
 
#include "application_instance_mirserver_priv.h"
20
 
#include "window_properties_mirserver_priv.h"
21
 
#include "window_mirserver_priv.h"
22
 
 
23
 
#include "mircommon/application_id_mir_priv.h"
24
 
#include "mircommon/application_description_mir_priv.h"
25
 
#include "mircommon/application_options_mir_priv.h"
26
 
#include "mircommon/mir/geometry/rectangles.h"
27
 
 
28
19
// C APIs
29
20
#include <ubuntu/application/init.h>
30
 
#include <ubuntu/application/lifecycle_delegate.h>
 
21
#include <ubuntu/application/instance.h>
 
22
#include <ubuntu/application/ui/display.h>
31
23
#include <ubuntu/application/ui/window.h>
32
 
#include <ubuntu/application/ui/options.h>
33
 
#include <ubuntu/application/ui/session.h>
34
 
#include <ubuntu/application/ui/clipboard.h>
35
 
#include <ubuntu/application/ui/display.h>
36
 
#include <ubuntu/application/sensors/accelerometer.h>
37
 
#include <ubuntu/application/sensors/proximity.h>
38
 
#include <ubuntu/application/sensors/light.h>
39
 
 
40
 
#include <mir/default_server_configuration.h>
41
 
 
42
 
#include <mir/graphics/display.h>
43
 
#include <mir/graphics/display_buffer.h>
44
 
#include <mir/graphics/platform.h>
45
 
#include <mir/graphics/graphic_buffer_allocator.h>
46
 
#include <mir/graphics/internal_client.h>
47
 
#include <mir/input/input_platform.h>
48
 
 
49
 
#include <assert.h>
50
 
 
51
 
#include <memory>
52
 
#include <functional>
53
 
 
54
 
namespace uam = ubuntu::application::mir;
55
 
namespace uams = ubuntu::application::mir::server;
56
 
 
57
 
namespace
58
 
{
59
 
 
60
 
struct MirServerContext
61
 
{
62
 
    std::shared_ptr<mir::graphics::Display> display;
63
 
    std::shared_ptr<mir::graphics::GraphicBufferAllocator> buffer_allocator;
64
 
    std::shared_ptr<mir::scene::SurfaceCoordinator> surface_coordinator;
65
 
    std::shared_ptr<mir::scene::SessionListener> session_listener;
66
 
    std::shared_ptr<mir::input::receiver::InputPlatform> input_platform;
67
 
    std::shared_ptr<mir::graphics::InternalClient> egl_client;
68
 
};
69
 
 
70
 
MirServerContext *
71
 
global_mirserver_context()
72
 
{
73
 
    static MirServerContext context;
74
 
    return &context;
75
 
}
76
 
}
77
24
 
78
25
extern "C"
79
26
{
80
27
void u_application_init(void *args)
81
28
{
82
 
    auto context = global_mirserver_context();
83
 
    mir::DefaultServerConfiguration* config = reinterpret_cast<mir::DefaultServerConfiguration*>(args);
84
 
 
85
 
    context->surface_coordinator = config->the_surface_coordinator();
86
 
    context->buffer_allocator = config->the_buffer_allocator();
87
 
    context->display = config->the_display();
88
 
    context->session_listener = config->the_session_listener();
89
 
    context->input_platform = mir::input::receiver::InputPlatform::create();
90
 
    context->egl_client = config->the_graphics_platform()->create_internal_client();
 
29
    (void) args;
91
30
}
92
31
 
93
32
void u_application_finish()
94
33
{
95
 
    auto context = global_mirserver_context();
96
 
 
97
 
    context->display.reset();
98
 
    context->surface_coordinator.reset();
99
 
    context->session_listener.reset();
100
 
    context->input_platform.reset();
101
 
    context->egl_client.reset();
102
34
}
103
35
 
104
36
UApplicationInstance* u_application_instance_new_from_description_with_options(UApplicationDescription* u_description, UApplicationOptions* u_options)
105
37
{
106
 
    auto surface_coordinator = global_mirserver_context()->surface_coordinator;
107
 
    assert(surface_coordinator);
108
 
    auto session_listener = global_mirserver_context()->session_listener;
109
 
    assert(session_listener);
110
 
 
111
 
    auto description = uam::Description::from_u_application_description(u_description);
112
 
    auto options = uam::Options::from_u_application_options(u_options);
113
 
 
114
 
    auto instance = new uams::Instance(surface_coordinator, session_listener, description, options);
115
 
 
116
 
    return instance->as_u_application_instance();
 
38
    (void) u_description;
 
39
    (void) u_options;
 
40
    return NULL;
117
41
}
118
42
 
119
43
void
120
44
u_application_instance_ref(UApplicationInstance *u_instance)
121
45
{
122
 
    auto instance = uams::Instance::from_u_application_instance(u_instance);
123
 
    instance->ref();
 
46
    (void) u_instance;
124
47
}
125
 
    
 
48
 
126
49
void
127
50
u_application_instance_unref(UApplicationInstance *u_instance)
128
51
{
129
 
    auto instance = uams::Instance::from_u_application_instance(u_instance);
130
 
    instance->unref();
 
52
    (void) u_instance;
131
53
}
132
 
    
 
54
 
133
55
void
134
56
u_application_instance_destroy(UApplicationInstance *instance)
135
57
{
136
 
    // TODO<papi>: What are the proper semantics here.
137
 
    u_application_instance_unref(instance);
 
58
    (void) instance;
138
59
}
139
 
    
 
60
 
140
61
void
141
62
u_application_instance_run(UApplicationInstance *instance)
142
63
{
153
74
 
154
75
void ua_ui_get_clipboard_content(void** out_content, size_t* out_content_size)
155
76
{
156
 
    // TODO<mir,papi>: Implement
157
77
    *out_content = NULL;
158
78
    *out_content_size = 0;
159
79
}
160
80
 
161
81
UAUiDisplay* ua_ui_display_new_with_index(size_t index)
162
82
{
163
 
    // TODO<mir>: Make use of index. This is kind of strangely done...
164
 
    return reinterpret_cast<UAUiDisplay*>(index);
 
83
    (void) index;
 
84
    return NULL;
165
85
}
166
86
 
167
87
void ua_ui_display_destroy(UAUiDisplay* display)
168
88
{
169
 
    // TODO: Implement. Or is this a noop for mirserver?
170
89
    (void) display;
171
90
}
172
91
 
173
92
uint32_t ua_ui_display_query_horizontal_res(UAUiDisplay* display)
174
93
{
175
 
    (void) display; // TODO<mir>: Multiple displays
176
 
 
177
 
    auto mir_display = global_mirserver_context()->display;
178
 
    assert(mir_display);
179
 
 
180
 
    /* TODO: Get proper configuration */
181
 
    mir::geometry::Rectangles view_area;
182
 
    mir_display->for_each_display_buffer([&view_area](mir::graphics::DisplayBuffer const& db)
183
 
    {
184
 
        view_area.add(db.view_area());
185
 
    });
186
 
    mir::geometry::Size const display_size{view_area.bounding_rectangle().size};
187
 
    
188
 
    return display_size.width.as_uint32_t();
 
94
    (void) display;
 
95
 
 
96
    return 0;
189
97
}
190
98
 
191
99
uint32_t ua_ui_display_query_vertical_res(UAUiDisplay* display)
192
100
{
193
101
    (void) display; // TODO<mir>: Multiple displays
194
102
 
195
 
    auto mir_display = global_mirserver_context()->display;
196
 
    assert(mir_display);
197
 
 
198
 
    /* TODO: Get proper configuration */
199
 
    mir::geometry::Rectangles view_area;
200
 
    mir_display->for_each_display_buffer([&view_area](mir::graphics::DisplayBuffer const& db)
201
 
    {
202
 
        view_area.add(db.view_area());
203
 
    });
204
 
    mir::geometry::Size const display_size{view_area.bounding_rectangle().size};
205
 
    
206
 
    return display_size.height.as_uint32_t();
 
103
    return 0;
207
104
}
208
105
 
209
106
EGLNativeDisplayType ua_ui_display_get_native_type(UAUiDisplay* display)
210
107
{
211
 
    auto internal_client = global_mirserver_context()->egl_client;
212
 
    assert(internal_client);
213
 
    
214
 
    return internal_client->egl_native_display();
215
 
}
216
 
 
217
 
namespace
218
 
{
219
 
static MirPixelFormat choose_pixel_format(std::shared_ptr<mir::graphics::GraphicBufferAllocator> const& allocator)
220
 
{
221
 
    auto formats = allocator->supported_pixel_formats();
222
 
    return formats[0];
223
 
}
 
108
    (void) display;
 
109
    return NULL;
224
110
}
225
111
 
226
112
UAUiWindowProperties* ua_ui_window_properties_new_for_normal_window()
227
113
{
228
 
    auto properties = new uams::WindowProperties();
229
 
 
230
 
    return properties->as_u_window_properties();
 
114
    return NULL;
231
115
}
232
116
 
233
117
void ua_ui_window_properties_destroy(UAUiWindowProperties* u_properties)
234
118
{
235
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
236
 
    delete properties;
 
119
    (void) u_properties;
237
120
}
238
121
 
239
122
void ua_ui_window_properties_set_titlen(UAUiWindowProperties* u_properties, const char* title, size_t title_length)
240
123
{
241
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
242
 
    properties->set_title(title, title_length);
 
124
    (void) u_properties;
 
125
    (void) title;
 
126
    (void) title_length;
243
127
}
244
128
 
245
129
const char* ua_ui_window_properties_get_title(UAUiWindowProperties* u_properties)
246
130
{
247
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
248
 
    return properties->surface_parameters().name.c_str();
 
131
    (void) u_properties;
 
132
    return NULL;
249
133
}
250
134
 
251
135
void ua_ui_window_properties_set_role(UAUiWindowProperties* properties, UAUiWindowRole role)
252
136
{
253
 
    // TODO<papi>: Implement. Or is this a noop for us?
254
137
    (void) properties;
255
138
    (void) role;
256
139
}
257
140
 
258
 
void ua_ui_window_properties_set_event_cb_and_ctx(UAUiWindowProperties*, UAUiWindowEventCb, void*)
 
141
void ua_ui_window_properties_set_event_cb_and_ctx(UAUiWindowProperties* u_properties, UAUiWindowEventCb cb, void* ctx)
259
142
{
 
143
    (void) u_properties;
 
144
    (void) cb;
 
145
    (void) ctx;
260
146
}
261
147
 
262
148
void ua_ui_window_properties_set_input_cb_and_ctx(UAUiWindowProperties* u_properties, UAUiWindowInputEventCb cb, void* ctx)
263
149
{
264
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
265
 
    properties->set_input_cb_and_ctx(cb, ctx);
 
150
    (void) u_properties;
 
151
    (void) cb;
 
152
    (void) ctx;
266
153
}
267
154
 
268
155
void ua_ui_window_properties_set_dimensions(UAUiWindowProperties *u_properties, uint32_t width, uint32_t height)
269
156
{
270
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
271
 
    properties->set_dimensions(width, height);
 
157
    (void) u_properties;
 
158
    (void) width;
 
159
    (void) height;
272
160
}
273
161
 
274
162
UAUiWindow* ua_ui_window_new_for_application_with_properties(UApplicationInstance* u_instance, UAUiWindowProperties* u_properties)
275
163
{
276
 
    auto input_platform = global_mirserver_context()->input_platform;
277
 
    assert(input_platform);
278
 
    auto internal_client = global_mirserver_context()->egl_client;
279
 
    assert(internal_client);
280
 
 
281
 
    auto instance = uams::Instance::from_u_application_instance(u_instance);
282
 
    auto properties = uams::WindowProperties::from_u_window_properties(u_properties);
283
 
    
284
 
    // A bit of a wart.
285
 
    properties->set_pixel_format(choose_pixel_format(global_mirserver_context()->buffer_allocator));
286
 
    
287
 
    auto window = new uams::Window(*instance, properties, input_platform, internal_client);
288
 
 
289
 
    return window->as_u_window();
 
164
    (void) u_instance;
 
165
    (void) u_properties;
 
166
    return NULL;
290
167
}
291
168
 
292
169
void ua_ui_window_destroy(UAUiWindow* u_window)
293
170
{
294
 
    auto window = uams::Window::from_u_window(u_window);
295
 
    delete window;
 
171
    (void) u_window;
296
172
}
297
173
 
298
174
void ua_ui_window_get_size(UAUiWindow* u_window, uint32_t *width, uint32_t *height)
304
180
 
305
181
UStatus ua_ui_window_move(UAUiWindow* window, uint32_t x, uint32_t y)
306
182
{
307
 
    // TODO<mir,papi>: Implement. But should this exist?
308
183
    (void) window;
309
184
    (void) x;
310
185
    (void) y;
313
188
 
314
189
UStatus ua_ui_window_resize(UAUiWindow* window, uint32_t width, uint32_t height)
315
190
{
316
 
    // TODO<mir>: Implement
317
191
    (void) window;
318
192
    (void) width;
319
193
    (void) height;
322
196
 
323
197
UStatus ua_ui_window_hide(UAUiWindow* window)
324
198
{
325
 
    // TODO<mir>: Implement
326
199
    (void) window;
327
200
    return (UStatus) 0;
328
201
}
329
202
 
330
203
UStatus ua_ui_window_show(UAUiWindow* window)
331
204
{
332
 
    // TODO<mir>: Implement
333
205
    (void) window;
334
206
    return (UStatus) 0;
335
207
}
336
208
 
337
209
void ua_ui_window_request_fullscreen(UAUiWindow* window)
338
210
{
339
 
    // TODO<mir>: Implement
340
211
    (void) window;
341
212
}
342
213
 
343
214
EGLNativeWindowType ua_ui_window_get_native_type(UAUiWindow* u_window)
344
215
{
345
 
    auto window = uams::Window::from_u_window(u_window);
346
 
 
347
 
    return window->get_native_type();
 
216
    (void) (u_window);
 
217
    return 0;
348
218
}
349
219
 
350
 
// TODO: Sensors
351
220
}