HomeScreenBinding
simple-egl.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
3  * Copyright © 2011 Benjamin Franzke
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice (including the next
13  * paragraph) shall be included in all copies or substantial portions of the
14  * Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22  * DEALINGS IN THE SOFTWARE.
23  */
24 
25 #include <mutex>
26 #include <chrono>
27 
28 #include <iostream>
29 #include <string>
30 #include <stdarg.h>
31 #include <sys/types.h>
32 #include <thread>
33 #include <exception>
34 #include <vector>
35 #include <sstream>
36 
37 #include <assert.h>
38 #include <signal.h>
39 
40 #include <wayland-client.h>
41 #include <wayland-egl.h>
42 
43 #include <GLES2/gl2.h>
44 #include <EGL/egl.h>
45 #include <EGL/eglext.h>
46 
47 #include <unistd.h>
48 #include <time.h>
49 
50 #include <libwindowmanager.h>
51 #include <libhomescreen.hpp>
52 
53 #include <ilm/ivi-application-client-protocol.h>
54 #include "hmi-debug.h"
55 
56 using namespace std;
57 
58 const char* log_prefix = "simple-egl";
59 uint32_t g_id_ivisurf = 9009;
60 long port = 1700;
61 string token = string("wm");
62 
63 string app_name = string("Navigation");
64 const char* main_role = "navigation";
65 
67 LibWindowmanager *wm;
68 
69 static const struct wl_interface *types[] = {
70  NULL,
71  NULL,
72  NULL,
73  &wl_surface_interface,
75 };
76 
77 static const struct wl_message ivi_surface_requests[] = {
78  { "destroy", "", types + 0 },
79 };
80 
81 static const struct wl_message ivi_surface_events[] = {
82  { "configure", "ii", types + 0 },
83 };
84 
85 const struct wl_interface ivi_surface_interface = {
86  "ivi_surface", 1,
89 };
90 
91 static const struct wl_message ivi_application_requests[] = {
92  { "surface_create", "uon", types + 2 },
93 };
94 
95 const struct wl_interface ivi_application_interface = {
96  "ivi_application", 1,
98  0, NULL,
99 };
100 
101 #include "platform.h"
102 
103 #ifndef EGL_EXT_swap_buffers_with_damage
104 #define EGL_EXT_swap_buffers_with_damage 1
105 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
106 #endif
107 
108 #ifndef EGL_EXT_buffer_age
109 #define EGL_EXT_buffer_age 1
110 #define EGL_BUFFER_AGE_EXT 0x313D
111 #endif
112 
113 struct window;
114 struct seat;
115 
116 struct display {
117  struct wl_display *display;
118  struct wl_registry *registry;
119  struct wl_compositor *compositor;
120  struct wl_seat *seat;
121  struct {
122  EGLDisplay dpy;
123  EGLContext ctx;
124  EGLConfig conf;
125  } egl;
126  struct window *window;
127  struct ivi_application *ivi_application;
128 
129  PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage;
130 };
131 
132 struct geometry {
133  int width, height;
134 };
135 
136 struct window {
137  struct display *display;
138  struct geometry geometry, window_size;
139  struct {
141  GLuint pos;
142  GLuint col;
143  } gl;
144 
145  uint32_t benchmark_time, frames;
146  struct wl_egl_window *native;
147  struct wl_surface *surface;
148  struct ivi_surface *ivi_surface;
149  EGLSurface egl_surface;
150  struct wl_callback *callback;
151  int fullscreen, opaque, buffer_size, frame_sync;
152 };
153 
154 static const char *vert_shader_text =
155  "uniform mat4 rotation;\n"
156  "attribute vec4 pos;\n"
157  "attribute vec4 color;\n"
158  "varying vec4 v_color;\n"
159  "void main() {\n"
160  " gl_Position = rotation * pos;\n"
161  " v_color = color;\n"
162  "}\n";
163 
164 static const char *frag_shader_text =
165  "precision mediump float;\n"
166  "varying vec4 v_color;\n"
167  "void main() {\n"
168  " gl_FragColor = v_color;\n"
169  "}\n";
170 
171 static int running = 1;
172 
173 static void
175 {
176  static const EGLint context_attribs[] = {
177  EGL_CONTEXT_CLIENT_VERSION, 2,
178  EGL_NONE
179  };
180  const char *extensions;
181 
182  EGLint config_attribs[] = {
183  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
184  EGL_RED_SIZE, 1,
185  EGL_GREEN_SIZE, 1,
186  EGL_BLUE_SIZE, 1,
187  EGL_ALPHA_SIZE, 1,
188  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
189  EGL_NONE
190  };
191 
192  EGLint major, minor, n, count, i, size;
193  EGLConfig *configs;
194  EGLBoolean ret;
195 
196  if (window->opaque || window->buffer_size == 16)
197  config_attribs[9] = 0;
198 
199  display->egl.dpy = weston_platform_get_egl_display(EGL_PLATFORM_WAYLAND_KHR, display->display, NULL);
200  assert(display->egl.dpy);
201 
202  ret = eglInitialize(display->egl.dpy, &major, &minor);
203  assert(ret == EGL_TRUE);
204  ret = eglBindAPI(EGL_OPENGL_ES_API);
205  assert(ret == EGL_TRUE);
206 
207  if (!eglGetConfigs(display->egl.dpy, NULL, 0, &count) || count < 1)
208  assert(0);
209 
210  configs = calloc(count, sizeof *configs);
211  assert(configs);
212 
213  ret = eglChooseConfig(display->egl.dpy, config_attribs,
214  configs, count, &n);
215  assert(ret && n >= 1);
216 
217  for (i = 0; i < n; i++) {
218  eglGetConfigAttrib(display->egl.dpy,
219  configs[i], EGL_BUFFER_SIZE, &size);
220  if (window->buffer_size == size) {
221  display->egl.conf = configs[i];
222  break;
223  }
224  }
225  free(configs);
226  if (display->egl.conf == NULL) {
227  HMI_ERROR(log_prefix,"did not find config with buffer size %d",
228  window->buffer_size);
229  exit(EXIT_FAILURE);
230  }
231 
232  display->egl.ctx = eglCreateContext(display->egl.dpy,
233  display->egl.conf,
234  EGL_NO_CONTEXT, context_attribs);
235  assert(display->egl.ctx);
236 
237  display->swap_buffers_with_damage = NULL;
238  extensions = eglQueryString(display->egl.dpy, EGL_EXTENSIONS);
239  if (extensions &&
240  strstr(extensions, "EGL_EXT_swap_buffers_with_damage") &&
241  strstr(extensions, "EGL_EXT_buffer_age"))
242  display->swap_buffers_with_damage =
243  (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)
244  eglGetProcAddress("eglSwapBuffersWithDamageEXT");
245 
246  if (display->swap_buffers_with_damage)
247  HMI_DEBUG(log_prefix,"has EGL_EXT_buffer_age and EGL_EXT_swap_buffers_with_damage");
248 
249 }
250 
251 static void
253 {
254  eglTerminate(display->egl.dpy);
255  eglReleaseThread();
256 }
257 
258 static GLuint
259 create_shader(struct window *window, const char *source, GLenum shader_type)
260 {
261  GLuint shader;
262  GLint status;
263 
264  shader = glCreateShader(shader_type);
265  assert(shader != 0);
266 
267  glShaderSource(shader, 1, (const char **) &source, NULL);
268  glCompileShader(shader);
269 
270  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
271  if (!status) {
272  char log[1000];
273  GLsizei len;
274  glGetShaderInfoLog(shader, 1000, &len, log);
275  HMI_ERROR(log_prefix,"Error: compiling %s: %*s",
276  shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
277  len, log);
278  exit(1);
279  }
280 
281  return shader;
282 }
283 
284 static void
286 {
287  GLuint frag, vert;
288  GLuint program;
289  GLint status;
290 
291  frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
292  vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);
293 
294  program = glCreateProgram();
295  glAttachShader(program, frag);
296  glAttachShader(program, vert);
297  glLinkProgram(program);
298 
299  glGetProgramiv(program, GL_LINK_STATUS, &status);
300  if (!status) {
301  char log[1000];
302  GLsizei len;
303  glGetProgramInfoLog(program, 1000, &len, log);
304  HMI_ERROR(log_prefix,"Error: linking:%*s", len, log);
305  exit(1);
306  }
307 
308  glUseProgram(program);
309 
310  window->gl.pos = 0;
311  window->gl.col = 1;
312 
313  glBindAttribLocation(program, window->gl.pos, "pos");
314  glBindAttribLocation(program, window->gl.col, "color");
315  glLinkProgram(program);
316 
317  window->gl.rotation_uniform =
318  glGetUniformLocation(program, "rotation");
319 }
320 
321 static void
323 {
324  uint32_t id_ivisurf = g_id_ivisurf;
325  window->ivi_surface =
326  ivi_application_surface_create(display->ivi_application,
327  id_ivisurf, window->surface);
328 
329  if (window->ivi_surface == NULL) {
330  HMI_ERROR(log_prefix,"Failed to create ivi_client_surface");
331  abort();
332  }
333 
334 }
335 
336 static void
338 {
339  struct display *display = window->display;
340  EGLBoolean ret;
341 
342  window->surface = wl_compositor_create_surface(display->compositor);
343 
344  window->native =
345  wl_egl_window_create(window->surface,
346  window->geometry.width,
347  window->geometry.height);
348  window->egl_surface =
349  weston_platform_create_egl_surface(display->egl.dpy,
350  display->egl.conf,
351  window->native, NULL);
352 
353 
354  if (display->ivi_application ) {
355  create_ivi_surface(window, display);
356  } else {
357  assert(0);
358  }
359 
360  ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
361  window->egl_surface, window->display->egl.ctx);
362  assert(ret == EGL_TRUE);
363 
364  if (!window->frame_sync)
365  eglSwapInterval(display->egl.dpy, 0);
366 
367 }
368 
369 static void
371 {
372  /* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
373  * on eglReleaseThread(). */
374  eglMakeCurrent(window->display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
375  EGL_NO_CONTEXT);
376 
377  eglDestroySurface(window->display->egl.dpy, window->egl_surface);
378  wl_egl_window_destroy(window->native);
379 
380  if (window->display->ivi_application)
381  ivi_surface_destroy(window->ivi_surface);
382  wl_surface_destroy(window->surface);
383 
384  if (window->callback)
385  wl_callback_destroy(window->callback);
386 }
387 
388 static void
389 redraw(void *data, struct wl_callback *callback, uint32_t time)
390 {
391  struct window *window = data;
392  struct display *display = window->display;
393  static const GLfloat verts[3][2] = {
394  { -0.5, -0.5 },
395  { 0.5, -0.5 },
396  { 0, 0.5 }
397  };
398 
399  static const GLfloat colors[3][3] = {
400  { 1, 0, 0 },
401  { 0, 1, 0 },
402  { 0, 0, 1 }
403  };
404 
405  GLfloat angle;
406  GLfloat rotation[4][4] = {
407  { 1, 0, 0, 0 },
408  { 0, 1, 0, 0 },
409  { 0, 0, 1, 0 },
410  { 0, 0, 0, 1 }
411  };
412  static const uint32_t speed_div = 5, benchmark_interval = 5;
413  struct wl_region *region;
414  EGLint rect[4];
415  EGLint buffer_age = 0;
416  struct timeval tv;
417 
418  assert(window->callback == callback);
419  window->callback = NULL;
420 
421  if (callback)
422  wl_callback_destroy(callback);
423 
424  gettimeofday(&tv, NULL);
425  time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
426  if (window->frames == 0)
427  window->benchmark_time = time;
428 
429  if (time - window->benchmark_time > (benchmark_interval * 1000)) {
430  HMI_DEBUG(log_prefix,"%d frames in %d seconds: %f fps",
431  window->frames,
432  benchmark_interval,
433  (float) window->frames / benchmark_interval);
434  window->benchmark_time = time;
435  window->frames = 0;
436  }
437 
438  angle = (time / speed_div) % 360 * M_PI / 180.0;
439  rotation[0][0] = cos(angle);
440  rotation[0][2] = sin(angle);
441  rotation[2][0] = -sin(angle);
442  rotation[2][2] = cos(angle);
443 
444  if (display->swap_buffers_with_damage)
445  eglQuerySurface(display->egl.dpy, window->egl_surface,
446  EGL_BUFFER_AGE_EXT, &buffer_age);
447 
448  glViewport(0, 0, window->geometry.width, window->geometry.height);
449 
450  glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
451  (GLfloat *) rotation);
452 
453  glClearColor(0.0, 0.0, 0.0, 0.5);
454  glClear(GL_COLOR_BUFFER_BIT);
455 
456  glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
457  glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
458  glEnableVertexAttribArray(window->gl.pos);
459  glEnableVertexAttribArray(window->gl.col);
460 
461  glDrawArrays(GL_TRIANGLES, 0, 3);
462 
463  glDisableVertexAttribArray(window->gl.pos);
464  glDisableVertexAttribArray(window->gl.col);
465 
466  if (window->opaque || window->fullscreen) {
467  region = wl_compositor_create_region(window->display->compositor);
468  wl_region_add(region, 0, 0,
469  window->geometry.width,
470  window->geometry.height);
471  wl_surface_set_opaque_region(window->surface, region);
472  wl_region_destroy(region);
473  } else {
474  wl_surface_set_opaque_region(window->surface, NULL);
475  }
476 
477  if (display->swap_buffers_with_damage && buffer_age > 0) {
478  rect[0] = window->geometry.width / 4 - 1;
479  rect[1] = window->geometry.height / 4 - 1;
480  rect[2] = window->geometry.width / 2 + 2;
481  rect[3] = window->geometry.height / 2 + 2;
482  display->swap_buffers_with_damage(display->egl.dpy,
483  window->egl_surface,
484  rect, 1);
485  } else {
486  eglSwapBuffers(display->egl.dpy, window->egl_surface);
487  }
488 
489  window->frames++;
490 }
491 
492 static void
493 registry_handle_global(void *data, struct wl_registry *registry,
494  uint32_t name, const char *interface, uint32_t version)
495 {
496  struct display *d = data;
497 
498  if (strcmp(interface, "wl_compositor") == 0) {
499  d->compositor =
500  wl_registry_bind(registry, name,
501  &wl_compositor_interface, 1);
502  } else if (strcmp(interface, "ivi_application") == 0) {
503  d->ivi_application =
504  wl_registry_bind(registry, name,
506  }
507 }
508 
509 static void
510 registry_handle_global_remove(void *data, struct wl_registry *registry,
511  uint32_t name)
512 {
513 }
514 
515 static const struct wl_registry_listener registry_listener = {
518 };
519 
520 static void
521 signal_int(int signum)
522 {
523  running = 0;
524 }
525 
526 int
527 init_wm(LibWindowmanager *wm, struct window *window)
528 {
529  HMI_DEBUG(log_prefix,"called");
530 
531  if (wm->init(port, token) != 0) {
532  HMI_ERROR(log_prefix,"wm init failed. ");
533  return -1;
534  }
535 
536  g_id_ivisurf = wm->requestSurface(main_role);
537  if (g_id_ivisurf < 0) {
538  HMI_ERROR(log_prefix,"wm request surface failed ");
539  return -1;
540  }
541  HMI_DEBUG(log_prefix,"IVI_SURFACE_ID: %d ", g_id_ivisurf);
542 
543  WMHandler wmh;
544  wmh.on_visible = [](const char* role, bool visible){
545  // Sample code if user uses visible event
546  HMI_DEBUG(log_prefix, "role: %s, visible: %s", role, visible ? "true" : "false");
547  };
548  wmh.on_sync_draw = [wm, window](const char* role, const char* area, Rect rect) {
549 
550  HMI_DEBUG(log_prefix,"Surface %s got syncDraw! Area: %s. w:%d, h:%d", role, area, rect.width(), rect.height());
551 
552  wl_egl_window_resize(window->native, rect.width(), rect.height(), 0, 0);
553  window->geometry.width = rect.width();
554  window->geometry.height = rect.height();
555 
556  wm->endDraw(role);
557  };
558 
559  wm->setEventHandler(wmh);
560 
561  return 0;
562 }
563 
564 int
566  if(hs->init(port, token)!=0)
567  {
568  HMI_ERROR(log_prefix,"homescreen init failed. ");
569  return -1;
570  }
571 
572  hs->set_event_handler(LibHomeScreen::Event_ShowWindow, [hs](json_object *object){
573  HMI_DEBUG("simple-egl","try to activeWindow %s ", app_name.c_str());
574 
575  struct json_object *param_obj = json_object_object_get(object, hs->_keyParameter);
576  const char *area = json_object_get_string(
577  json_object_object_get(param_obj, hs->_keyArea));
578  // Application should call LibWindowmanager::activateWindow() in showWindow handler
579  if(area == nullptr)
580  wm->activateWindow(main_role, hs->_areaNormal);
581  else
582  wm->activateWindow(main_role, area);
583  });
584 
585  return 0;
586 }
587 
588 int
589 main(int argc, char **argv)
590 {
591  struct sigaction sigint;
592  struct window window = { 0 };
593  struct display display = { 0 };
594 
595  window.display = &display;
596  display.window = &window;
597  window.geometry.width = 1080;
598  window.geometry.height = 1488;
599  window.window_size = window.geometry;
600  window.buffer_size = 32;
601  window.frame_sync = 1;
602 
603  if(argc > 2){
604  port = strtol(argv[1], NULL, 10);
605  token = argv[2];
606  }
607 
608  HMI_DEBUG(log_prefix,"main_role: %s, port: %d, token: %s. ", main_role, port, token.c_str());
609 
610  display.display = wl_display_connect(NULL);
611  assert(display.display);
612 
613  display.registry = wl_display_get_registry(display.display);
614  wl_registry_add_listener(display.registry,
615  &registry_listener, &display);
616 
617  wl_display_roundtrip(display.display);
618 
619  init_egl(&display, &window);
620 
621  wm = new LibWindowmanager();
622  if(init_wm(wm, &window)!=0){
623  fini_egl(&display);
624  if (display.ivi_application)
625  ivi_application_destroy(display.ivi_application);
626  if (display.compositor)
627  wl_compositor_destroy(display.compositor);
628  wl_registry_destroy(display.registry);
629  wl_display_flush(display.display);
630  return -1;
631  }
632 
633  hs = new LibHomeScreen();
634  if(init_hs(hs)!=0){
635  fini_egl(&display);
636  if (display.ivi_application)
637  ivi_application_destroy(display.ivi_application);
638  if (display.compositor)
639  wl_compositor_destroy(display.compositor);
640  wl_registry_destroy(display.registry);
641  wl_display_flush(display.display);
642  return -1;
643  }
644 
645  create_surface(&window);
646  init_gl(&window);
647 
648  //Ctrl+C
649  sigint.sa_handler = signal_int;
650  sigemptyset(&sigint.sa_mask);
651  sigint.sa_flags = SA_RESETHAND;
652  sigaction(SIGINT, &sigint, NULL);
653 
654  eglSwapBuffers(window.display->egl.dpy, window.egl_surface);
655 
656  wm->activateWindow(main_role);
657 
658  /* The mainloop here is a little subtle. Redrawing will cause
659  * EGL to read events so we can just call
660  * wl_display_dispatch_pending() to handle any events that got
661  * queued up as a side effect. */
662  while (running) {
663  wl_display_dispatch_pending(display.display);
664  redraw(&window, NULL, 0);
665  }
666 
667  HMI_DEBUG(log_prefix,"simple-egl exiting! ");
668 
669  destroy_surface(&window);
670  fini_egl(&display);
671 
672  if (display.ivi_application)
673  ivi_application_destroy(display.ivi_application);
674 
675  if (display.compositor)
676  wl_compositor_destroy(display.compositor);
677 
678  wl_registry_destroy(display.registry);
679  wl_display_flush(display.display);
680  wl_display_disconnect(display.display);
681 
682  return 0;
683 }
static const struct wl_message ivi_surface_events[]
Definition: simple-egl.cpp:81
struct window * window
Definition: simple-egl.cpp:126
static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version)
Definition: simple-egl.cpp:493
GLuint rotation_uniform
Definition: simple-egl.cpp:140
LibWindowmanager * wm
Definition: simple-egl.cpp:67
struct wl_seat * seat
Definition: simple-egl.cpp:120
static void init_gl(struct window *window)
Definition: simple-egl.cpp:285
uint32_t g_id_ivisurf
Definition: simple-egl.cpp:59
int init_wm(LibWindowmanager *wm, struct window *window)
Definition: simple-egl.cpp:527
EGLSurface surface
Definition: simple-egl.cpp:105
struct window::@1 gl
const struct wl_interface ivi_surface_interface
Definition: simple-egl.cpp:85
const char * main_role
Definition: simple-egl.cpp:64
uint32_t benchmark_time
Definition: simple-egl.cpp:145
int opaque
Definition: simple-egl.cpp:151
typedef EGLBoolean(EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy
EGLSurface EGLint * rects
Definition: simple-egl.cpp:105
static const struct wl_interface * types[]
Definition: simple-egl.cpp:69
static const struct wl_message ivi_application_requests[]
Definition: simple-egl.cpp:91
const char * _keyParameter
EGLDisplay dpy
Definition: simple-egl.cpp:122
EGLSurface egl_surface
Definition: simple-egl.cpp:149
string app_name
Definition: simple-egl.cpp:63
static GLuint create_shader(struct window *window, const char *source, GLenum shader_type)
Definition: simple-egl.cpp:259
GLuint pos
Definition: simple-egl.cpp:141
#define EGL_BUFFER_AGE_EXT
Definition: simple-egl.cpp:110
static void signal_int(int signum)
Definition: simple-egl.cpp:521
static const char * frag_shader_text
Definition: simple-egl.cpp:164
static void create_surface(struct window *window)
Definition: simple-egl.cpp:337
static void redraw(void *data, struct wl_callback *callback, uint32_t time)
Definition: simple-egl.cpp:389
EGLConfig conf
Definition: simple-egl.cpp:124
struct wl_egl_window * native
Definition: simple-egl.cpp:146
EGLSurface EGLint EGLint n_rects
Definition: simple-egl.cpp:105
string token
Definition: simple-egl.cpp:61
struct wl_surface * surface
Definition: simple-egl.cpp:147
static const char * vert_shader_text
Definition: simple-egl.cpp:154
struct ivi_application * ivi_application
Definition: simple-egl.cpp:127
LibHomeScreen * hs
Definition: simple-egl.cpp:66
struct display::@0 egl
GLuint col
Definition: simple-egl.cpp:142
struct wl_callback * callback
Definition: simple-egl.cpp:150
PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC swap_buffers_with_damage
Definition: simple-egl.cpp:129
const struct wl_interface ivi_application_interface
Definition: simple-egl.cpp:95
struct wl_registry * registry
Definition: simple-egl.cpp:118
static int running
Definition: simple-egl.cpp:171
struct display * display
Definition: simple-egl.cpp:137
const char * _keyArea
EGLContext ctx
Definition: simple-egl.cpp:123
long port
Definition: simple-egl.cpp:60
static const struct wl_registry_listener registry_listener
Definition: simple-egl.cpp:515
static void create_ivi_surface(struct window *window, struct display *display)
Definition: simple-egl.cpp:322
struct ivi_surface * ivi_surface
Definition: simple-egl.cpp:148
struct geometry geometry window_size
Definition: simple-egl.cpp:138
int init(const int port, const std::string &token)
int frame_sync
Definition: simple-egl.cpp:151
struct wl_display * display
Definition: simple-egl.cpp:117
static void fini_egl(struct display *display)
Definition: simple-egl.cpp:252
#define HMI_ERROR(prefix, args,...)
Definition: hmi-debug.h:38
static void init_egl(struct display *display, struct window *window)
Definition: simple-egl.cpp:174
#define HMI_DEBUG(prefix, args,...)
Definition: hmi-debug.h:42
const char * _areaNormal
static void registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
Definition: simple-egl.cpp:510
int main(int argc, char **argv)
Definition: simple-egl.cpp:589
struct wl_compositor * compositor
Definition: simple-egl.cpp:119
int buffer_size
Definition: simple-egl.cpp:151
const char * log_prefix
Definition: simple-egl.cpp:58
static void destroy_surface(struct window *window)
Definition: simple-egl.cpp:370
int fullscreen
Definition: simple-egl.cpp:151
int init_hs(LibHomeScreen *hs)
Definition: simple-egl.cpp:565
static const struct wl_message ivi_surface_requests[]
Definition: simple-egl.cpp:77
uint32_t frames
Definition: simple-egl.cpp:145
void set_event_handler(enum EventType et, handler_func f)