Пример #1
0
static void
destroy_popup(struct wl_resource *resource)
{
	struct xdg_popup *popup = wl_resource_get_user_data(resource);

	wl_list_remove(&popup->surface_destroy_listener.link);
	compositor_view_destroy(popup->view);
	free(popup);
}
Пример #2
0
static void modify(struct screen_modifier * modifier,
                   const struct swc_rectangle * geometry,
                   pixman_region32_t * usable)
{
    struct panel * panel = wl_container_of(modifier, panel, modifier);
    pixman_box32_t box = {
        .x1 = geometry->x, .y1 = geometry->y,
        .x2 = geometry->x + geometry->width,
        .y2 = geometry->y + geometry->height
    };

    assert(panel->docked);

    DEBUG("Original geometry { x1: %d, y1: %d, x2: %d, y2: %d }\n",
          box.x1, box.y1, box.x2, box.y2);

    switch (panel->edge)
    {
    case SWC_PANEL_EDGE_TOP:
        box.y1 = MAX(box.y1, geometry->y + panel->strut_size);
        break;
    case SWC_PANEL_EDGE_BOTTOM:
        box.y2 = MIN(box.y2, geometry->y + geometry->height
                     - panel->strut_size);
        break;
    case SWC_PANEL_EDGE_LEFT:
        box.x1 = MAX(box.x1, geometry->x + panel->strut_size);
        break;
    case SWC_PANEL_EDGE_RIGHT:
        box.x2 = MIN(box.x2, geometry->x + geometry->width
                     - panel->strut_size);
        break;
    }

    DEBUG("Usable region { x1: %d, y1: %d, x2: %d, y2: %d }\n",
          box.x1, box.y1, box.x2, box.y2);

    pixman_region32_reset(usable, &box);
}

static void destroy_panel(struct wl_resource * resource)
{
    struct panel * panel = wl_resource_get_user_data(resource);

    if (panel->docked)
    {
        wl_list_remove(&panel->modifier.link);
        screen_update_usable_geometry(panel->screen);
    }

    compositor_view_destroy(panel->view);
    free(panel);
}

static void handle_surface_destroy(struct wl_listener * listener, void * data)
{
    struct panel * panel
        = wl_container_of(listener, panel, surface_destroy_listener);

    wl_resource_destroy(panel->resource);
}

struct panel * panel_new(struct wl_client * client, uint32_t version,
                         uint32_t id, struct surface * surface)
{
    struct panel * panel;

    panel = malloc(sizeof *panel);

    if (!panel)
        goto error0;

    panel->resource = wl_resource_create(client, &swc_panel_interface,
                                         version, id);

    if (!panel->resource)
        goto error1;

    if (!(panel->view = compositor_create_view(surface)))
        goto error2;

    wl_resource_set_implementation(panel->resource, &panel_implementation,
                                   panel, &destroy_panel);

    panel->surface_destroy_listener.notify = &handle_surface_destroy;
    panel->view_handler.impl = &view_handler_impl;
    panel->modifier.modify = &modify;
    panel->screen = NULL;
    panel->offset = 0;
    panel->strut_size = 0;
    panel->docked = false;

    wl_list_insert(&panel->view->base.handlers, &panel->view_handler.link);
    wl_resource_add_destroy_listener(surface->resource,
                                     &panel->surface_destroy_listener);

    return panel;

error2:
    wl_resource_destroy(panel->resource);
error1:
    free(panel);
error0:
    return NULL;
}