#define _GNU_SOURCE
#include <stdlib.h>
-#include <stdio.h>
#include <string.h>
#include <linux/input.h>
#include <fcntl.h>
EGLint code;
code = eglGetError();
- fprintf(stderr, "EGL error state: %s (0x%04lx)\n",
+ weston_log("EGL error state: %s (0x%04lx)\n",
egl_error_string(code), (long)code);
}
if (errored)
return -1;
errored = 1;
- fprintf(stderr, "Failed to make EGL context current.\n");
+ weston_log("Failed to make EGL context current.\n");
print_egl_error_state();
return -1;
}
ret = eglSwapBuffers(compositor->base.display, output->egl_surface);
if (ret == EGL_FALSE && !errored) {
errored = 1;
- fprintf(stderr, "Failed in eglSwapBuffers.\n");
+ weston_log("Failed in eglSwapBuffers.\n");
print_egl_error_state();
}
compositor->base.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (compositor->base.display == EGL_NO_DISPLAY) {
- fprintf(stderr, "Failed to create EGL display.\n");
+ weston_log("Failed to create EGL display.\n");
print_egl_error_state();
return -1;
}
ret = eglInitialize(compositor->base.display, &eglmajor, &eglminor);
if (!ret) {
- fprintf(stderr, "Failed to initialise EGL.\n");
+ weston_log("Failed to initialise EGL.\n");
print_egl_error_state();
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
- fprintf(stderr, "Failed to bind EGL_OPENGL_ES_API.\n");
+ weston_log("Failed to bind EGL_OPENGL_ES_API.\n");
print_egl_error_state();
return -1;
}
ret = android_egl_choose_config(compositor, output->fb, config_attrs);
if (ret < 0) {
- fprintf(stderr, "Failed to find an EGL config.\n");
+ weston_log("Failed to find an EGL config.\n");
print_egl_error_state();
return -1;
}
EGL_NO_CONTEXT,
context_attrs);
if (compositor->base.context == EGL_NO_CONTEXT) {
- fprintf(stderr, "Failed to create a GL ES 2 context.\n");
+ weston_log("Failed to create a GL ES 2 context.\n");
print_egl_error_state();
return -1;
}
output->fb->native_window,
NULL);
if (output->egl_surface == EGL_NO_SURFACE) {
- fprintf(stderr, "Failed to create FB EGLSurface.\n");
+ weston_log("Failed to create FB EGLSurface.\n");
print_egl_error_state();
return -1;
}
#define _GNU_SOURCE
#include <errno.h>
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "compositor.h"
#include "evdev.h"
#include "launcher-util.h"
+#include "log.h"
struct drm_compositor {
struct weston_compositor base;
ret = drmModeAddFB(compositor->drm.fd, width, height, 24, 32,
stride, handle, &fb->fb_id);
if (ret) {
- fprintf(stderr, "failed to create kms fb: %m\n");
+ weston_log("failed to create kms fb: %m\n");
free(fb);
return NULL;
}
if (!eglMakeCurrent(compositor->base.display, output->egl_surface,
output->egl_surface, compositor->base.context)) {
- fprintf(stderr, "failed to make current\n");
+ weston_log("failed to make current\n");
return;
}
eglSwapBuffers(compositor->base.display, output->egl_surface);
bo = gbm_surface_lock_front_buffer(output->surface);
if (!bo) {
- fprintf(stderr, "failed to lock front buffer: %m\n");
+ weston_log("failed to lock front buffer: %m\n");
return;
}
output->next = drm_fb_get_from_bo(bo, output);
if (!output->next) {
- fprintf(stderr, "failed to get drm_fb for bo\n");
+ weston_log("failed to get drm_fb for bo\n");
gbm_surface_release_buffer(output->surface, bo);
return;
}
&output->connector_id, 1,
&mode->mode_info);
if (ret) {
- fprintf(stderr, "set mode failed: %m\n");
+ weston_log("set mode failed: %m\n");
return;
}
}
if (drmModePageFlip(compositor->drm.fd, output->crtc_id,
output->next->fb_id,
DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
- fprintf(stderr, "queueing pageflip failed: %m\n");
+ weston_log("queueing pageflip failed: %m\n");
return;
}
s->src_x, s->src_y,
s->src_w, s->src_h);
if (ret)
- fprintf(stderr, "setplane failed: %d: %s\n",
+ weston_log("setplane failed: %d: %s\n",
ret, strerror(errno));
/*
vbl.request.signal = (unsigned long)s;
ret = drmWaitVBlank(compositor->drm.fd, &vbl);
if (ret) {
- fprintf(stderr, "vblank event request failed: %d: %s\n",
+ weston_log("vblank event request failed: %d: %s\n",
ret, strerror(errno));
}
}
output->crtc_id, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0);
if (ret)
- fprintf(stderr,
- "failed to disable plane: %d: %s\n",
+ weston_log("failed to disable plane: %d: %s\n",
ret, strerror(errno));
drmModeRmFB(c->drm.fd, s->fb_id);
s->surface = NULL;
format, handles, pitches, offsets,
&fb_id, 0);
if (ret) {
- fprintf(stderr, "addfb2 failed: %d\n", ret);
+ weston_log("addfb2 failed: %d\n", ret);
c->sprites_are_broken = 1;
return -1;
}
handle = gbm_bo_get_handle(bo).s32;
ret = drmModeSetCursor(c->drm.fd, output->crtc_id, handle, 64, 64);
if (ret) {
- fprintf(stderr, "failed to set cursor: %s\n", strerror(-ret));
+ weston_log("failed to set cursor: %s\n", strerror(-ret));
goto out;
}
es->sprite->geometry.x - output->base.x,
es->sprite->geometry.y - output->base.y);
if (ret) {
- fprintf(stderr, "failed to move cursor: %s\n", strerror(-ret));
+ weston_log("failed to move cursor: %s\n", strerror(-ret));
goto out;
}
EGLSurface egl_surface;
if (output_base == NULL) {
- fprintf(stderr, "output is NULL.\n");
+ weston_log("output is NULL.\n");
return -1;
}
if (mode == NULL) {
- fprintf(stderr, "mode is NULL.\n");
+ weston_log("mode is NULL.\n");
return -1;
}
drm_mode = choose_mode (output, mode);
if (!drm_mode) {
- printf("%s, invalid resolution:%dx%d\n", __func__, mode->width, mode->height);
+ weston_log("%s, invalid resolution:%dx%d\n", __func__, mode->width, mode->height);
return -1;
} else if (&drm_mode->base == output->base.current) {
return 0;
&output->connector_id, 1, &drm_mode->mode_info);
if (ret) {
- fprintf(stderr, "failed to set mode (%dx%d) %u Hz\n",
+ weston_log("failed to set mode (%dx%d) %u Hz\n",
drm_mode->base.width,
drm_mode->base.height,
drm_mode->base.refresh / 1000);
GBM_BO_USE_SCANOUT |
GBM_BO_USE_RENDERING);
if (!surface) {
- fprintf(stderr, "failed to create gbm surface\n");
+ weston_log("failed to create gbm surface\n");
return -1;
}
surface, NULL);
if (egl_surface == EGL_NO_SURFACE) {
- fprintf(stderr, "failed to create egl surface\n");
+ weston_log("failed to create egl surface\n");
goto err;
}
output->current->fb_id, 0, 0,
&output->connector_id, 1, &drm_mode->mode_info);
if (ret) {
- fprintf(stderr, "failed to set mode\n");
+ weston_log("failed to set mode\n");
goto err;
}
if (sysnum)
ec->drm.id = atoi(sysnum);
if (!sysnum || ec->drm.id < 0) {
- fprintf(stderr, "cannot get device sysnum\n");
+ weston_log("cannot get device sysnum\n");
return -1;
}
fd = open(filename, O_RDWR | O_CLOEXEC);
if (fd < 0) {
/* Probably permissions error */
- fprintf(stderr, "couldn't open %s, skipping\n",
+ weston_log("couldn't open %s, skipping\n",
udev_device_get_devnode(device));
return -1;
}
ec->gbm = gbm_create_device(ec->drm.fd);
ec->base.display = eglGetDisplay(ec->gbm);
if (ec->base.display == NULL) {
- fprintf(stderr, "failed to create display\n");
+ weston_log("failed to create display\n");
return -1;
}
if (!eglInitialize(ec->base.display, &major, &minor)) {
- fprintf(stderr, "failed to initialize display\n");
+ weston_log("failed to initialize display\n");
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
- fprintf(stderr, "failed to bind api EGL_OPENGL_ES_API\n");
+ weston_log("failed to bind api EGL_OPENGL_ES_API\n");
return -1;
}
if (!eglChooseConfig(ec->base.display, config_attribs,
&ec->base.config, 1, &n) || n != 1) {
- fprintf(stderr, "failed to choose config: %d\n", n);
+ weston_log("failed to choose config: %d\n", n);
return -1;
}
ec->base.context = eglCreateContext(ec->base.display, ec->base.config,
EGL_NO_CONTEXT, context_attribs);
if (ec->base.context == NULL) {
- fprintf(stderr, "failed to create context\n");
+ weston_log("failed to create context\n");
return -1;
}
GBM_FORMAT_XRGB8888,
GBM_BO_USE_RENDERING);
if (!ec->dummy_surface) {
- fprintf(stderr, "failed to create dummy gbm surface\n");
+ weston_log("failed to create dummy gbm surface\n");
return -1;
}
eglCreateWindowSurface(ec->base.display, ec->base.config,
ec->dummy_surface, NULL);
if (ec->dummy_egl_surface == EGL_NO_SURFACE) {
- fprintf(stderr, "failed to create egl surface\n");
+ weston_log("failed to create egl surface\n");
return -1;
}
if (!eglMakeCurrent(ec->base.display, ec->dummy_egl_surface,
ec->dummy_egl_surface, ec->base.context)) {
- fprintf(stderr, "failed to make context current\n");
+ weston_log("failed to make context current\n");
return -1;
}
encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[0]);
if (encoder == NULL) {
- fprintf(stderr, "No encoder for connector.\n");
+ weston_log("No encoder for connector.\n");
return -1;
}
break;
}
if (i == resources->count_crtcs) {
- fprintf(stderr, "No usable crtc for encoder.\n");
+ weston_log("No usable crtc for encoder.\n");
drmModeFreeEncoder(encoder);
return -1;
}
GBM_BO_USE_SCANOUT |
GBM_BO_USE_RENDERING);
if (!output->surface) {
- fprintf(stderr, "failed to create gbm surface\n");
+ weston_log("failed to create gbm surface\n");
goto err_free;
}
eglCreateWindowSurface(ec->base.display, ec->base.config,
output->surface, NULL);
if (output->egl_surface == EGL_NO_SURFACE) {
- fprintf(stderr, "failed to create egl surface\n");
+ weston_log("failed to create egl surface\n");
goto err_surface;
}
plane_res = drmModeGetPlaneResources(ec->drm.fd);
if (!plane_res) {
- fprintf(stderr, "failed to get plane resources: %s\n",
+ weston_log("failed to get plane resources: %s\n",
strerror(errno));
return;
}
sprite = malloc(sizeof(*sprite) + ((sizeof(uint32_t)) *
plane->count_formats));
if (!sprite) {
- fprintf(stderr, "%s: out of memory\n",
+ weston_log("%s: out of memory\n",
__func__);
free(plane);
continue;
resources = drmModeGetResources(ec->drm.fd);
if (!resources) {
- fprintf(stderr, "drmModeGetResources failed\n");
+ weston_log("drmModeGetResources failed\n");
return -1;
}
}
if (wl_list_empty(&ec->base.output_list)) {
- fprintf(stderr, "No currently active connector found.\n");
+ weston_log("No currently active connector found.\n");
drmModeFreeResources(resources);
return -1;
}
resources = drmModeGetResources(ec->drm.fd);
if (!resources) {
- fprintf(stderr, "drmModeGetResources failed\n");
+ weston_log("drmModeGetResources failed\n");
return;
}
create_output_for_connector(ec, resources,
connector, x, y,
drm_device);
- printf("connector %d connected\n", connector_id);
+ weston_log("connector %d connected\n", connector_id);
}
drmModeFreeConnector(connector);
if (disconnects & (1 << output->connector_id)) {
disconnects &= ~(1 << output->connector_id);
- printf("connector %d disconnected\n",
+ weston_log("connector %d disconnected\n",
output->connector_id);
x_offset += output->base.current->width;
drm_output_destroy(&output->base);
gbm_device_destroy(d->gbm);
destroy_sprites(d);
if (weston_launcher_drm_set_master(&d->base, d->drm.fd, 0) < 0)
- fprintf(stderr, "failed to drop master: %m\n");
+ weston_log("failed to drop master: %m\n");
tty_destroy(d->tty);
free(d);
&output->connector_id, 1,
&drm_mode->mode_info);
if (ret < 0) {
- fprintf(stderr,
+ weston_log(
"failed to set mode %dx%d for output at %d,%d: %m\n",
drm_mode->base.width, drm_mode->base.height,
output->base.x, output->base.y);
case TTY_ENTER_VT:
compositor->focus = 1;
if (weston_launcher_drm_set_master(&ec->base, ec->drm.fd, 1)) {
- fprintf(stderr, "failed to set master: %m\n");
+ weston_log("failed to set master: %m\n");
wl_display_terminate(compositor->wl_display);
}
compositor->state = ec->prev_state;
0, 0, 0, 0, 0, 0, 0, 0);
if (weston_launcher_drm_set_master(&ec->base, ec->drm.fd, 0) < 0)
- fprintf(stderr, "failed to drop master: %m\n");
+ weston_log("failed to drop master: %m\n");
break;
};
memset(ec, 0, sizeof *ec);
ec->udev = udev_new();
if (ec->udev == NULL) {
- fprintf(stderr, "failed to initialize udev context\n");
+ weston_log("failed to initialize udev context\n");
return NULL;
}
ec->base.wl_display = display;
ec->tty = tty_create(&ec->base, vt_func, tty);
if (!ec->tty) {
- fprintf(stderr, "failed to initialize tty\n");
+ weston_log("failed to initialize tty\n");
free(ec);
return NULL;
}
}
if (drm_device == NULL) {
- fprintf(stderr, "no drm device found\n");
+ weston_log("no drm device found\n");
return NULL;
}
if (init_egl(ec, drm_device) < 0) {
- fprintf(stderr, "failed to initialize egl\n");
+ weston_log("failed to initialize egl\n");
return NULL;
}
create_sprites(ec);
if (create_outputs(ec, connector, drm_device) < 0) {
- fprintf(stderr, "failed to create output for %s\n", path);
+ weston_log("failed to create output for %s\n", path);
return NULL;
}
ec->udev_monitor = udev_monitor_new_from_netlink(ec->udev, "udev");
if (ec->udev_monitor == NULL) {
- fprintf(stderr, "failed to intialize udev monitor\n");
+ weston_log("failed to intialize udev monitor\n");
return NULL;
}
udev_monitor_filter_add_match_subsystem_devtype(ec->udev_monitor,
WL_EVENT_READABLE, udev_drm_event, ec);
if (udev_monitor_enable_receiving(ec->udev_monitor) < 0) {
- fprintf(stderr, "failed to enable udev-monitor receiving\n");
+ weston_log("failed to enable udev-monitor receiving\n");
return NULL;
}
#define _GNU_SOURCE
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "compositor.h"
#include "evdev.h"
+#include "log.h"
struct wfd_compositor {
struct weston_compositor base;
ec->gbm = gbm_create_device(ec->wfd_fd);
ec->base.display = eglGetDisplay(ec->gbm);
if (ec->base.display == NULL) {
- fprintf(stderr, "failed to create display\n");
+ weston_log("failed to create display\n");
return -1;
}
if (!eglInitialize(ec->base.display, &major, &minor)) {
- fprintf(stderr, "failed to initialize display\n");
+ weston_log("failed to initialize display\n");
return -1;
}
extensions = eglQueryString(ec->base.display, EGL_EXTENSIONS);
if (!strstr(extensions, "EGL_KHR_surfaceless_gles2")) {
- fprintf(stderr, "EGL_KHR_surfaceless_gles2 not available\n");
+ weston_log("EGL_KHR_surfaceless_gles2 not available\n");
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
- fprintf(stderr, "failed to bind api EGL_OPENGL_ES_API\n");
+ weston_log("failed to bind api EGL_OPENGL_ES_API\n");
return -1;
}
ec->base.context = eglCreateContext(ec->base.display, NULL,
EGL_NO_CONTEXT, context_attribs);
if (ec->base.context == NULL) {
- fprintf(stderr, "failed to create context\n");
+ weston_log("failed to create context\n");
return -1;
}
if (!eglMakeCurrent(ec->base.display, EGL_NO_SURFACE,
EGL_NO_SURFACE, ec->base.context)) {
- fprintf(stderr, "failed to make context current\n");
+ weston_log("failed to make context current\n");
return -1;
}
num_modes = wfdGetPortModes(ec->dev, output->port, NULL, 0);
if (num_modes < 1) {
- fprintf(stderr, "failed to get port mode\n");
+ weston_log("failed to get port mode\n");
goto cleanup_port;
}
}
}
if (output->base.current == NULL) {
- fprintf(stderr, "failed to find a native mode\n");
+ weston_log("failed to find a native mode\n");
goto cleanup_port;
}
num_pipelines = wfdGetPortAttribi(ec->dev, output->port,
WFD_PORT_PIPELINE_ID_COUNT);
if (num_pipelines < 1) {
- fprintf(stderr, "failed to get a bindable pipeline\n");
+ weston_log("failed to get a bindable pipeline\n");
goto cleanup_port;
}
pipelines = calloc(num_pipelines, sizeof *pipelines);
}
}
if (output->pipeline_id == WFD_INVALID_PIPELINE_ID) {
- fprintf(stderr, "no pipeline found for port: %d\n", port);
+ weston_log("no pipeline found for port: %d\n", port);
goto cleanup_pipelines;
}
output->pipeline = wfdCreatePipeline(ec->dev, output->pipeline_id, NULL);
if (output->pipeline == WFD_INVALID_HANDLE) {
- fprintf(stderr, "failed to create a pipeline\n");
+ weston_log("failed to create a pipeline\n");
goto cleanup_weston_output;
}
EGL_NATIVE_PIXMAP_KHR,
output->bo[i], NULL);
- printf("output->image[i]: %p\n", output->image[i]);
+ weston_log("output->image[i]: %p\n", output->image[i]);
ec->base.image_target_renderbuffer_storage(GL_RENDERBUFFER,
output->image[i]);
output->source[i] =
output->image[i], NULL);
if (output->source[i] == WFD_INVALID_HANDLE) {
- fprintf(stderr, "failed to create source\n");
+ weston_log("failed to create source\n");
goto cleanup_pipeline;
}
}
ec->udev = udev_new();
if (ec->udev == NULL) {
- fprintf(stderr, "failed to initialize udev context\n");
+ weston_log("failed to initialize udev context\n");
return NULL;
}
ec->dev = wfdCreateDevice(WFD_DEFAULT_DEVICE_ID, NULL);
if (ec->dev == WFD_INVALID_HANDLE) {
- fprintf(stderr, "failed to create wfd device\n");
+ weston_log("failed to create wfd device\n");
return NULL;
}
ec->event = wfdCreateEvent(ec->dev, NULL);
if (ec->event == WFD_INVALID_HANDLE) {
- fprintf(stderr, "failed to create wfd event\n");
+ weston_log("failed to create wfd event\n");
return NULL;
}
ec->base.wl_display = display;
if (init_egl(ec) < 0) {
- fprintf(stderr, "failed to initialize egl\n");
+ weston_log("failed to initialize egl\n");
return NULL;
}
return NULL;
if (create_outputs(ec, connector) < 0) {
- fprintf(stderr, "failed to create outputs\n");
+ weston_log("failed to create outputs\n");
return NULL;
}
#include <EGL/eglext.h>
#include "compositor.h"
+#include "log.h"
struct wayland_compositor {
struct weston_compositor base;
image = load_image(DATADIR "/weston/border.png");
if (!image) {
- fprintf(stderr, "could'nt load border image\n");
+ weston_log("could'nt load border image\n");
return;
}
c->base.display = eglGetDisplay(c->parent.display);
if (c->base.display == NULL) {
- fprintf(stderr, "failed to create display\n");
+ weston_log("failed to create display\n");
return -1;
}
if (!eglInitialize(c->base.display, &major, &minor)) {
- fprintf(stderr, "failed to initialize display\n");
+ weston_log("failed to initialize display\n");
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
- fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n");
+ weston_log("failed to bind EGL_OPENGL_ES_API\n");
return -1;
}
if (!eglChooseConfig(c->base.display, config_attribs,
&c->base.config, 1, &n) || n == 0) {
- fprintf(stderr, "failed to choose config: %d\n", n);
+ weston_log("failed to choose config: %d\n", n);
return -1;
}
c->base.context = eglCreateContext(c->base.display, c->base.config,
EGL_NO_CONTEXT, context_attribs);
if (c->base.context == NULL) {
- fprintf(stderr, "failed to create context\n");
+ weston_log("failed to create context\n");
return -1;
}
c->dummy_pixmap = wl_egl_pixmap_create(10, 10, 0);
if (!c->dummy_pixmap) {
- fprintf(stderr, "failure to create dummy_pixmap\n");
+ weston_log("failure to create dummy_pixmap\n");
return -1;
}
c->dummy_pixmap, NULL);
if (!eglMakeCurrent(c->base.display, c->dummy_egl_surface,
c->dummy_egl_surface, c->base.context)) {
- fprintf(stderr, "failed to make context current\n");
+ weston_log("failed to make context current\n");
return -1;
}
if (!eglMakeCurrent(compositor->base.display, output->egl_surface,
output->egl_surface, compositor->base.context)) {
- fprintf(stderr, "failed to make current\n");
+ weston_log("failed to make current\n");
return;
}
width + c->border.left + c->border.right,
height + c->border.top + c->border.bottom);
if (!output->parent.egl_window) {
- fprintf(stderr, "failure to create wl_egl_window\n");
+ weston_log("failure to create wl_egl_window\n");
goto cleanup_output;
}
eglCreateWindowSurface(c->base.display, c->base.config,
output->parent.egl_window, NULL);
if (!output->egl_surface) {
- fprintf(stderr, "failed to create window surface\n");
+ weston_log("failed to create window surface\n");
goto cleanup_window;
}
if (!eglMakeCurrent(c->base.display, output->egl_surface,
output->egl_surface, c->base.context)) {
- fprintf(stderr, "failed to make surface current\n");
+ weston_log("failed to make surface current\n");
goto cleanup_surface;
return -1;
}
close(fd);
if (!keymap) {
- fprintf(stderr, "failed to compile keymap\n");
+ weston_log("failed to compile keymap\n");
return;
}
c->parent.display = wl_display_connect(display_name);
if (c->parent.display == NULL) {
- fprintf(stderr, "failed to create display: %m\n");
+ weston_log("failed to create display: %m\n");
return NULL;
}
#endif
#include <stddef.h>
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "compositor.h"
#include "../shared/config-parser.h"
+#include "log.h"
struct x11_compositor {
struct weston_compositor base;
c->base.display = eglGetDisplay(c->dpy);
if (c->base.display == NULL) {
- fprintf(stderr, "failed to create display\n");
+ weston_log("failed to create display\n");
return -1;
}
if (!eglInitialize(c->base.display, &major, &minor)) {
- fprintf(stderr, "failed to initialize display\n");
+ weston_log("failed to initialize display\n");
return -1;
}
if (!eglBindAPI(EGL_OPENGL_ES_API)) {
- fprintf(stderr, "failed to bind EGL_OPENGL_ES_API\n");
+ weston_log("failed to bind EGL_OPENGL_ES_API\n");
return -1;
}
if (!eglChooseConfig(c->base.display, config_attribs,
&c->base.config, 1, &n) || n == 0) {
- fprintf(stderr, "failed to choose config: %d\n", n);
+ weston_log("failed to choose config: %d\n", n);
return -1;
}
c->base.context = eglCreateContext(c->base.display, c->base.config,
EGL_NO_CONTEXT, context_attribs);
if (c->base.context == NULL) {
- fprintf(stderr, "failed to create context\n");
+ weston_log("failed to create context\n");
return -1;
}
c->base.config,
pbuffer_attribs);
if (c->dummy_pbuffer == NULL) {
- fprintf(stderr, "failed to create dummy pbuffer\n");
+ weston_log("failed to create dummy pbuffer\n");
return -1;
}
if (!eglMakeCurrent(c->base.display, c->dummy_pbuffer,
c->dummy_pbuffer, c->base.context)) {
- fprintf(stderr, "failed to make context current\n");
+ weston_log("failed to make context current\n");
return -1;
}
if (!eglMakeCurrent(compositor->base.display, output->egl_surface,
output->egl_surface, compositor->base.context)) {
- fprintf(stderr, "failed to make current\n");
+ weston_log("failed to make current\n");
return;
}
eglCreateWindowSurface(c->base.display, c->base.config,
output->window, NULL);
if (!output->egl_surface) {
- fprintf(stderr, "failed to create window surface\n");
+ weston_log("failed to create window surface\n");
return -1;
}
if (!eglMakeCurrent(c->base.display, output->egl_surface,
output->egl_surface, c->base.context)) {
- fprintf(stderr, "failed to make surface current\n");
+ weston_log("failed to make surface current\n");
return -1;
}
}
if (&p->link == &child_process_list) {
- fprintf(stderr, "unknown child process exited\n");
+ weston_log("unknown child process exited\n");
return 1;
}
* non-CLOEXEC fd to pass through exec. */
clientfd = dup(sockfd);
if (clientfd == -1) {
- fprintf(stderr, "compositor: dup failed: %m\n");
+ weston_log("compositor: dup failed: %m\n");
return;
}
setenv("WAYLAND_SOCKET", s, 1);
if (execl(path, path, NULL) < 0)
- fprintf(stderr, "compositor: executing '%s' failed: %m\n",
+ weston_log("compositor: executing '%s' failed: %m\n",
path);
}
struct wl_client *client;
if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
- fprintf(stderr, "weston_client_launch: "
+ weston_log("weston_client_launch: "
"socketpair failed while launching '%s': %m\n",
path);
return NULL;
if (pid == -1) {
close(sv[0]);
close(sv[1]);
- fprintf(stderr, "weston_client_launch: "
+ weston_log("weston_client_launch: "
"fork failed while launching '%s': %m\n", path);
return NULL;
}
client = wl_client_create(compositor->wl_display, sv[0]);
if (!client) {
close(sv[0]);
- fprintf(stderr, "weston_client_launch: "
+ weston_log("weston_client_launch: "
"wl_client_create failed while launching '%s'.\n",
path);
return NULL;
weston_matrix_transform(&surface->transform.matrix, &v);
if (fabsf(v.f[3]) < 1e-6) {
- fprintf(stderr, "warning: numerical instability in "
+ weston_log("warning: numerical instability in "
"weston_surface_to_global(), divisor = %g\n",
v.f[3]);
*x = 0;
if (weston_matrix_invert(inverse, matrix) < 0) {
/* Oops, bad total transformation, not invertible */
- fprintf(stderr, "error: weston_surface %p"
+ weston_log("error: weston_surface %p"
" transformation not invertible.\n", surface);
return -1;
}
weston_matrix_transform(&surface->transform.inverse, &v);
if (fabsf(v.f[3]) < 1e-6) {
- fprintf(stderr, "warning: numerical instability in "
+ weston_log("warning: numerical instability in "
"weston_surface_from_global(), divisor = %g\n",
v.f[3]);
*sx = 0;
find_resource_for_client(&seat->touch->resource_list,
surface->resource.client);
if (!resource) {
- fprintf(stderr, "couldn't find resource\n");
+ weston_log("couldn't find resource\n");
return;
}
if (ec->xkb_context == NULL) {
ec->xkb_context = xkb_context_new(0);
if (ec->xkb_context == NULL) {
- fprintf(stderr, "failed to create XKB context\n");
+ weston_log("failed to create XKB context\n");
exit(1);
}
}
keymap_str = xkb_map_get_as_string(xkb_info->keymap);
if (keymap_str == NULL) {
- fprintf(stderr, "failed to get string version of keymap\n");
+ weston_log("failed to get string version of keymap\n");
exit(EXIT_FAILURE);
}
xkb_info->keymap_size = strlen(keymap_str) + 1;
xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
if (xkb_info->keymap_fd < 0) {
- fprintf(stderr,
- "creating a keymap file for %lu bytes failed: %m\n",
+ weston_log("creating a keymap file for %lu bytes failed: %m\n",
(unsigned long) xkb_info->keymap_size);
goto err_keymap_str;
}
PROT_READ | PROT_WRITE,
MAP_SHARED, xkb_info->keymap_fd, 0);
if (xkb_info->keymap_area == MAP_FAILED) {
- fprintf(stderr, "failed to mmap() %lu bytes\n",
+ weston_log("failed to mmap() %lu bytes\n",
(unsigned long) xkb_info->keymap_size);
goto err_dev_zero;
}
&ec->xkb_names,
0);
if (ec->xkb_info.keymap == NULL) {
- fprintf(stderr, "failed to compile global XKB keymap\n");
- fprintf(stderr,
- " tried rules %s, model %s, layout %s, variant %s, "
+ weston_log("failed to compile global XKB keymap\n");
+ weston_log(" tried rules %s, model %s, layout %s, variant %s, "
"options %s",
ec->xkb_names.rules, ec->xkb_names.model,
ec->xkb_names.layout, ec->xkb_names.variant,
seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap);
if (seat->xkb_state.state == NULL) {
- fprintf(stderr, "failed to initialise XKB state\n");
+ weston_log("failed to initialise XKB state\n");
exit(1);
}
glGetShaderiv(s, GL_COMPILE_STATUS, &status);
if (!status) {
glGetShaderInfoLog(s, sizeof msg, NULL, msg);
- fprintf(stderr, "shader info: %s\n", msg);
+ weston_log("shader info: %s\n", msg);
return GL_NONE;
}
glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
if (!status) {
glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
- fprintf(stderr, "link info: %s\n", msg);
+ weston_log("link info: %s\n", msg);
return -1;
}
extensions = (const char *) glGetString(GL_EXTENSIONS);
if (!extensions) {
- fprintf(stderr, "Retrieving GL extension string failed.\n");
+ weston_log("Retrieving GL extension string failed.\n");
return -1;
}
if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
- fprintf(stderr,
- "GL_EXT_texture_format_BGRA8888 not available\n");
+ weston_log("GL_EXT_texture_format_BGRA8888 not available\n");
return -1;
}
extensions =
(const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
if (!extensions) {
- fprintf(stderr, "Retrieving EGL extension string failed.\n");
+ weston_log("Retrieving EGL extension string failed.\n");
return -1;
}
{
struct wl_display *display = data;
- fprintf(stderr, "caught signal %d\n", signal_number);
+ weston_log("caught signal %d\n", signal_number);
wl_display_terminate(display);
return 1;
int i, count;
Dl_info info;
- fprintf(stderr, "caught segv\n");
+ weston_log("caught segv\n");
count = backtrace(buffer, ARRAY_LENGTH(buffer));
for (i = 0; i < count; i++) {
dladdr(buffer[i], &info);
- fprintf(stderr, " [%016lx] %s (%s)\n",
+ weston_log(" [%016lx] %s (%s)\n",
(long) buffer[i],
info.dli_sname ? info.dli_sname : "--",
info.dli_fname);
module = dlopen(path, RTLD_LAZY);
if (!module) {
- fprintf(stderr,
- "failed to load module '%s': %s\n", path, dlerror());
+ weston_log("failed to load module '%s': %s\n", path, dlerror());
return NULL;
}
init = dlsym(module, entrypoint);
if (!init) {
- fprintf(stderr,
- "failed to lookup init function in '%s': %s\n",
+ weston_log("failed to lookup init function in '%s': %s\n",
path, dlerror());
return NULL;
}
ARRAY_LENGTH(core_options), argc, argv);
if (!getenv("XDG_RUNTIME_DIR")) {
- fprintf(stderr, xdg_error_message);
+ weston_log(xdg_error_message);
exit(EXIT_FAILURE);
}
ec = backend_init(display, argc, argv, config_file);
if (ec == NULL) {
- fprintf(stderr, "failed to create compositor\n");
+ weston_log("failed to create compositor\n");
exit(EXIT_FAILURE);
}
for (i = 1; argv[i]; i++)
- fprintf(stderr, "unhandled option: %s\n", argv[i]);
+ weston_log("unhandled option: %s\n", argv[i]);
if (argv[1])
exit(EXIT_FAILURE);
exit(EXIT_FAILURE);
if (wl_display_add_socket(display, socket_name)) {
- fprintf(stderr, "failed to add socket: %m\n");
+ weston_log("failed to add socket: %m\n");
exit(EXIT_FAILURE);
}
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <linux/input.h>
#include "evdev.h"
#include "evdev-private.h"
#include "launcher-util.h"
+#include "log.h"
static void
evdev_led_update(struct weston_seat *seat_base, enum weston_led leds)
if (device->is_mt) {
device->mtdev = mtdev_new_open(device->fd);
if (!device->mtdev)
- fprintf(stderr, "mtdev failed to open for %s\n", path);
+ weston_log("mtdev failed to open for %s\n", path);
}
device->source = wl_event_loop_add_fd(ec->input_loop, device->fd,
ret = ioctl(device->fd,
EVIOCGKEY(sizeof evdev_keys), evdev_keys);
if (ret < 0) {
- fprintf(stderr, "failed to get keys for device %s\n",
+ weston_log("failed to get keys for device %s\n",
device->devnode);
continue;
}
evdev_notify_keyboard_focus(seat);
if (wl_list_empty(&seat->devices_list)) {
- fprintf(stderr,
+ weston_log(
"warning: no input devices on entering Weston. "
"Possible causes:\n"
"\t- no permissions to read /dev/input/event*\n"
master->udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
if (!master->udev_monitor) {
- fprintf(stderr, "udev: failed to create the udev monitor\n");
+ weston_log("udev: failed to create the udev monitor\n");
return 0;
}
"input", NULL);
if (udev_monitor_enable_receiving(master->udev_monitor)) {
- fprintf(stderr, "udev: failed to bind the udev monitor\n");
+ weston_log("udev: failed to bind the udev monitor\n");
udev_monitor_unref(master->udev_monitor);
return 0;
}
*/
#include <stdlib.h>
-#include <stdio.h>
#include <stdint.h>
#include <limits.h>
#include <math.h>
#include "compositor.h"
#include "desktop-shell-server-protocol.h"
#include "../shared/config-parser.h"
+#include "log.h"
enum animation_type {
ANIMATION_NONE,
surface = weston_surface_create(ec);
if (surface == NULL) {
- fprintf(stderr, "no memory\n");
+ weston_log("no memory\n");
return NULL;
}
struct shell_surface *shsurf;
if (surface->configure) {
- fprintf(stderr, "surface->configure already set\n");
+ weston_log("surface->configure already set\n");
return NULL;
}
shsurf = calloc(1, sizeof *shsurf);
if (!shsurf) {
- fprintf(stderr, "no memory to allocate shell surface\n");
+ weston_log("no memory to allocate shell surface\n");
return NULL;
}
return;
if (shell->screensaver.process.pid != 0) {
- fprintf(stderr, "old screensaver still running\n");
+ weston_log("old screensaver still running\n");
return;
}
struct desktop_shell *shell =
container_of(listener, struct desktop_shell, lock_surface_listener);
- fprintf(stderr, "lock surface gone\n");
+ weston_log("lock surface gone\n");
shell->lock_surface = NULL;
}
shell->child.deathcount++;
if (shell->child.deathcount > 5) {
- fprintf(stderr, "weston-desktop-shell died, giving up.\n");
+ weston_log("weston-desktop-shell died, giving up.\n");
return;
}
- fprintf(stderr, "weston-desktop-shell died, respawning...\n");
+ weston_log("weston-desktop-shell died, respawning...\n");
launch_desktop_shell_process(shell);
}
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
-#include <stdio.h>
#include <string.h>
#include <linux/input.h>
#include "compositor.h"
#include "tablet-shell-server-protocol.h"
+#include "log.h"
/*
* TODO: Don't fade back from black until we've received a lockscreen
shell->process.pid = 0;
- fprintf(stderr,
- "weston-tablet-shell crashed, exit code %d\n", status);
+ weston_log("weston-tablet-shell crashed, exit code %d\n", status);
}
static void
"STARTING", "LOCKED", "HOME", "SWITCHER", "TASK"
};
- fprintf(stderr, "switching to state %s (from %s)\n",
+ weston_log("switching to state %s (from %s)\n",
states[state], states[shell->state]);
shell->previous_state = shell->state;
shell->state = state;
tablet_client->surface = NULL;
shell->current_client = tablet_client;
- fprintf(stderr, "created client %p, id %d, name %s, fd %d\n",
+ weston_log("created client %p, id %d, name %s, fd %d\n",
tablet_client->client, id, name, fd);
}
#include <sys/stat.h>
#include "compositor.h"
+#include "log.h"
/* Introduced in 2.6.38 */
#ifndef K_OFF
tty0 = open("/dev/tty0", O_WRONLY | O_CLOEXEC);
if (tty0 < 0) {
- fprintf(stderr, "could not open tty0: %m\n");
+ weston_log("could not open tty0: %m\n");
return -1;
}
if (ioctl(tty0, VT_OPENQRY, &tty->vt) < 0 || tty->vt == -1) {
- fprintf(stderr, "could not open tty0: %m\n");
+ weston_log("could not open tty0: %m\n");
close(tty0);
return -1;
}
close(tty0);
snprintf(filename, sizeof filename, "/dev/tty%d", tty->vt);
- fprintf(stderr, "compositor: using new vt %s\n", filename);
+ weston_log("compositor: using new vt %s\n", filename);
fd = open(filename, O_RDWR | O_NOCTTY | O_CLOEXEC);
if (fd < 0)
return fd;
if (tty_nr > 0) {
snprintf(filename, sizeof filename, "/dev/tty%d", tty_nr);
- fprintf(stderr, "compositor: using %s\n", filename);
+ weston_log("compositor: using %s\n", filename);
tty->fd = open(filename, O_RDWR | O_NOCTTY | O_CLOEXEC);
tty->vt = tty_nr;
} else if (fstat(tty->fd, &buf) == 0 &&
}
if (tty->fd <= 0) {
- fprintf(stderr, "failed to open tty: %m\n");
+ weston_log("failed to open tty: %m\n");
free(tty);
return NULL;
}
if (tty->starting_vt != tty->vt) {
if (ioctl(tty->fd, VT_ACTIVATE, tty->vt) < 0 ||
ioctl(tty->fd, VT_WAITACTIVE, tty->vt) < 0) {
- fprintf(stderr, "failed to swtich to new vt\n");
+ weston_log("failed to swtich to new vt\n");
return NULL;
}
}
if (tcgetattr(tty->fd, &tty->terminal_attributes) < 0) {
- fprintf(stderr, "could not get terminal attributes: %m\n");
+ weston_log("could not get terminal attributes: %m\n");
goto err;
}
raw_attributes.c_oflag |= OPOST | OCRNL;
if (tcsetattr(tty->fd, TCSANOW, &raw_attributes) < 0)
- fprintf(stderr, "could not put terminal into raw mode: %m\n");
+ weston_log("could not put terminal into raw mode: %m\n");
loop = wl_display_get_event_loop(compositor->wl_display);
}
if (ret) {
- fprintf(stderr, "failed to set K_OFF keyboard mode on tty: %m\n");
+ weston_log("failed to set K_OFF keyboard mode on tty: %m\n");
goto err_attr;
}
ret = ioctl(tty->fd, KDSETMODE, KD_GRAPHICS);
if (ret) {
- fprintf(stderr, "failed to set KD_GRAPHICS mode on tty: %m\n");
+ weston_log("failed to set KD_GRAPHICS mode on tty: %m\n");
goto err_kdkbmode;
}
mode.relsig = SIGUSR1;
mode.acqsig = SIGUSR1;
if (ioctl(tty->fd, VT_SETMODE, &mode) < 0) {
- fprintf(stderr, "failed to take control of vt handling\n");
+ weston_log("failed to take control of vt handling\n");
goto err_kdmode;
}
wl_event_source_remove(tty->input_source);
if (ioctl(tty->fd, KDSKBMODE, tty->kb_mode))
- fprintf(stderr, "failed to restore keyboard mode: %m\n");
+ weston_log("failed to restore keyboard mode: %m\n");
if (ioctl(tty->fd, KDSETMODE, KD_TEXT))
- fprintf(stderr,
- "failed to set KD_TEXT mode on tty: %m\n");
+ weston_log("failed to set KD_TEXT mode on tty: %m\n");
if (tcsetattr(tty->fd, TCSANOW, &tty->terminal_attributes) < 0)
- fprintf(stderr,
- "could not restore terminal to canonical mode\n");
+ weston_log("could not restore terminal to canonical mode\n");
mode.mode = VT_AUTO;
if (ioctl(tty->fd, VT_SETMODE, &mode) < 0)
- fprintf(stderr, "could not reset vt handling\n");
+ weston_log("could not reset vt handling\n");
if (tty->has_vt && tty->vt != tty->starting_vt) {
ioctl(tty->fd, VT_ACTIVATE, tty->starting_vt);
#include "xwayland.h"
#include "xserver-server-protocol.h"
+#include "../log.h"
static int
int sv[2], client_fd;
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
- fprintf(stderr, "socketpair failed\n");
+ weston_log("socketpair failed\n");
return 1;
}
"-nolisten", "all",
"-terminate",
NULL) < 0)
- fprintf(stderr, "exec failed: %m\n");
+ weston_log("exec failed: %m\n");
exit(-1);
default:
- fprintf(stderr, "forked X server, pid %d\n", mxs->process.pid);
+ weston_log("forked X server, pid %d\n", mxs->process.pid);
close(sv[1]);
mxs->client = wl_client_create(mxs->wl_display, sv[0]);
break;
case -1:
- fprintf(stderr, "failed to fork\n");
+ weston_log( "failed to fork\n");
break;
}
weston_xserver_handle_event, mxs);
if (mxs->wm) {
- fprintf(stderr, "xserver exited, code %d\n", status);
+ weston_log("xserver exited, code %d\n", status);
weston_wm_destroy(mxs->wm);
mxs->wm = NULL;
} else {
/* If the X server crashes before it binds to the
* xserver interface, shut down and don't try
* again. */
- fprintf(stderr, "xserver crashing too fast: %d\n", status);
+ weston_log("xserver crashing too fast: %d\n", status);
weston_xserver_shutdown(mxs);
}
}
wxs->wm = weston_wm_create(wxs);
if (wxs->wm == NULL) {
- fprintf(stderr, "failed to create wm\n");
+ weston_log("failed to create wm\n");
}
xserver_send_listen_socket(wxs->resource, wxs->abstract_fd);
"%c/tmp/.X11-unix/X%d", 0, display);
size = offsetof(struct sockaddr_un, sun_path) + name_size;
if (bind(fd, (struct sockaddr *) &addr, size) < 0) {
- fprintf(stderr, "failed to bind to @%s: %s\n",
+ weston_log("failed to bind to @%s: %s\n",
addr.sun_path + 1, strerror(errno));
close(fd);
return -1;
size = offsetof(struct sockaddr_un, sun_path) + name_size;
unlink(addr.sun_path);
if (bind(fd, (struct sockaddr *) &addr, size) < 0) {
- fprintf(stderr, "failed to bind to %s (%s)\n",
+ weston_log("failed to bind to %s (%s)\n",
addr.sun_path, strerror(errno));
close(fd);
return -1;
if (fd < 0 && errno == EEXIST) {
fd = open(lockfile, O_CLOEXEC, O_RDONLY);
if (fd < 0 || read(fd, pid, 11) != 11) {
- fprintf(stderr, "can't read lock file %s: %s\n",
+ weston_log("can't read lock file %s: %s\n",
lockfile, strerror(errno));
errno = EEXIST;
return -1;
other = strtol(pid, &end, 0);
if (end != pid + 10) {
- fprintf(stderr, "can't parse lock file %s\n",
+ weston_log("can't parse lock file %s\n",
lockfile);
close(fd);
errno = EEXIST;
if (kill(other, 0) < 0 && errno == ESRCH) {
/* stale lock file; unlink and try again */
- fprintf(stderr,
- "unlinking stale lock file %s\n", lockfile);
+ weston_log("unlinking stale lock file %s\n", lockfile);
close(fd);
if (unlink(lockfile))
/* If we fail to unlink, return EEXIST
errno = EEXIST;
return -1;
} else if (fd < 0) {
- fprintf(stderr, "failed to create lock file %s: %s\n",
+ weston_log("failed to create lock file %s: %s\n",
lockfile, strerror(errno));
return -1;
}
}
snprintf(display_name, sizeof display_name, ":%d", mxs->display);
- fprintf(stderr, "xserver listening on display %s\n", display_name);
+ weston_log("xserver listening on display %s\n", display_name);
setenv("DISPLAY", display_name, 1);
mxs->loop = wl_display_get_event_loop(display);
#define _GNU_SOURCE
#include <stdlib.h>
-#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include "xwayland.h"
+#include "../log.h"
static int
weston_wm_write_property(int fd, uint32_t mask, void *data)
free(wm->property_reply);
wl_event_source_remove(wm->property_source);
close(fd);
- fprintf(stderr, "write error to target fd: %m\n");
+ weston_log("write error to target fd: %m\n");
return 1;
}
- fprintf(stderr, "wrote %d (chunk size %d) of %d bytes\n",
+ weston_log("wrote %d (chunk size %d) of %d bytes\n",
wm->property_start + len,
len, xcb_get_property_value_length(wm->property_reply));
wm->selection_window,
wm->atom.wl_selection);
} else {
- fprintf(stderr, "transfer complete\n");
+ weston_log("transfer complete\n");
close(fd);
}
}
wm);
wm->property_reply = reply;
} else {
- fprintf(stderr, "transfer complete\n");
+ weston_log("transfer complete\n");
close(wm->data_source_fd);
free(reply);
}
len = read(fd, p, available);
if (len == -1) {
- fprintf(stderr, "read error from data source: %m\n");
+ weston_log("read error from data source: %m\n");
weston_wm_send_selection_notify(wm, XCB_ATOM_NONE);
wl_event_source_remove(wm->property_source);
close(fd);
wl_array_release(&wm->source_data);
}
- fprintf(stderr, "read %d (available %d, mask 0x%x) bytes: \"%.*s\"\n",
+ weston_log("read %d (available %d, mask 0x%x) bytes: \"%.*s\"\n",
len, available, mask, len, (char *) p);
wm->source_data.size = current + len;
if (wm->source_data.size >= incr_chunk_size) {
if (!wm->incr) {
- fprintf(stderr, "got %zu bytes, starting incr\n",
+ weston_log("got %zu bytes, starting incr\n",
wm->source_data.size);
wm->incr = 1;
xcb_change_property(wm->conn,
wl_event_source_remove(wm->property_source);
weston_wm_send_selection_notify(wm, wm->selection_request.property);
} else if (wm->selection_property_set) {
- fprintf(stderr, "got %zu bytes, waiting for "
+ weston_log("got %zu bytes, waiting for "
"property delete\n", wm->source_data.size);
wm->flush_property_on_delete = 1;
wl_event_source_remove(wm->property_source);
} else {
- fprintf(stderr, "got %zu bytes, "
+ weston_log("got %zu bytes, "
"property deleted, seting new property\n",
wm->source_data.size);
weston_wm_flush_source_data(wm);
}
} else if (len == 0 && !wm->incr) {
- fprintf(stderr, "non-incr transfer complete\n");
+ weston_log("non-incr transfer complete\n");
/* Non-incr transfer all done. */
weston_wm_flush_source_data(wm);
weston_wm_send_selection_notify(wm, wm->selection_request.property);
wl_array_release(&wm->source_data);
wm->selection_request.requestor = XCB_NONE;
} else if (len == 0 && wm->incr) {
- fprintf(stderr, "incr transfer complete\n");
+ weston_log("incr transfer complete\n");
wm->flush_property_on_delete = 1;
if (wm->selection_property_set) {
- fprintf(stderr, "got %zu bytes, waiting for "
+ weston_log("got %zu bytes, waiting for "
"property delete\n", wm->source_data.size);
} else {
- fprintf(stderr, "got %zu bytes, "
+ weston_log("got %zu bytes, "
"property deleted, seting new property\n",
wm->source_data.size);
weston_wm_flush_source_data(wm);
wm->data_source_fd = -1;
close(fd);
} else {
- fprintf(stderr, "nothing happened, buffered the bytes\n");
+ weston_log("nothing happened, buffered the bytes\n");
}
return 1;
int p[2];
if (pipe2(p, O_CLOEXEC | O_NONBLOCK) == -1) {
- fprintf(stderr, "pipe2 failed: %m\n");
+ weston_log("pipe2 failed: %m\n");
weston_wm_send_selection_notify(wm, XCB_ATOM_NONE);
return;
}
{
int length;
- fprintf(stderr, "property deleted\n");
+ weston_log("property deleted\n");
wm->selection_property_set = 0;
if (wm->flush_property_on_delete) {
- fprintf(stderr, "setting new property, %zu bytes\n",
+ weston_log("setting new property, %zu bytes\n",
wm->source_data.size);
wm->flush_property_on_delete = 0;
length = weston_wm_flush_source_data(wm);
xcb_selection_request_event_t *selection_request =
(xcb_selection_request_event_t *) event;
- fprintf(stderr, "selection request, %s, ",
+ weston_log("selection request, %s, ",
get_atom_name(wm->conn, selection_request->selection));
- fprintf(stderr, "target %s, ",
+ weston_log_continue("target %s, ",
get_atom_name(wm->conn, selection_request->target));
- fprintf(stderr, "property %s\n",
+ weston_log_continue("property %s\n",
get_atom_name(wm->conn, selection_request->property));
wm->selection_request = *selection_request;
weston_wm_send_data(wm, wm->atom.utf8_string,
"text/plain;charset=utf-8");
} else {
- fprintf(stderr, "can only handle UTF8_STRING targets...\n");
+ weston_log("can only handle UTF8_STRING targets...\n");
weston_wm_send_selection_notify(wm, XCB_ATOM_NONE);
}
}
struct weston_compositor *compositor;
uint32_t serial;
- printf("xfixes selection notify event: owner %d\n",
+ weston_log("xfixes selection notify event: owner %d\n",
xfixes_selection_notify->owner);
if (xfixes_selection_notify->owner == XCB_WINDOW_NONE) {
* answer TIMESTAMP conversion requests correctly. */
if (xfixes_selection_notify->owner == wm->selection_window) {
wm->selection_timestamp = xfixes_selection_notify->timestamp;
- fprintf(stderr, "our window, skipping\n");
+ weston_log("our window, skipping\n");
return;
}
end = (const char **)
((char *) source->mime_types.data + source->mime_types.size);
while (p < end) {
- fprintf(stderr, " %s\n", *p);
+ weston_log(" %s\n", *p);
if (strcmp(*p, "text/plain") == 0 ||
strcmp(*p, "text/plain;charset=utf-8") == 0)
has_text_plain = 1;
#include "../../shared/cairo-util.h"
#include "../compositor.h"
+#include "../log.h"
#include "xserver-server-protocol.h"
#include "hash.h"
int width, len;
uint32_t i;
- width = fprintf(stderr, "%s: ", get_atom_name(wm->conn, property));
+ width = weston_log_continue("%s: ", get_atom_name(wm->conn, property));
if (reply == NULL) {
- fprintf(stderr, "(no reply)\n");
+ weston_log_continue("(no reply)\n");
return;
}
- width += fprintf(stderr,
+ width += weston_log_continue(
"%s/%d, length %d (value_len %d): ",
get_atom_name(wm->conn, reply->type),
reply->format,
if (reply->type == wm->atom.incr) {
incr_value = xcb_get_property_value(reply);
- fprintf(stderr, "%d\n", *incr_value);
+ weston_log_continue("%d\n", *incr_value);
} else if (reply->type == wm->atom.utf8_string ||
reply->type == wm->atom.string) {
text_value = xcb_get_property_value(reply);
len = 40;
else
len = reply->value_len;
- fprintf(stderr, "\"%.*s\"\n", len, text_value);
+ weston_log_continue("\"%.*s\"\n", len, text_value);
} else if (reply->type == XCB_ATOM_ATOM) {
atom_value = xcb_get_property_value(reply);
for (i = 0; i < reply->value_len; i++) {
name = get_atom_name(wm->conn, atom_value[i]);
if (width + strlen(name) + 2 > 78) {
- fprintf(stderr, "\n ");
+ weston_log_continue("\n ");
width = 4;
} else if (i > 0) {
- width += fprintf(stderr, ", ");
+ width += weston_log_continue(", ");
}
- width += fprintf(stderr, "%s", name);
+ width += weston_log_continue("%s", name);
}
- fprintf(stderr, "\n");
+ weston_log_continue("\n");
} else {
- fprintf(stderr, "huh?\n");
+ weston_log_continue("huh?\n");
}
}
uint32_t mask, values[16];
int x, y, width, height, i = 0;
- fprintf(stderr, "XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n",
+ weston_log("XCB_CONFIGURE_REQUEST (window %d) %d,%d @ %dx%d\n",
configure_request->window,
configure_request->x, configure_request->y,
configure_request->width, configure_request->height);
window = hash_table_lookup(wm->window_hash, configure_notify->window);
- fprintf(stderr, "XCB_CONFIGURE_NOTIFY (%s window %d) %d,%d @ %dx%d\n",
+ weston_log("XCB_CONFIGURE_NOTIFY (%s window %d) %d,%d @ %dx%d\n",
configure_notify->window == window->id ? "client" : "frame",
configure_notify->window,
configure_notify->x, configure_notify->y,
int x, y, width, height;
if (our_resource(wm, map_request->window)) {
- fprintf(stderr, "XCB_MAP_REQUEST (window %d, ours)\n",
+ weston_log("XCB_MAP_REQUEST (window %d, ours)\n",
map_request->window);
return;
}
xcb_configure_window(wm->conn, window->id,
XCB_CONFIG_WINDOW_BORDER_WIDTH, values);
- fprintf(stderr, "XCB_MAP_REQUEST (window %d, %p, frame %d)\n",
+ weston_log("XCB_MAP_REQUEST (window %d, %p, frame %d)\n",
window->id, window, window->frame_id);
xcb_map_window(wm->conn, map_request->window);
xcb_map_notify_event_t *map_notify = (xcb_map_notify_event_t *) event;
if (our_resource(wm, map_notify->window)) {
- fprintf(stderr, "XCB_MAP_NOTIFY (window %d, ours)\n",
+ weston_log("XCB_MAP_NOTIFY (window %d, ours)\n",
map_notify->window);
return;
}
- fprintf(stderr, "XCB_MAP_NOTIFY (window %d)\n", map_notify->window);
+ weston_log("XCB_MAP_NOTIFY (window %d)\n", map_notify->window);
}
static void
(xcb_unmap_notify_event_t *) event;
struct weston_wm_window *window;
- fprintf(stderr,
- "XCB_UNMAP_NOTIFY (window %d, event %d%s)\n",
+ weston_log("XCB_UNMAP_NOTIFY (window %d, event %d%s)\n",
unmap_notify->window,
unmap_notify->event,
our_resource(wm, unmap_notify->window) ? ", ours" : "");
if (window)
window->properties_dirty = 1;
- fprintf(stderr, "XCB_PROPERTY_NOTIFY: window %d, ",
+ weston_log("XCB_PROPERTY_NOTIFY: window %d, ",
property_notify->window);
if (property_notify->state == XCB_PROPERTY_DELETE)
- fprintf(stderr, "deleted\n");
+ weston_log("deleted\n");
else
read_and_dump_property(wm, property_notify->window,
property_notify->atom);
window = malloc(sizeof *window);
if (window == NULL) {
- fprintf(stderr, "failed to allocate window\n");
+ weston_log("failed to allocate window\n");
return;
}
xcb_create_notify_event_t *create_notify =
(xcb_create_notify_event_t *) event;
- fprintf(stderr,
- "XCB_CREATE_NOTIFY (window %d, width %d, height %d%s%s)\n",
+ weston_log("XCB_CREATE_NOTIFY (window %d, width %d, height %d%s%s)\n",
create_notify->window,
create_notify->width, create_notify->height,
create_notify->override_redirect ? ", override" : "",
(xcb_destroy_notify_event_t *) event;
struct weston_wm_window *window;
- fprintf(stderr, "XCB_DESTROY_NOTIFY, win %d, event %d%s\n",
+ weston_log("XCB_DESTROY_NOTIFY, win %d, event %d%s\n",
destroy_notify->window,
destroy_notify->event,
our_resource(wm, destroy_notify->window) ? ", ours" : "");
(xcb_reparent_notify_event_t *) event;
struct weston_wm_window *window;
- fprintf(stderr,
- "XCB_REPARENT_NOTIFY (window %d, parent %d, event %d)\n",
+ weston_log("XCB_REPARENT_NOTIFY (window %d, parent %d, event %d)\n",
reparent_notify->window,
reparent_notify->parent,
reparent_notify->event);
window = hash_table_lookup(wm->window_hash, client_message->window);
- fprintf(stderr, "XCB_CLIENT_MESSAGE (%s %d %d %d %d %d)\n",
+ weston_log("XCB_CLIENT_MESSAGE (%s %d %d %d %d %d)\n",
get_atom_name(wm->conn, client_message->type),
client_message->data.data32[0],
client_message->data.data32[1],
struct theme *t = wm->theme;
int width, height;
- fprintf(stderr, "XCB_BUTTON_%s (detail %d)\n",
+ weston_log("XCB_BUTTON_%s (detail %d)\n",
button->response_type == XCB_BUTTON_PRESS ?
"PRESS" : "RELEASE", button->detail);
weston_wm_handle_destroy_notify(wm, event);
break;
case XCB_MAPPING_NOTIFY:
- fprintf(stderr, "XCB_MAPPING_NOTIFY\n");
+ weston_log("XCB_MAPPING_NOTIFY\n");
break;
case XCB_PROPERTY_NOTIFY:
weston_wm_handle_property_notify(wm, event);
wm->xfixes = xcb_get_extension_data(wm->conn, &xcb_xfixes_id);
if (!wm->xfixes || !wm->xfixes->present)
- fprintf(stderr, "xfixes not available\n");
+ weston_log("xfixes not available\n");
xfixes_cookie = xcb_xfixes_query_version(wm->conn,
XCB_XFIXES_MAJOR_VERSION,
xfixes_reply = xcb_xfixes_query_version_reply(wm->conn,
xfixes_cookie, NULL);
- printf("xfixes version: %d.%d\n",
+ weston_log("xfixes version: %d.%d\n",
xfixes_reply->major_version, xfixes_reply->minor_version);
free(xfixes_reply);
}
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
- fprintf(stderr, "socketpair failed\n");
+ weston_log("socketpair failed\n");
hash_table_destroy(wm->window_hash);
free(wm);
return NULL;
/* xcb_connect_to_fd takes ownership of the fd. */
wm->conn = xcb_connect_to_fd(sv[0], NULL);
if (xcb_connection_has_error(wm->conn)) {
- fprintf(stderr, "xcb_connect_to_fd failed\n");
+ weston_log("xcb_connect_to_fd failed\n");
close(sv[0]);
hash_table_destroy(wm->window_hash);
free(wm);
wl_signal_add(&wxs->compositor->activate_signal,
&wm->activate_listener);
- fprintf(stderr, "created wm\n");
+ weston_log("created wm\n");
return wm;
}
container_of(listener,
struct weston_wm_window, surface_destroy_listener);
- fprintf(stderr, "surface for xid %d destroyed\n", window->id);
+ weston_log("surface for xid %d destroyed\n", window->id);
}
static struct weston_wm_window *
window = hash_table_lookup(wm->window_hash, id);
if (window == NULL) {
- fprintf(stderr, "set_window_id for unknown window %d\n", id);
+ weston_log("set_window_id for unknown window %d\n", id);
return;
}
- fprintf(stderr, "set_window_id %d for surface %p\n", id, surface);
+ weston_log("set_window_id %d for surface %p\n", id, surface);
weston_wm_window_read_properties(window);
projects / profile / ivi / weston.git / commitdiff