@samitouri / QOSamiQemu / commits / 405a42e365

ui/console: rename public API to use consistent qemu_console_ prefix

Rename the display and graphic console public functions to follow a consistent qemu_console_ (or qemu_graphic_console_) naming convention. The previous API used a mix of prefixes: dpy_, graphic_hw_, graphic_console_, console_has_, and update_displaychangelistener(). Unify them under a common qemu_console_ namespace for better discoverability and consistency. The main renames are: - dpy_gfx_*() / dpy_text_*() / dpy_gl_*() → qemu_console_*() - dpy_{get,set}_ui_info() → qemu_console_{get,set}_ui_info() - graphic_hw_*() → qemu_console_hw_*() - graphic_console_*() → qemu_graphic_console_*() - console_has_gl() → qemu_console_has_gl() - update_displaychangelistener() → qemu_console_listener_set_refresh() No functional changes. Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>

Marc-André Lureau committed Mar 3, 2026 at 21:45 UTC 405a42e36550e17598b007b144d19bc99caabfe3
57 files changed +379 -389
hw/arm/musicpal.c
+2 -2
@@ -170,7 +170,7 @@ static bool lcd_refresh(void *opaque)
170 }
171 }
172
173 - dpy_gfx_update(s->con, 0, 0, 128*3, 64*3);
173 + qemu_console_update(s->con, 0, 0, 128*3, 64*3);
174 return true;
175 }
176
@@ -253,7 +253,7 @@ static const GraphicHwOps musicpal_gfx_ops = {
253 static void musicpal_lcd_realize(DeviceState *dev, Error **errp)
254 {
255 musicpal_lcd_state *s = MUSICPAL_LCD(dev);
256 - s->con = graphic_console_init(dev, 0, &musicpal_gfx_ops, s);
256 + s->con = qemu_graphic_console_create(dev, 0, &musicpal_gfx_ops, s);
257 qemu_console_resize(s->con, 128 * 3, 64 * 3);
258 }
259
hw/display/apple-gfx.m
+8 -8
@@ -317,8 +317,8 @@ static void apple_gfx_render_frame_completed_bh(void *opaque)
317 copy_mtl_texture_to_surface_mem(s->texture, surface_data(s->surface));
318 if (s->gfx_update_requested) {
319 s->gfx_update_requested = false;
320 - dpy_gfx_update_full(s->con);
321 - graphic_hw_update_done(s->con);
320 + qemu_console_update_full(s->con);
321 + qemu_console_hw_update_done(s->con);
322 s->new_frame_ready = false;
323 } else {
324 s->new_frame_ready = true;
@@ -337,7 +337,7 @@ static bool apple_gfx_fb_update_display(void *opaque)
337
338 assert(bql_locked());
339 if (s->new_frame_ready) {
340 - dpy_gfx_update_full(s->con);
340 + qemu_console_update_full(s->con);
341 s->new_frame_ready = false;
342 } else if (s->pending_frames > 0) {
343 s->gfx_update_requested = true;
@@ -380,14 +380,14 @@ static void set_mode(AppleGFXState *s, uint32_t width, uint32_t height)
380 (s->texture.storageMode == MTLStorageModeManaged);
381 }
382
383 - dpy_gfx_replace_surface(s->con, s->surface);
383 + qemu_console_set_surface(s->con, s->surface);
384 }
385
386 static void update_cursor(AppleGFXState *s)
387 {
388 assert(bql_locked());
389 - dpy_mouse_set(s->con, s->pgdisp.cursorPosition.x,
390 - s->pgdisp.cursorPosition.y, qatomic_read(&s->cursor_show));
389 + qemu_console_set_mouse(s->con, s->pgdisp.cursorPosition.x,
390 + s->pgdisp.cursorPosition.y, qatomic_read(&s->cursor_show));
391 }
392
393 static void update_cursor_bh(void *opaque)
@@ -443,7 +443,7 @@ static void set_cursor_glyph(void *opaque)
443 }
444 px_data += padding_bytes_per_row;
445 }
446 - dpy_cursor_define(s->con, s->cursor);
446 + qemu_console_set_cursor(s->con, s->cursor);
447 update_cursor(s);
448 }
449 [glyph release];
@@ -792,7 +792,7 @@ bool apple_gfx_common_realize(AppleGFXState *s, DeviceState *dev,
792 apple_gfx_create_display_mode_array(display_modes, num_display_modes);
793 [mode_array release];
794
795 - s->con = graphic_console_init(dev, 0, &apple_gfx_fb_ops, s);
795 + s->con = qemu_graphic_console_create(dev, 0, &apple_gfx_fb_ops, s);
796 return true;
797 }
798
hw/display/artist.c
+2 -2
@@ -1324,7 +1324,7 @@ static bool artist_update_display(void *opaque)
1324 artist_draw_cursor(s);
1325
1326 if (first >= 0) {
1327 - dpy_gfx_update(s->con, 0, first, s->width, last - first + 1);
1327 + qemu_console_update(s->con, 0, first, s->width, last - first + 1);
1328 }
1329
1330 return true;
@@ -1424,7 +1424,7 @@ static void artist_realizefn(DeviceState *dev, Error **errp)
1424 s->misc_video |= 0x0A000000;
1425 s->misc_ctrl |= 0x00800000;
1426
1427 - s->con = graphic_console_init(dev, 0, &artist_ops, s);
1427 + s->con = qemu_graphic_console_create(dev, 0, &artist_ops, s);
1428 qemu_console_resize(s->con, s->width, s->height);
1429 }
1430
hw/display/ati.c
+8 -8
@@ -161,7 +161,7 @@ static void ati_cursor_define(ATIVGAState *s)
161 }
162 cursor_set_mono(s->cursor, s->regs.cur_color1, s->regs.cur_color0,
163 (uint8_t *)&data[64], 1, (uint8_t *)&data[0]);
164 - dpy_cursor_define(s->vga.con, s->cursor);
164 + qemu_console_set_cursor(s->vga.con, s->cursor);
165 }
166
167 /* Alternatively support guest rendered hardware cursor */
@@ -626,9 +626,9 @@ static void ati_mm_write(void *opaque, hwaddr addr,
626 if (s->regs.crtc_gen_cntl & CRTC2_CUR_EN) {
627 ati_cursor_define(s);
628 }
629 - dpy_mouse_set(s->vga.con, s->regs.cur_hv_pos >> 16,
630 - s->regs.cur_hv_pos & 0xffff,
631 - (s->regs.crtc_gen_cntl & CRTC2_CUR_EN) != 0);
629 + qemu_console_set_mouse(s->vga.con, s->regs.cur_hv_pos >> 16,
630 + s->regs.cur_hv_pos & 0xffff,
631 + (s->regs.crtc_gen_cntl & CRTC2_CUR_EN) != 0);
632 }
633 }
634 if ((val & (CRTC2_EXT_DISP_EN | CRTC2_EN)) !=
@@ -780,8 +780,8 @@ static void ati_mm_write(void *opaque, hwaddr addr,
780 }
781 if (!s->cursor_guest_mode &&
782 (s->regs.crtc_gen_cntl & CRTC2_CUR_EN) && !(t & BIT(31))) {
783 - dpy_mouse_set(s->vga.con, s->regs.cur_hv_pos >> 16,
784 - s->regs.cur_hv_pos & 0xffff, true);
783 + qemu_console_set_mouse(s->vga.con, s->regs.cur_hv_pos >> 16,
784 + s->regs.cur_hv_pos & 0xffff, true);
785 }
786 break;
787 }
@@ -1094,7 +1094,7 @@ static void ati_vga_realize(PCIDevice *dev, Error **errp)
1094 }
1095 vga_init(vga, OBJECT(s), pci_address_space(dev),
1096 pci_address_space_io(dev), true);
1097 - vga->con = graphic_console_init(DEVICE(s), 0, s->vga.hw_ops, vga);
1097 + vga->con = qemu_graphic_console_create(DEVICE(s), 0, s->vga.hw_ops, vga);
1098 if (s->cursor_guest_mode) {
1099 vga->cursor_invalidate = ati_cursor_invalidate;
1100 vga->cursor_draw_line = ati_cursor_draw_line;
@@ -1167,7 +1167,7 @@ static void ati_vga_exit(PCIDevice *dev)
1167 ATIVGAState *s = ATI_VGA(dev);
1168
1169 timer_del(&s->vblank_timer);
1170 - graphic_console_close(s->vga.con);
1170 + qemu_graphic_console_close(s->vga.con);
1171 }
1172
1173 static const Property ati_vga_properties[] = {
hw/display/bcm2835_fb.c
+2 -3
@@ -207,8 +207,7 @@ static bool fb_update_display(void *opaque)
207 draw_line_src16, s, &first, &last);
208
209 if (first >= 0) {
210 - dpy_gfx_update(s->con, 0, first, s->config.xres,
211 - last - first + 1);
210 + qemu_console_update(s->con, 0, first, s->config.xres, last - first + 1);
211 }
212
213 s->invalidate = false;
@@ -427,7 +426,7 @@ static void bcm2835_fb_realize(DeviceState *dev, Error **errp)
426
427 bcm2835_fb_reset(dev);
428
430 - s->con = graphic_console_init(dev, 0, &vgafb_ops, s);
429 + s->con = qemu_graphic_console_create(dev, 0, &vgafb_ops, s);
430 qemu_console_resize(s->con, s->config.xres, s->config.yres);
431 }
432
hw/display/bochs-display.c
+6 -8
@@ -224,12 +224,12 @@ static bool bochs_display_update(void *opaque)
224 mode.format,
225 mode.stride,
226 ptr + mode.offset);
227 - dpy_gfx_replace_surface(s->con, ds);
227 + qemu_console_set_surface(s->con, ds);
228 full_update = true;
229 }
230
231 if (full_update) {
232 - dpy_gfx_update_full(s->con);
232 + qemu_console_update_full(s->con);
233 } else {
234 snap = memory_region_snapshot_and_clear_dirty(&s->vram,
235 mode.offset, mode.size,
@@ -243,14 +243,12 @@ static bool bochs_display_update(void *opaque)
243 ys = y;
244 }
245 if (!dirty && ys >= 0) {
246 - dpy_gfx_update(s->con, 0, ys,
247 - mode.width, y - ys);
246 + qemu_console_update(s->con, 0, ys, mode.width, y - ys);
247 ys = -1;
248 }
249 }
250 if (ys >= 0) {
252 - dpy_gfx_update(s->con, 0, ys,
253 - mode.width, y - ys);
251 + qemu_console_update(s->con, 0, ys, mode.width, y - ys);
252 }
253
254 g_free(snap);
@@ -279,7 +277,7 @@ static void bochs_display_realize(PCIDevice *dev, Error **errp)
277 }
278 s->vgamem = pow2ceil(s->vgamem);
279
282 - s->con = graphic_console_init(DEVICE(dev), 0, &bochs_display_gfx_ops, s);
280 + s->con = qemu_graphic_console_create(DEVICE(dev), 0, &bochs_display_gfx_ops, s);
281
282 memory_region_init_ram(&s->vram, obj, "bochs-display-vram", s->vgamem,
283 &error_fatal);
@@ -344,7 +342,7 @@ static void bochs_display_exit(PCIDevice *dev)
342 {
343 BochsDisplayState *s = BOCHS_DISPLAY(dev);
344
347 - graphic_console_close(s->con);
345 + qemu_graphic_console_close(s->con);
346 }
347
348 static const Property bochs_display_properties[] = {
hw/display/cg3.c
+3 -3
@@ -137,7 +137,7 @@ static bool cg3_update_display(void *opaque)
137 }
138 } else {
139 if (y_start >= 0) {
140 - dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
140 + qemu_console_update(s->con, 0, y_start, width, y - y_start);
141 y_start = -1;
142 }
143 pix += width;
@@ -146,7 +146,7 @@ static bool cg3_update_display(void *opaque)
146 }
147 s->full_update = 0;
148 if (y_start >= 0) {
149 - dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
149 + qemu_console_update(s->con, 0, y_start, width, y - y_start);
150 }
151 /* vsync interrupt? */
152 if (s->regs[0] & CG3_CR_ENABLE_INTS) {
@@ -311,7 +311,7 @@ static void cg3_realizefn(DeviceState *dev, Error **errp)
311
312 sysbus_init_irq(sbd, &s->irq);
313
314 - s->con = graphic_console_init(dev, 0, &cg3_ops, s);
314 + s->con = qemu_graphic_console_create(dev, 0, &cg3_ops, s);
315 qemu_console_resize(s->con, s->width, s->height);
316 }
317
hw/display/cirrus_vga.c
+4 -4
@@ -779,9 +779,9 @@ static int cirrus_do_copy(CirrusVGAState *s, int dst, int src, int w, int h)
779 s->cirrus_blt_width, s->cirrus_blt_height);
780
781 if (notify) {
782 - dpy_gfx_update(s->vga.con, dx, dy,
783 - s->cirrus_blt_width / depth,
784 - s->cirrus_blt_height);
782 + qemu_console_update(s->vga.con, dx, dy,
783 + s->cirrus_blt_width / depth,
784 + s->cirrus_blt_height);
785 }
786
787 /* we don't have to notify the display that this portion has
@@ -2964,7 +2964,7 @@ static void pci_cirrus_vga_realize(PCIDevice *dev, Error **errp)
2964 }
2965 cirrus_init_common(s, OBJECT(dev), device_id, 1, pci_address_space(dev),
2966 pci_address_space_io(dev));
2967 - s->vga.con = graphic_console_init(DEVICE(dev), 0, s->vga.hw_ops, &s->vga);
2967 + s->vga.con = qemu_graphic_console_create(DEVICE(dev), 0, s->vga.hw_ops, &s->vga);
2968
2969 /* setup PCI */
2970 memory_region_init(&s->pci_bar, OBJECT(dev), "cirrus-pci-bar0", 0x2000000);
hw/display/cirrus_vga_isa.c
+1 -1
@@ -62,7 +62,7 @@ static void isa_cirrus_vga_realizefn(DeviceState *dev, Error **errp)
62 cirrus_init_common(&d->cirrus_vga, OBJECT(dev), CIRRUS_ID_CLGD5430, 0,
63 isa_address_space(isadev),
64 isa_address_space_io(isadev));
65 - s->con = graphic_console_init(dev, 0, s->hw_ops, s);
65 + s->con = qemu_graphic_console_create(dev, 0, s->hw_ops, s);
66 rom_add_vga(VGABIOS_CIRRUS_FILENAME);
67 /* XXX ISA-LFB support */
68 /* FIXME not qdev yet */
hw/display/dm163.c
+3 -3
@@ -277,8 +277,8 @@ static uint32_t *update_display_of_row(DM163State *s, uint32_t *dest,
277 }
278 }
279
280 - dpy_gfx_update(s->console, 0, LED_SQUARE_SIZE * row,
281 - RGB_MATRIX_NUM_COLS * LED_SQUARE_SIZE, LED_SQUARE_SIZE);
280 + qemu_console_update(s->console, 0, LED_SQUARE_SIZE * row,
281 + RGB_MATRIX_NUM_COLS * LED_SQUARE_SIZE, LED_SQUARE_SIZE);
282 s->redraw &= ~(1 << row);
283 trace_dm163_redraw(s->redraw);
284
@@ -322,7 +322,7 @@ static void dm163_realize(DeviceState *dev, Error **errp)
322 qdev_init_gpio_in(dev, dm163_en_b_gpio_handler, 1);
323 qdev_init_gpio_out_named(dev, &s->sout, "sout", 1);
324
325 - s->console = graphic_console_init(dev, 0, &dm163_ops, s);
325 + s->console = qemu_graphic_console_create(dev, 0, &dm163_ops, s);
326 qemu_console_resize(s->console, RGB_MATRIX_NUM_COLS * LED_SQUARE_SIZE,
327 RGB_MATRIX_NUM_ROWS * LED_SQUARE_SIZE);
328 }
hw/display/exynos4210_fimd.c
+2 -2
@@ -1340,7 +1340,7 @@ static bool exynos4210_fimd_update(void *opaque)
1340 fimd_copy_line_toqemu(global_width, s->ifb + global_width * line *
1341 RGBA_SIZE, d + global_width * line * bpp);
1342 }
1343 - dpy_gfx_update_full(s->console);
1343 + qemu_console_update_full(s->console);
1344 }
1345 s->invalidate = false;
1346 s->vidintcon[1] |= FIMD_VIDINT_INTFRMPEND;
@@ -1964,7 +1964,7 @@ static void exynos4210_fimd_realize(DeviceState *dev, Error **errp)
1964 return;
1965 }
1966
1967 - s->console = graphic_console_init(dev, 0, &exynos4210_fimd_ops, s);
1967 + s->console = qemu_graphic_console_create(dev, 0, &exynos4210_fimd_ops, s);
1968 }
1969
1970 static void exynos4210_fimd_class_init(ObjectClass *klass, const void *data)
hw/display/g364fb.c
+5 -5
@@ -191,8 +191,8 @@ static void g364fb_draw_graphic8(G364State *s)
191 } else {
192 int dy;
193 if (xmax || ymax) {
194 - dpy_gfx_update(s->con, xmin, ymin,
195 - xmax - xmin + 1, ymax - ymin + 1);
194 + qemu_console_update(s->con, xmin, ymin,
195 + xmax - xmin + 1, ymax - ymin + 1);
196 xmin = s->width;
197 xmax = 0;
198 ymin = s->height;
@@ -211,7 +211,7 @@ static void g364fb_draw_graphic8(G364State *s)
211
212 done:
213 if (xmax || ymax) {
214 - dpy_gfx_update(s->con, xmin, ymin, xmax - xmin + 1, ymax - ymin + 1);
214 + qemu_console_update(s->con, xmin, ymin, xmax - xmin + 1, ymax - ymin + 1);
215 }
216 g_free(snap);
217 }
@@ -234,7 +234,7 @@ static void g364fb_draw_blank(G364State *s)
234 d += surface_stride(surface);
235 }
236
237 - dpy_gfx_update_full(s->con);
237 + qemu_console_update_full(s->con);
238 s->blanked = 1;
239 }
240
@@ -478,7 +478,7 @@ static const GraphicHwOps g364fb_ops = {
478
479 static void g364fb_init(DeviceState *dev, G364State *s)
480 {
481 - s->con = graphic_console_init(dev, 0, &g364fb_ops, s);
481 + s->con = qemu_graphic_console_create(dev, 0, &g364fb_ops, s);
482
483 memory_region_init_io(&s->mem_ctrl, OBJECT(dev), &g364fb_ctrl_ops, s,
484 "ctrl", 0x180000);
hw/display/imx6ul_lcdif.c
+7 -7
@@ -203,7 +203,7 @@ static bool imx6ul_lcdif_update_display(void *opaque)
203 src_width, surface_stride(surface), 0,
204 s->invalidate, fn, s, &first, &last);
205 if (first >= 0) {
206 - dpy_gfx_update(s->con, 0, first, width, last - first + 1);
206 + qemu_console_update(s->con, 0, first, width, last - first + 1);
207 }
208
209 s->invalidate = false;
@@ -301,7 +301,7 @@ static void imx6ul_lcdif_write(void *opaque, hwaddr offset,
301 if (!FIELD_EX32(oldv, CTRL, RUN) &&
302 FIELD_EX32(s->regs[idx], CTRL, RUN)) {
303 s->invalidate = true;
304 - graphic_hw_invalidate(s->con);
304 + qemu_console_hw_invalidate(s->con);
305 imx6ul_lcdif_maybe_schedule_frame(s);
306 break;
307 }
@@ -318,17 +318,17 @@ static void imx6ul_lcdif_write(void *opaque, hwaddr offset,
318 break;
319 case A_V4_TRANSFER_COUNT:
320 s->invalidate = true;
321 - graphic_hw_invalidate(s->con);
321 + qemu_console_hw_invalidate(s->con);
322 break;
323 case A_V4_CUR_BUF:
324 s->invalidate = true;
325 - graphic_hw_invalidate(s->con);
325 + qemu_console_hw_invalidate(s->con);
326 break;
327 case A_V4_NEXT_BUF:
328 s->regs[IMX6UL_LCDIF_REG_V4_CUR_BUF] = s->regs[idx];
329 imx6ul_lcdif_frame_done(s);
330 s->invalidate = true;
331 - graphic_hw_invalidate(s->con);
331 + qemu_console_hw_invalidate(s->con);
332 imx6ul_lcdif_maybe_schedule_frame(s);
333 return;
334 case A_AS_NEXT_BUF:
@@ -411,7 +411,7 @@ static void imx6ul_lcdif_realize(DeviceState *dev, Error **errp)
411 TYPE_IMX6UL_LCDIF, LCDIF_MMIO_SIZE);
412 sysbus_init_mmio(SYS_BUS_DEVICE(dev), &s->iomem);
413 sysbus_init_irq(SYS_BUS_DEVICE(dev), &s->irq);
414 - s->con = graphic_console_init(dev, 0, &imx6ul_lcdif_graphic_ops, s);
414 + s->con = qemu_graphic_console_create(dev, 0, &imx6ul_lcdif_graphic_ops, s);
415 }
416
417 static void imx6ul_lcdif_unrealize(DeviceState *dev)
@@ -423,7 +423,7 @@ static void imx6ul_lcdif_unrealize(DeviceState *dev)
423 s->frame_timer = NULL;
424
425 if (s->con) {
426 - graphic_console_close(s->con);
426 + qemu_graphic_console_close(s->con);
427 s->con = NULL;
428 }
429 }
hw/display/jazz_led.c
+4 -4
@@ -217,7 +217,7 @@ static bool jazz_led_update_display(void *opaque)
217 }
218
219 s->state = REDRAW_NONE;
220 - dpy_gfx_update_full(s->con);
220 + qemu_console_update_full(s->con);
221
222 return true;
223 }
@@ -233,7 +233,7 @@ static void jazz_led_text_update(void *opaque, uint32_t *chardata)
233 LedState *s = opaque;
234 char buf[3];
235
236 - dpy_text_cursor(s->con, -1, -1);
236 + qemu_console_text_set_cursor(s->con, -1, -1);
237 qemu_console_resize(s->con, 2, 1);
238
239 /* TODO: draw the segments */
@@ -243,7 +243,7 @@ static void jazz_led_text_update(void *opaque, uint32_t *chardata)
243 *chardata++ = ATTR2CHTYPE(buf[1], QEMU_COLOR_BLUE,
244 QEMU_COLOR_BLACK, 1);
245
246 - dpy_text_update(s->con, 0, 0, 2, 1);
246 + qemu_console_text_update(s->con, 0, 0, 2, 1);
247 }
248
249 static int jazz_led_post_load(void *opaque, int version_id)
@@ -284,7 +284,7 @@ static void jazz_led_realize(DeviceState *dev, Error **errp)
284 {
285 LedState *s = JAZZ_LED(dev);
286
287 - s->con = graphic_console_init(dev, 0, &jazz_led_ops, s);
287 + s->con = qemu_graphic_console_create(dev, 0, &jazz_led_ops, s);
288 }
289
290 static void jazz_led_reset(DeviceState *d)
hw/display/macfb.c
+3 -3
@@ -320,14 +320,14 @@ static void macfb_draw_graphic(MacfbState *s)
320 }
321 } else {
322 if (ymin >= 0) {
323 - dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
323 + qemu_console_update(s->con, 0, ymin, s->width, y - ymin);
324 ymin = -1;
325 }
326 }
327 }
328
329 if (ymin >= 0) {
330 - dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
330 + qemu_console_update(s->con, 0, ymin, s->width, y - ymin);
331 }
332
333 g_free(snap);
@@ -671,7 +671,7 @@ static bool macfb_common_realize(DeviceState *dev, MacfbState *s, Error **errp)
671 s->regs[DAFB_MODE_CTRL1 >> 2] = s->mode->mode_ctrl1;
672 s->regs[DAFB_MODE_CTRL2 >> 2] = s->mode->mode_ctrl2;
673
674 - s->con = graphic_console_init(dev, 0, &macfb_ops, s);
674 + s->con = qemu_graphic_console_create(dev, 0, &macfb_ops, s);
675 surface = qemu_console_surface(s->con);
676
677 if (surface_bits_per_pixel(surface) != 32) {
hw/display/next-fb.c
+2 -2
@@ -89,7 +89,7 @@ static bool nextfb_update(void *opaque)
89 src_width, dest_width, 0, 1, nextfb_draw_line,
90 s, &first, &last);
91
92 - dpy_gfx_update(s->con, 0, 0, s->cols, s->rows);
92 + qemu_console_update(s->con, 0, 0, s->cols, s->rows);
93
94 return true;
95 }
@@ -117,7 +117,7 @@ static void nextfb_realize(DeviceState *dev, Error **errp)
117 s->cols = 1120;
118 s->rows = 832;
119
120 - s->con = graphic_console_init(dev, 0, &nextfb_ops, s);
120 + s->con = qemu_graphic_console_create(dev, 0, &nextfb_ops, s);
121 qemu_console_resize(s->con, s->cols, s->rows);
122 }
123
hw/display/omap_lcdc.c
+2 -2
@@ -320,7 +320,7 @@ static bool omap_update_display(void *opaque)
320 &first, &last);
321
322 if (first >= 0) {
323 - dpy_gfx_update(omap_lcd->con, 0, first, width, last - first + 1);
323 + qemu_console_update(omap_lcd->con, 0, first, width, last - first + 1);
324 }
325 omap_lcd->invalidate = 0;
326
@@ -504,7 +504,7 @@ struct omap_lcd_panel_s *omap_lcdc_init(MemoryRegion *sysmem,
504 memory_region_init_io(&s->iomem, NULL, &omap_lcdc_ops, s, "omap.lcdc", 0x100);
505 memory_region_add_subregion(sysmem, base, &s->iomem);
506
507 - s->con = graphic_console_init(NULL, 0, &omap_ops, s);
507 + s->con = qemu_graphic_console_create(NULL, 0, &omap_ops, s);
508
509 return s;
510 }
hw/display/pl110.c
+2 -2
@@ -303,7 +303,7 @@ static bool pl110_update_display(void *opaque)
303 &first, &last);
304
305 if (first >= 0) {
306 - dpy_gfx_update(s->con, 0, first, s->cols, last - first + 1);
306 + qemu_console_update(s->con, 0, first, s->cols, last - first + 1);
307 }
308 s->invalidate = 0;
309 return true;
@@ -557,7 +557,7 @@ static void pl110_realize(DeviceState *dev, Error **errp)
557 s->vblank_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
558 pl110_vblank_interrupt, s);
559 qdev_init_gpio_in(dev, pl110_mux_ctrl_set, 1);
560 - s->con = graphic_console_init(dev, 0, &pl110_gfx_ops, s);
560 + s->con = qemu_graphic_console_create(dev, 0, &pl110_gfx_ops, s);
561 }
562
563 static void pl110_init(Object *obj)
hw/display/qxl-render.c
+6 -6
@@ -135,7 +135,7 @@ static void qxl_render_update_area_unlocked(PCIQXLDevice *qxl)
135 (width,
136 height);
137 }
138 - dpy_gfx_replace_surface(vga->con, surface);
138 + qemu_console_set_surface(vga->con, surface);
139 }
140
141 if (!qxl->guest_primary.data) {
@@ -154,16 +154,16 @@ static void qxl_render_update_area_unlocked(PCIQXLDevice *qxl)
154 continue;
155 }
156 qxl_blit(qxl, qxl->dirty+i);
157 - dpy_gfx_update(vga->con,
158 - qxl->dirty[i].left, qxl->dirty[i].top,
159 - qxl->dirty[i].right - qxl->dirty[i].left,
160 - qxl->dirty[i].bottom - qxl->dirty[i].top);
157 + qemu_console_update(vga->con,
158 + qxl->dirty[i].left, qxl->dirty[i].top,
159 + qxl->dirty[i].right - qxl->dirty[i].left,
160 + qxl->dirty[i].bottom - qxl->dirty[i].top);
161 }
162 qxl->num_dirty_rects = 0;
163
164 end:
165 if (qxl->render_update_cookie_num == 0) {
166 - graphic_hw_update_done(qxl->ssd.dcl.con);
166 + qemu_console_hw_update_done(qxl->ssd.dcl.con);
167 }
168 }
169
hw/display/qxl.c
+7 -7
@@ -1153,13 +1153,13 @@ static void qxl_enter_vga_mode(PCIQXLDevice *d)
1153 }
1154 trace_qxl_enter_vga_mode(d->id);
1155 spice_qxl_driver_unload(&d->ssd.qxl);
1156 - graphic_console_set_hwops(d->ssd.dcl.con, d->vga.hw_ops, &d->vga);
1157 - update_displaychangelistener(&d->ssd.dcl, GUI_REFRESH_INTERVAL_DEFAULT);
1156 + qemu_graphic_console_set_hwops(d->ssd.dcl.con, d->vga.hw_ops, &d->vga);
1157 + qemu_console_listener_set_refresh(&d->ssd.dcl, GUI_REFRESH_INTERVAL_DEFAULT);
1158 qemu_spice_create_host_primary(&d->ssd);
1159 d->mode = QXL_MODE_VGA;
1160 qemu_spice_display_switch(&d->ssd, d->ssd.ds);
1161 vga_dirty_log_start(&d->vga);
1162 - graphic_hw_update(d->vga.con);
1162 + qemu_console_hw_update(d->vga.con);
1163 }
1164
1165 static void qxl_exit_vga_mode(PCIQXLDevice *d)
@@ -1168,8 +1168,8 @@ static void qxl_exit_vga_mode(PCIQXLDevice *d)
1168 return;
1169 }
1170 trace_qxl_exit_vga_mode(d->id);
1171 - graphic_console_set_hwops(d->ssd.dcl.con, &qxl_ops, d);
1172 - update_displaychangelistener(&d->ssd.dcl, GUI_REFRESH_INTERVAL_IDLE);
1171 + qemu_graphic_console_set_hwops(d->ssd.dcl.con, &qxl_ops, d);
1172 + qemu_console_listener_set_refresh(&d->ssd.dcl, GUI_REFRESH_INTERVAL_IDLE);
1173 vga_dirty_log_stop(&d->vga);
1174 qxl_destroy_primary(d, QXL_SYNC);
1175 }
@@ -2237,7 +2237,7 @@ static void qxl_realize_primary(PCIDevice *dev, Error **errp)
2237 portio_list_add(&qxl->vga_port_list, pci_address_space_io(dev), 0x3b0);
2238 qxl->have_vga = true;
2239
2240 - vga->con = graphic_console_init(DEVICE(dev), 0, &qxl_ops, qxl);
2240 + vga->con = qemu_graphic_console_create(DEVICE(dev), 0, &qxl_ops, qxl);
2241 qxl->id = qemu_console_get_index(vga->con); /* == channel_id */
2242 if (qxl->id != 0) {
2243 error_setg(errp, "primary qxl-vga device must be console 0 "
@@ -2262,7 +2262,7 @@ static void qxl_realize_secondary(PCIDevice *dev, Error **errp)
2262 memory_region_init_ram(&qxl->vga.vram, OBJECT(dev), "qxl.vgavram",
2263 qxl->vga.vram_size, &error_fatal);
2264 qxl->vga.vram_ptr = memory_region_get_ram_ptr(&qxl->vga.vram);
2265 - qxl->vga.con = graphic_console_init(DEVICE(dev), 0, &qxl_ops, qxl);
2265 + qxl->vga.con = qemu_graphic_console_create(DEVICE(dev), 0, &qxl_ops, qxl);
2266 qxl->ssd.dcl.con = qxl->vga.con;
2267 qxl->id = qemu_console_get_index(qxl->vga.con); /* == channel_id */
2268
hw/display/ramfb-standalone.c
+1 -1
@@ -41,7 +41,7 @@ static void ramfb_realizefn(DeviceState *dev, Error **errp)
41 {
42 RAMFBStandaloneState *ramfb = RAMFB(dev);
43
44 - ramfb->con = graphic_console_init(dev, 0, &wrapper_ops, dev);
44 + ramfb->con = qemu_graphic_console_create(dev, 0, &wrapper_ops, dev);
45 ramfb->state = ramfb_setup(ramfb->use_legacy_x86_rom, errp);
46 }
47
hw/display/ramfb.c
+2 -2
@@ -111,12 +111,12 @@ void ramfb_display_update(QemuConsole *con, RAMFBState *s)
111 }
112
113 if (s->ds) {
114 - dpy_gfx_replace_surface(con, s->ds);
114 + qemu_console_set_surface(con, s->ds);
115 s->ds = NULL;
116 }
117
118 /* simple full screen update */
119 - dpy_gfx_update_full(con);
119 + qemu_console_update_full(con);
120 }
121
122 static int ramfb_post_load(void *opaque, int version_id)
hw/display/sm501.c
+3 -3
@@ -1822,7 +1822,7 @@ static bool sm501_update_display(void *opaque)
1822 } else {
1823 if (y_start >= 0) {
1824 /* flush to display */
1825 - dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
1825 + qemu_console_update(s->con, 0, y_start, width, y - y_start);
1826 y_start = -1;
1827 }
1828 }
@@ -1831,7 +1831,7 @@ static bool sm501_update_display(void *opaque)
1831
1832 /* complete flush to display */
1833 if (y_start >= 0) {
1834 - dpy_gfx_update(s->con, 0, y_start, width, y - y_start);
1834 + qemu_console_update(s->con, 0, y_start, width, y - y_start);
1835 }
1836
1837 return true;
@@ -1936,7 +1936,7 @@ static void sm501_init(SM501State *s, DeviceState *dev,
1936 &s->twoD_engine_region);
1937
1938 /* create qemu graphic console */
1939 - s->con = graphic_console_init(dev, 0, &sm501_ops, s);
1939 + s->con = qemu_graphic_console_create(dev, 0, &sm501_ops, s);
1940 }
1941
1942 static const VMStateDescription vmstate_sm501_state = {
hw/display/ssd0303.c
+2 -2
@@ -268,7 +268,7 @@ static bool ssd0303_update_display(void *opaque)
268 }
269 }
270 s->redraw = 0;
271 - dpy_gfx_update(s->con, 0, 0, 96 * MAGNIFY, 16 * MAGNIFY);
271 + qemu_console_update(s->con, 0, 0, 96 * MAGNIFY, 16 * MAGNIFY);
272
273 return true;
274 }
@@ -309,7 +309,7 @@ static void ssd0303_realize(DeviceState *dev, Error **errp)
309 {
310 ssd0303_state *s = SSD0303(dev);
311
312 - s->con = graphic_console_init(dev, 0, &ssd0303_ops, s);
312 + s->con = qemu_graphic_console_create(dev, 0, &ssd0303_ops, s);
313 qemu_console_resize(s->con, 96 * MAGNIFY, 16 * MAGNIFY);
314 }
315
hw/display/ssd0323.c
+3 -2
@@ -270,7 +270,8 @@ static bool ssd0323_update_display(void *opaque)
270 }
271 }
272 s->redraw = 0;
273 - dpy_gfx_update(s->con, 0, 0, 128 * MAGNIFY, 64 * MAGNIFY);
273 + qemu_console_update(s->con, 0, 0, 128 * MAGNIFY, 64 * MAGNIFY);
274 +
275 return true;
276 }
277
@@ -356,7 +357,7 @@ static void ssd0323_realize(SSIPeripheral *d, Error **errp)
357
358 s->col_end = 63;
359 s->row_end = 79;
359 - s->con = graphic_console_init(dev, 0, &ssd0323_ops, s);
360 + s->con = qemu_graphic_console_create(dev, 0, &ssd0323_ops, s);
361 qemu_console_resize(s->con, 128 * MAGNIFY, 64 * MAGNIFY);
362
363 qdev_init_gpio_in(dev, ssd0323_cd, 1);
hw/display/tcx.c
+6 -10
@@ -243,8 +243,7 @@ static bool tcx_update_display(void *opaque)
243 } else {
244 if (y_start >= 0) {
245 /* flush to display */
246 - dpy_gfx_update(ts->con, 0, y_start,
247 - ts->width, y - y_start);
246 + qemu_console_update(ts->con, 0, y_start, ts->width, y - y_start);
247 y_start = -1;
248 }
249 }
@@ -253,8 +252,7 @@ static bool tcx_update_display(void *opaque)
252 }
253 if (y_start >= 0) {
254 /* flush to display */
256 - dpy_gfx_update(ts->con, 0, y_start,
257 - ts->width, y - y_start);
255 + qemu_console_update(ts->con, 0, y_start, ts->width, y - y_start);
256 }
257 g_free(snap);
258 return true;
@@ -297,8 +295,7 @@ static bool tcx24_update_display(void *opaque)
295 } else {
296 if (y_start >= 0) {
297 /* flush to display */
300 - dpy_gfx_update(ts->con, 0, y_start,
301 - ts->width, y - y_start);
298 + qemu_console_update(ts->con, 0, y_start, ts->width, y - y_start);
299 y_start = -1;
300 }
301 }
@@ -309,8 +306,7 @@ static bool tcx24_update_display(void *opaque)
306 }
307 if (y_start >= 0) {
308 /* flush to display */
312 - dpy_gfx_update(ts->con, 0, y_start,
313 - ts->width, y - y_start);
309 + qemu_console_update(ts->con, 0, y_start, ts->width, y - y_start);
310 }
311 g_free(snap);
312 return true;
@@ -864,9 +860,9 @@ static void tcx_realize(DeviceState *dev, Error **errp)
860 sysbus_init_irq(sbd, &s->irq);
861
862 if (s->depth == 8) {
867 - s->con = graphic_console_init(dev, 0, &tcx_ops, s);
863 + s->con = qemu_graphic_console_create(dev, 0, &tcx_ops, s);
864 } else {
869 - s->con = graphic_console_init(dev, 0, &tcx24_ops, s);
865 + s->con = qemu_graphic_console_create(dev, 0, &tcx24_ops, s);
866 }
867 s->thcmisc = 0;
868
hw/display/vga-isa.c
+1 -1
@@ -79,7 +79,7 @@ static void vga_isa_realizefn(DeviceState *dev, Error **errp)
79 0x000a0000,
80 vga_io_memory, 1);
81 memory_region_set_coalescing(vga_io_memory);
82 - s->con = graphic_console_init(dev, 0, s->hw_ops, s);
82 + s->con = qemu_graphic_console_create(dev, 0, s->hw_ops, s);
83
84 memory_region_add_subregion(isa_address_space(isadev),
85 VBE_DISPI_LFB_PHYSICAL_ADDRESS,
hw/display/vga-mmio.c
+1 -1
@@ -108,7 +108,7 @@ static void vga_mmio_realizefn(DeviceState *dev, Error **errp)
108 }
109
110 sysbus_init_mmio(sbd, &s->vga.vram);
111 - s->vga.con = graphic_console_init(dev, 0, s->vga.hw_ops, &s->vga);
111 + s->vga.con = qemu_graphic_console_create(dev, 0, s->vga.hw_ops, &s->vga);
112 }
113
114 static const Property vga_mmio_properties[] = {
hw/display/vga-pci.c
+3 -3
@@ -247,7 +247,7 @@ static void pci_std_vga_realize(PCIDevice *dev, Error **errp)
247 vga_init(s, OBJECT(dev), pci_address_space(dev), pci_address_space_io(dev),
248 true);
249
250 - s->con = graphic_console_init(DEVICE(dev), 0, s->hw_ops, s);
250 + s->con = qemu_graphic_console_create(DEVICE(dev), 0, s->hw_ops, s);
251
252 /* XXX: VGA_RAM_SIZE must be a power of two */
253 pci_register_bar(&d->dev, 0, PCI_BASE_ADDRESS_MEM_PREFETCH, &s->vram);
@@ -282,7 +282,7 @@ static void pci_secondary_vga_realize(PCIDevice *dev, Error **errp)
282 if (!vga_common_init(s, OBJECT(dev), errp)) {
283 return;
284 }
285 - s->con = graphic_console_init(DEVICE(dev), 0, s->hw_ops, s);
285 + s->con = qemu_graphic_console_create(DEVICE(dev), 0, s->hw_ops, s);
286
287 /* mmio bar */
288 memory_region_init_io(&d->mmio, OBJECT(dev), &unassigned_io_ops, NULL,
@@ -306,7 +306,7 @@ static void pci_secondary_vga_exit(PCIDevice *dev)
306 PCIVGAState *d = PCI_VGA(dev);
307 VGACommonState *s = &d->vga;
308
309 - graphic_console_close(s->con);
309 + qemu_graphic_console_close(s->con);
310 memory_region_del_subregion(&d->mmio, &d->mrs[0]);
311 memory_region_del_subregion(&d->mmio, &d->mrs[1]);
312 if (d->flags & (1 << PCI_VGA_FLAG_ENABLE_QEXT)) {
hw/display/vga.c
+19 -21
@@ -1246,7 +1246,7 @@ static void vga_draw_text(VGACommonState *s, int full_update)
1246 s->last_scr_height = height * cheight;
1247 qemu_console_resize(s->con, s->last_scr_width, s->last_scr_height);
1248 surface = qemu_console_surface(s->con);
1249 - dpy_text_resize(s->con, width, height);
1249 + qemu_console_text_resize(s->con, width, height);
1250 s->last_depth = 0;
1251 s->last_width = width;
1252 s->last_height = height;
@@ -1365,8 +1365,8 @@ static void vga_draw_text(VGACommonState *s, int full_update)
1365 ch_attr_ptr++;
1366 }
1367 if (cx_max != -1) {
1368 - dpy_gfx_update(s->con, cx_min * cw, cy * cheight,
1369 - (cx_max - cx_min + 1) * cw, cheight);
1368 + qemu_console_update(s->con, cx_min * cw, cy * cheight,
1369 + (cx_max - cx_min + 1) * cw, cheight);
1370 }
1371 dest += linesize * cheight;
1372 line1 = line + cheight;
@@ -1610,7 +1610,7 @@ static void vga_draw_graphic(VGACommonState *s, int full_update)
1610 */
1611 format = qemu_default_pixman_format(depth, !byteswap);
1612 if (format) {
1613 - allocate_surface = !dpy_gfx_check_format(s->con, format)
1613 + allocate_surface = !qemu_console_check_format(s->con, format)
1614 || s->force_shadow || force_shadow;
1615 } else {
1616 allocate_surface = true;
@@ -1647,7 +1647,7 @@ static void vga_draw_graphic(VGACommonState *s, int full_update)
1647 surface = qemu_create_displaysurface_from(disp_width,
1648 height, format, s->params.line_offset,
1649 s->vram_ptr + (s->params.start_addr * 4));
1650 - dpy_gfx_replace_surface(s->con, surface);
1650 + qemu_console_set_surface(s->con, surface);
1651 } else {
1652 qemu_console_resize(s->con, disp_width, height);
1653 surface = qemu_console_surface(s->con);
@@ -1720,8 +1720,7 @@ static void vga_draw_graphic(VGACommonState *s, int full_update)
1720 } else {
1721 if (y_start >= 0) {
1722 /* flush to display */
1723 - dpy_gfx_update(s->con, 0, y_start,
1724 - disp_width, y - y_start);
1723 + qemu_console_update(s->con, 0, y_start, disp_width, y - y_start);
1724 y_start = -1;
1725 }
1726 }
@@ -1745,8 +1744,7 @@ static void vga_draw_graphic(VGACommonState *s, int full_update)
1744 }
1745 if (y_start >= 0) {
1746 /* flush to display */
1748 - dpy_gfx_update(s->con, 0, y_start,
1749 - disp_width, y - y_start);
1747 + qemu_console_update(s->con, 0, y_start, disp_width, y - y_start);
1748 }
1749 g_free(snap);
1750 memset(s->invalidated_y_table, 0, sizeof(s->invalidated_y_table));
@@ -1767,7 +1765,7 @@ static void vga_draw_blank(VGACommonState *s, int full_update)
1765 /* unshare buffer, otherwise the blanking corrupts vga vram */
1766 surface = qemu_create_displaysurface(s->last_scr_width,
1767 s->last_scr_height);
1770 - dpy_gfx_replace_surface(s->con, surface);
1768 + qemu_console_set_surface(s->con, surface);
1769 }
1770
1771 w = s->last_scr_width * surface_bytes_per_pixel(surface);
@@ -1776,7 +1774,7 @@ static void vga_draw_blank(VGACommonState *s, int full_update)
1774 memset(d, 0, w);
1775 d += surface_stride(surface);
1776 }
1779 - dpy_gfx_update_full(s->con);
1777 + qemu_console_update_full(s->con);
1778 }
1779
1780 #define GMODE_TEXT 0
@@ -1967,7 +1965,7 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
1965 s->last_scr_width = width * cw;
1966 s->last_scr_height = height * cheight;
1967 qemu_console_resize(s->con, s->last_scr_width, s->last_scr_height);
1970 - dpy_text_resize(s->con, width, height);
1968 + qemu_console_text_resize(s->con, width, height);
1969 s->last_depth = 0;
1970 s->last_width = width;
1971 s->last_height = height;
@@ -1992,11 +1990,11 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
1990 s->cr[VGA_CRTC_CURSOR_END] != s->cursor_end || full_update) {
1991 cursor_visible = !(s->cr[VGA_CRTC_CURSOR_START] & 0x20);
1992 if (cursor_visible && cursor_offset < size && cursor_offset >= 0)
1995 - dpy_text_cursor(s->con,
1996 - TEXTMODE_X(cursor_offset),
1997 - TEXTMODE_Y(cursor_offset));
1993 + qemu_console_text_set_cursor(s->con,
1994 + TEXTMODE_X(cursor_offset),
1995 + TEXTMODE_Y(cursor_offset));
1996 else
1999 - dpy_text_cursor(s->con, -1, -1);
1997 + qemu_console_text_set_cursor(s->con, -1, -1);
1998 s->cursor_offset = cursor_offset;
1999 s->cursor_start = s->cr[VGA_CRTC_CURSOR_START];
2000 s->cursor_end = s->cr[VGA_CRTC_CURSOR_END];
@@ -2009,7 +2007,7 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
2007 for (i = 0; i < size; src ++, dst ++, i ++)
2008 *dst = VMEM2CHTYPE(le32_to_cpu(*src));
2009
2012 - dpy_text_update(s->con, 0, 0, width, height);
2010 + qemu_console_text_update(s->con, 0, 0, width, height);
2011 } else {
2012 c_max = 0;
2013
@@ -2032,7 +2030,7 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
2030
2031 if (c_min <= c_max) {
2032 i = TEXTMODE_Y(c_min);
2035 - dpy_text_update(s->con, 0, i, width, TEXTMODE_Y(c_max) - i + 1);
2033 + qemu_console_text_update(s->con, 0, i, width, TEXTMODE_Y(c_max) - i + 1);
2034 }
2035 }
2036
@@ -2057,8 +2055,8 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
2055 /* Display a message */
2056 s->last_width = 60;
2057 s->last_height = height = 3;
2060 - dpy_text_cursor(s->con, -1, -1);
2061 - dpy_text_resize(s->con, s->last_width, height);
2058 + qemu_console_text_set_cursor(s->con, -1, -1);
2059 + qemu_console_text_resize(s->con, s->last_width, height);
2060
2061 for (dst = chardata, i = 0; i < s->last_width * height; i ++)
2062 *dst++ = ' ';
@@ -2070,7 +2068,7 @@ static void vga_update_text(void *opaque, uint32_t *chardata)
2068 *dst++ = ATTR2CHTYPE(msg_buffer[i], QEMU_COLOR_BLUE,
2069 QEMU_COLOR_BLACK, 1);
2070
2073 - dpy_text_update(s->con, 0, 0, s->last_width, height);
2071 + qemu_console_text_update(s->con, 0, 0, s->last_width, height);
2072 }
2073
2074 static uint64_t vga_mem_read(void *opaque, hwaddr addr,
hw/display/vhost-user-gpu.c
+11 -11
@@ -142,11 +142,11 @@ vhost_user_gpu_handle_cursor(VhostUserGPU *g, VhostUserGpuMsg *msg)
142 memcpy(s->current_cursor->data, up->data,
143 64 * 64 * sizeof(uint32_t));
144
145 - dpy_cursor_define(s->con, s->current_cursor);
145 + qemu_console_set_cursor(s->con, s->current_cursor);
146 }
147
148 - dpy_mouse_set(s->con, pos->x, pos->y,
149 - msg->request != VHOST_USER_GPU_CURSOR_POS_HIDE);
148 + qemu_console_set_mouse(s->con, pos->x, pos->y,
149 + msg->request != VHOST_USER_GPU_CURSOR_POS_HIDE);
150 }
151
152 static void
@@ -238,7 +238,7 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
238 con = s->con;
239
240 if (m->width == 0) {
241 - dpy_gfx_replace_surface(con, NULL);
241 + qemu_console_set_surface(con, NULL);
242 } else {
243 s->ds = qemu_create_displaysurface(m->width, m->height);
244 /* replace surface on next update */
@@ -269,12 +269,12 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
269
270 if (dmabuf) {
271 qemu_dmabuf_close(dmabuf);
272 - dpy_gl_release_dmabuf(con, dmabuf);
272 + qemu_console_gl_release_dmabuf(con, dmabuf);
273 g_clear_pointer(&dmabuf, qemu_dmabuf_free);
274 }
275
276 if (fd == -1) {
277 - dpy_gl_scanout_disable(con);
277 + qemu_console_gl_scanout_disable(con);
278 g->dmabuf[m->scanout_id] = NULL;
279 break;
280 }
@@ -291,7 +291,7 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
291 &fd, 1, false, m->fd_flags &
292 VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP);
293
294 - dpy_gl_scanout_dmabuf(con, dmabuf);
294 + qemu_console_gl_scanout_dmabuf(con, dmabuf);
295 g->dmabuf[m->scanout_id] = dmabuf;
296 break;
297 }
@@ -306,13 +306,13 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
306 }
307
308 con = g->parent_obj.scanout[m->scanout_id].con;
309 - if (!console_has_gl(con)) {
309 + if (!qemu_console_has_gl(con)) {
310 error_report("console doesn't support GL!");
311 vhost_user_gpu_unblock(g);
312 break;
313 }
314 g->backend_blocked = true;
315 - dpy_gl_update(con, m->x, m->y, m->width, m->height);
315 + qemu_console_gl_update(con, m->x, m->y, m->width, m->height);
316 break;
317 }
318 #ifdef CONFIG_PIXMAN
@@ -337,9 +337,9 @@ vhost_user_gpu_handle_display(VhostUserGPU *g, VhostUserGpuMsg *msg)
337
338 pixman_image_unref(image);
339 if (qemu_console_surface(con) != s->ds) {
340 - dpy_gfx_replace_surface(con, s->ds);
340 + qemu_console_set_surface(con, s->ds);
341 } else {
342 - dpy_gfx_update(con, m->x, m->y, m->width, m->height);
342 + qemu_console_update(con, m->x, m->y, m->width, m->height);
343 }
344 break;
345 }
hw/display/virtio-gpu-base.c
+1 -1
@@ -253,7 +253,7 @@ virtio_gpu_base_device_realize(DeviceState *qdev,
253 g->hw_ops = &virtio_gpu_ops;
254 for (i = 0; i < g->conf.max_outputs; i++) {
255 g->scanout[i].con =
256 - graphic_console_init(DEVICE(g), i, &virtio_gpu_ops, g);
256 + qemu_graphic_console_create(DEVICE(g), i, &virtio_gpu_ops, g);
257 }
258
259 return true;
hw/display/virtio-gpu-rutabaga.c
+5 -5
@@ -282,7 +282,7 @@ rutabaga_cmd_resource_flush(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd)
282 rf.resource_id, &transfer,
283 &transfer_iovec);
284 CHECK(!result, cmd);
285 - dpy_gfx_update_full(scanout->con);
285 + qemu_console_update_full(scanout->con);
286 }
287
288 static void
@@ -306,8 +306,8 @@ rutabaga_cmd_set_scanout(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd)
306 scanout = &vb->scanout[ss.scanout_id];
307
308 if (ss.resource_id == 0) {
309 - dpy_gfx_replace_surface(scanout->con, NULL);
310 - dpy_gl_scanout_disable(scanout->con);
309 + qemu_console_set_surface(scanout->con, NULL);
310 + qemu_console_gl_scanout_disable(scanout->con);
311 return;
312 }
313
@@ -331,8 +331,8 @@ rutabaga_cmd_set_scanout(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd)
331
332 /* realloc the surface ptr */
333 scanout->ds = qemu_create_displaysurface_pixman(res->image);
334 - dpy_gfx_replace_surface(scanout->con, NULL);
335 - dpy_gfx_replace_surface(scanout->con, scanout->ds);
334 + qemu_console_set_surface(scanout->con, NULL);
335 + qemu_console_set_surface(scanout->con, scanout->ds);
336 res->scanout_bitmask = ss.scanout_id;
337 }
338
hw/display/virtio-gpu-udmabuf.c
+2 -2
@@ -156,7 +156,7 @@ static void virtio_gpu_free_dmabuf(VirtIOGPU *g, VGPUDMABuf *dmabuf)
156 struct virtio_gpu_scanout *scanout;
157
158 scanout = &g->parent_obj.scanout[dmabuf->scanout_id];
159 - dpy_gl_release_dmabuf(scanout->con, dmabuf->buf);
159 + qemu_console_gl_release_dmabuf(scanout->con, dmabuf->buf);
160 g_clear_pointer(&dmabuf->buf, qemu_dmabuf_free);
161 QTAILQ_REMOVE(&g->dmabuf.bufs, dmabuf, next);
162 g_free(dmabuf);
@@ -232,7 +232,7 @@ int virtio_gpu_update_dmabuf(VirtIOGPU *g,
232 height = qemu_dmabuf_get_height(new_primary->buf);
233 g->dmabuf.primary[scanout_id] = new_primary;
234 qemu_console_resize(scanout->con, width, height);
235 - dpy_gl_scanout_dmabuf(scanout->con, new_primary->buf);
235 + qemu_console_gl_scanout_dmabuf(scanout->con, new_primary->buf);
236
237 if (old_primary) {
238 virtio_gpu_free_dmabuf(g, old_primary);
hw/display/virtio-gpu-virgl.c
+9 -11
@@ -521,7 +521,7 @@ static void virtio_gpu_rect_update(VirtIOGPU *g, int idx, int x, int y,
521 return;
522 }
523
524 - dpy_gl_update(g->parent_obj.scanout[idx].con, x, y, width, height);
524 + qemu_console_gl_update(g->parent_obj.scanout[idx].con, x, y, width, height);
525 }
526
527 static void virgl_cmd_resource_flush(VirtIOGPU *g,
@@ -584,16 +584,15 @@ static void virgl_cmd_set_scanout(VirtIOGPU *g,
584 qemu_console_resize(g->parent_obj.scanout[ss.scanout_id].con,
585 ss.r.width, ss.r.height);
586 virgl_renderer_force_ctx_0();
587 - dpy_gl_scanout_texture(
587 + qemu_console_gl_scanout_texture(
588 g->parent_obj.scanout[ss.scanout_id].con, info.tex_id,
589 info.flags & VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP,
590 info.width, info.height,
591 ss.r.x, ss.r.y, ss.r.width, ss.r.height,
592 d3d_tex2d);
593 } else {
594 - dpy_gfx_replace_surface(
595 - g->parent_obj.scanout[ss.scanout_id].con, NULL);
596 - dpy_gl_scanout_disable(g->parent_obj.scanout[ss.scanout_id].con);
594 + qemu_console_set_surface(g->parent_obj.scanout[ss.scanout_id].con, NULL);
595 + qemu_console_gl_scanout_disable(g->parent_obj.scanout[ss.scanout_id].con);
596 }
597 g->parent_obj.scanout[ss.scanout_id].resource_id = ss.resource_id;
598 }
@@ -1315,7 +1314,7 @@ virgl_create_context(void *opaque, int scanout_idx,
1314 qparams.major_ver = params->major_ver;
1315 qparams.minor_ver = params->minor_ver;
1316
1318 - ctx = dpy_gl_ctx_create(g->parent_obj.scanout[scanout_idx].con, &qparams);
1317 + ctx = qemu_console_gl_ctx_create(g->parent_obj.scanout[scanout_idx].con, &qparams);
1318 return (virgl_renderer_gl_context)ctx;
1319 }
1320
@@ -1324,7 +1323,7 @@ static void virgl_destroy_context(void *opaque, virgl_renderer_gl_context ctx)
1323 VirtIOGPU *g = opaque;
1324 QEMUGLContext qctx = (QEMUGLContext)ctx;
1325
1327 - dpy_gl_ctx_destroy(g->parent_obj.scanout[0].con, qctx);
1326 + qemu_console_gl_ctx_destroy(g->parent_obj.scanout[0].con, qctx);
1327 }
1328
1329 static int virgl_make_context_current(void *opaque, int scanout_idx,
@@ -1333,8 +1332,7 @@ static int virgl_make_context_current(void *opaque, int scanout_idx,
1332 VirtIOGPU *g = opaque;
1333 QEMUGLContext qctx = (QEMUGLContext)ctx;
1334
1336 - return dpy_gl_ctx_make_current(g->parent_obj.scanout[scanout_idx].con,
1337 - qctx);
1335 + return qemu_console_gl_ctx_make_current(g->parent_obj.scanout[scanout_idx].con, qctx);
1336 }
1337
1338 static struct virgl_renderer_callbacks virtio_gpu_3d_cbs = {
@@ -1399,8 +1397,8 @@ void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g)
1397 int i;
1398
1399 for (i = 0; i < g->parent_obj.conf.max_outputs; i++) {
1402 - dpy_gfx_replace_surface(g->parent_obj.scanout[i].con, NULL);
1403 - dpy_gl_scanout_disable(g->parent_obj.scanout[i].con);
1400 + qemu_console_set_surface(g->parent_obj.scanout[i].con, NULL);
1401 + qemu_console_gl_scanout_disable(g->parent_obj.scanout[i].con);
1402 }
1403 }
1404
hw/display/virtio-gpu.c
+13 -13
@@ -103,14 +103,14 @@ static void update_cursor(VirtIOGPU *g, struct virtio_gpu_update_cursor *cursor)
103 if (cursor->resource_id > 0) {
104 vgc->update_cursor_data(g, s, cursor->resource_id);
105 }
106 - dpy_cursor_define(s->con, s->current_cursor);
106 + qemu_console_set_cursor(s->con, s->current_cursor);
107
108 s->cursor = *cursor;
109 } else {
110 s->cursor.pos.x = cursor->pos.x;
111 s->cursor.pos.y = cursor->pos.y;
112 }
113 - dpy_mouse_set(s->con, cursor->pos.x, cursor->pos.y, cursor->resource_id);
113 + qemu_console_set_mouse(s->con, cursor->pos.x, cursor->pos.y, cursor->resource_id);
114 }
115
116 struct virtio_gpu_simple_resource *
@@ -390,7 +390,7 @@ void virtio_gpu_disable_scanout(VirtIOGPU *g, int scanout_id)
390 res->scanout_bitmask &= ~(1 << scanout_id);
391 }
392
393 - dpy_gfx_replace_surface(scanout->con, NULL);
393 + qemu_console_set_surface(scanout->con, NULL);
394 scanout->resource_id = 0;
395 scanout->ds = NULL;
396 scanout->width = 0;
@@ -531,8 +531,8 @@ static void virtio_gpu_resource_flush(VirtIOGPU *g,
531 rf.r.y + rf.r.height >= scanout->y) {
532 within_bounds = true;
533
534 - if (console_has_gl(scanout->con)) {
535 - dpy_gl_update(scanout->con, 0, 0, scanout->width,
534 + if (qemu_console_has_gl(scanout->con)) {
535 + qemu_console_gl_update(scanout->con, 0, 0, scanout->width,
536 scanout->height);
537 update_submitted = true;
538 }
@@ -582,8 +582,8 @@ static void virtio_gpu_resource_flush(VirtIOGPU *g,
582 /* work out the area we need to update for each console */
583 if (qemu_rect_intersect(&flush_rect, &rect, &rect)) {
584 qemu_rect_translate(&rect, -scanout->x, -scanout->y);
585 - dpy_gfx_update(g->parent_obj.scanout[i].con,
586 - rect.x, rect.y, rect.width, rect.height);
585 + qemu_console_update(g->parent_obj.scanout[i].con,
586 + rect.x, rect.y, rect.width, rect.height);
587 }
588 }
589 }
@@ -649,7 +649,7 @@ static bool virtio_gpu_do_set_scanout(VirtIOGPU *g,
649 g->parent_obj.enable = 1;
650
651 if (res->blob) {
652 - if (console_has_gl(scanout->con)) {
652 + if (qemu_console_has_gl(scanout->con)) {
653 if (!virtio_gpu_update_dmabuf(g, scanout_id, res, fb, r)) {
654 virtio_gpu_update_scanout(g, scanout_id, res, fb, r);
655 } else {
@@ -665,7 +665,7 @@ static bool virtio_gpu_do_set_scanout(VirtIOGPU *g,
665 }
666
667 /* create a surface for this scanout */
668 - if ((res->blob && !console_has_gl(scanout->con)) ||
668 + if ((res->blob && !qemu_console_has_gl(scanout->con)) ||
669 !scanout->ds ||
670 surface_data(scanout->ds) != data + fb->offset ||
671 scanout->width != r->width ||
@@ -686,7 +686,7 @@ static bool virtio_gpu_do_set_scanout(VirtIOGPU *g,
686 qemu_displaysurface_set_share_handle(scanout->ds, res->share_handle, fb->offset);
687
688 pixman_image_unref(rect);
689 - dpy_gfx_replace_surface(g->parent_obj.scanout[scanout_id].con,
689 + qemu_console_set_surface(g->parent_obj.scanout[scanout_id].con,
690 scanout->ds);
691 }
692
@@ -1483,10 +1483,10 @@ static int virtio_gpu_post_load(void *opaque, int version_id)
1483 }
1484 scanout->ds = qemu_create_displaysurface_pixman(res->image);
1485 qemu_displaysurface_set_share_handle(scanout->ds, res->share_handle, 0);
1486 - dpy_gfx_replace_surface(scanout->con, scanout->ds);
1486 + qemu_console_set_surface(scanout->con, scanout->ds);
1487 }
1488
1489 - dpy_gfx_update_full(scanout->con);
1489 + qemu_console_update_full(scanout->con);
1490 if (scanout->cursor.resource_id) {
1491 update_cursor(g, &scanout->cursor);
1492 }
@@ -1602,7 +1602,7 @@ static void virtio_gpu_reset_bh(void *opaque)
1602 }
1603
1604 for (i = 0; i < g->parent_obj.conf.max_outputs; i++) {
1605 - dpy_gfx_replace_surface(g->parent_obj.scanout[i].con, NULL);
1605 + qemu_console_set_surface(g->parent_obj.scanout[i].con, NULL);
1606 }
1607
1608 g->reset_finished = true;
hw/display/virtio-vga.c
+1 -1
@@ -172,7 +172,7 @@ static void virtio_vga_base_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
172 vvga->vga_mrs, true, false);
173
174 vga->con = g->scanout[0].con;
175 - graphic_console_set_hwops(vga->con, &virtio_vga_base_ops, vvga);
175 + qemu_graphic_console_set_hwops(vga->con, &virtio_vga_base_ops, vvga);
176
177 for (i = 0; i < g->conf.max_outputs; i++) {
178 object_property_set_link(OBJECT(g->scanout[i].con), "device",
hw/display/vmware_vga.c
+6 -6
@@ -378,7 +378,7 @@ static inline void vmsvga_update_rect(struct vmsvga_state_s *s,
378 for (line = h; line > 0; line--, src += bypl, dst += bypl) {
379 memcpy(dst, src, width);
380 }
381 - dpy_gfx_update(s->vga.con, x, y, w, h);
381 + qemu_console_update(s->vga.con, x, y, w, h);
382 }
383
384 static inline void vmsvga_update_rect_flush(struct vmsvga_state_s *s)
@@ -554,7 +554,7 @@ static inline void vmsvga_cursor_define(struct vmsvga_state_s *s,
554 qc = cursor_builtin_left_ptr();
555 }
556
557 - dpy_cursor_define(s->vga.con, qc);
557 + qemu_console_set_cursor(s->vga.con, qc);
558 cursor_unref(qc);
559 }
560 #endif
@@ -1082,7 +1082,7 @@ static void vmsvga_value_write(void *opaque, uint32_t address, uint32_t value)
1082 s->cursor.on &= (value != SVGA_CURSOR_ON_HIDE);
1083 #ifdef HW_MOUSE_ACCEL
1084 if (value <= SVGA_CURSOR_ON_SHOW) {
1085 - dpy_mouse_set(s->vga.con, s->cursor.x, s->cursor.y, s->cursor.on);
1085 + qemu_console_set_mouse(s->vga.con, s->cursor.x, s->cursor.y, s->cursor.on);
1086 }
1087 #endif
1088 break;
@@ -1130,7 +1130,7 @@ static inline void vmsvga_check_size(struct vmsvga_state_s *s)
1130 surface = qemu_create_displaysurface_from(s->new_width, s->new_height,
1131 format, stride,
1132 s->vga.vram_ptr);
1133 - dpy_gfx_replace_surface(s->vga.con, surface);
1133 + qemu_console_set_surface(s->vga.con, surface);
1134 s->invalidated = 1;
1135 }
1136 }
@@ -1151,7 +1151,7 @@ static bool vmsvga_update_display(void *opaque)
1151
1152 if (s->invalidated) {
1153 s->invalidated = 0;
1154 - dpy_gfx_update_full(s->vga.con);
1154 + qemu_console_update_full(s->vga.con);
1155 }
1156
1157 return true;
@@ -1254,7 +1254,7 @@ static void vmsvga_init(DeviceState *dev, struct vmsvga_state_s *s,
1254 s->scratch_size = SVGA_SCRATCH_SIZE;
1255 s->scratch = g_malloc(s->scratch_size * 4);
1256
1257 - s->vga.con = graphic_console_init(dev, 0, &vmsvga_ops, s);
1257 + s->vga.con = qemu_graphic_console_create(dev, 0, &vmsvga_ops, s);
1258
1259 s->fifo_size = SVGA_FIFO_SIZE;
1260 memory_region_init_ram(&s->fifo_ram, NULL, "vmsvga.fifo", s->fifo_size,
hw/display/xenfb.c
+3 -3
@@ -657,7 +657,7 @@ static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
657 xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
658 __func__, xenfb->depth, bpp);
659
660 - dpy_gfx_update(xenfb->con, x, y, w, h);
660 + qemu_console_update(xenfb->con, x, y, w, h);
661 }
662
663 #ifdef XENFB_TYPE_REFRESH_PERIOD
@@ -743,7 +743,7 @@ static bool xenfb_update(void *opaque)
743 surface = qemu_create_displaysurface(xenfb->width, xenfb->height);
744 break;
745 }
746 - dpy_gfx_replace_surface(xenfb->con, surface);
746 + qemu_console_set_surface(xenfb->con, surface);
747 xen_pv_printf(&xenfb->c.xendev, 1,
748 "update: resizing: %dx%d @ %d bpp%s\n",
749 xenfb->width, xenfb->height, xenfb->depth,
@@ -903,7 +903,7 @@ static int fb_initialise(struct XenLegacyDevice *xendev)
903 if (rc != 0)
904 return rc;
905
906 - fb->con = graphic_console_init(NULL, 0, &xenfb_ops, fb);
906 + fb->con = qemu_graphic_console_create(NULL, 0, &xenfb_ops, fb);
907
908 if (xenstore_read_fe_int(xendev, "feature-update", &fb->feature_update) == -1)
909 fb->feature_update = 0;
hw/display/xlnx_dp.c
+5 -5
@@ -605,7 +605,7 @@ static void xlnx_dp_recreate_surface(XlnxDPState *s)
605
606 if ((width != 0) && (height != 0)) {
607 /*
608 - * As dpy_gfx_replace_surface calls qemu_free_displaysurface on the
608 + * As qemu_console_replace_surface calls qemu_free_displaysurface on the
609 * surface we need to be careful and don't free the surface associated
610 * to the console or double free will happen.
611 */
@@ -631,10 +631,10 @@ static void xlnx_dp_recreate_surface(XlnxDPState *s)
631 height,
632 s->g_plane.format,
633 0, NULL);
634 - dpy_gfx_replace_surface(s->console, s->bout_plane.surface);
634 + qemu_console_set_surface(s->console, s->bout_plane.surface);
635 } else {
636 s->bout_plane.surface = NULL;
637 - dpy_gfx_replace_surface(s->console, s->g_plane.surface);
637 + qemu_console_set_surface(s->console, s->g_plane.surface);
638 }
639
640 xlnx_dpdma_set_host_data_location(s->dpdma, DP_GRAPHIC_DMA_CHANNEL,
@@ -1287,7 +1287,7 @@ static bool xlnx_dp_update_display(void *opaque)
1287 /*
1288 * XXX: We might want to update only what changed.
1289 */
1290 - dpy_gfx_update_full(s->console);
1290 + qemu_console_update_full(s->console);
1291
1292 return true;
1293 }
@@ -1387,7 +1387,7 @@ static void xlnx_dp_realize(DeviceState *dev, Error **errp)
1387 qdev_realize(DEVICE(s->edid), BUS(aux_get_i2c_bus(s->aux_bus)),
1388 &error_fatal);
1389
1390 - s->console = graphic_console_init(dev, 0, &xlnx_dp_gfx_ops, s);
1390 + s->console = qemu_graphic_console_create(dev, 0, &xlnx_dp_gfx_ops, s);
1391 surface = qemu_console_surface(s->console);
1392 xlnx_dpdma_set_host_data_location(s->dpdma, DP_GRAPHIC_DMA_CHANNEL,
1393 surface_data(surface));
hw/vfio/display.c
+16 -16
@@ -264,7 +264,7 @@ static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf)
264 QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
265
266 qemu_dmabuf_close(dmabuf->buf);
267 - dpy_gl_release_dmabuf(dpy->con, dmabuf->buf);
267 + qemu_console_gl_release_dmabuf(dpy->con, dmabuf->buf);
268 g_clear_pointer(&dmabuf->buf, qemu_dmabuf_free);
269 g_free(dmabuf);
270 }
@@ -307,7 +307,7 @@ static bool vfio_display_dmabuf_update(void *opaque)
307 if (dpy->dmabuf.primary != primary) {
308 dpy->dmabuf.primary = primary;
309 qemu_console_resize(dpy->con, width, height);
310 - dpy_gl_scanout_dmabuf(dpy->con, primary->buf);
310 + qemu_console_gl_scanout_dmabuf(dpy->con, primary->buf);
311 free_bufs = true;
312 }
313
@@ -321,21 +321,21 @@ static bool vfio_display_dmabuf_update(void *opaque)
321 if (cursor && (new_cursor || cursor->hot_updates)) {
322 bool have_hot = (cursor->hot_x != 0xffffffff &&
323 cursor->hot_y != 0xffffffff);
324 - dpy_gl_cursor_dmabuf(dpy->con, cursor->buf, have_hot,
325 - cursor->hot_x, cursor->hot_y);
324 + qemu_console_gl_cursor_dmabuf(dpy->con, cursor->buf, have_hot,
325 + cursor->hot_x, cursor->hot_y);
326 cursor->hot_updates = 0;
327 } else if (!cursor && new_cursor) {
328 - dpy_gl_cursor_dmabuf(dpy->con, NULL, false, 0, 0);
328 + qemu_console_gl_cursor_dmabuf(dpy->con, NULL, false, 0, 0);
329 }
330
331 if (cursor && cursor->pos_updates) {
332 - dpy_gl_cursor_position(dpy->con,
332 + qemu_console_gl_cursor_position(dpy->con,
333 cursor->pos_x,
334 cursor->pos_y);
335 cursor->pos_updates = 0;
336 }
337
338 - dpy_gl_update(dpy->con, 0, 0, width, height);
338 + qemu_console_gl_update(dpy->con, 0, 0, width, height);
339
340 if (free_bufs) {
341 vfio_display_free_dmabufs(vdev);
@@ -363,7 +363,7 @@ static bool vfio_display_dmabuf_init(VFIOPCIDevice *vdev, Error **errp)
363 }
364
365 vdev->dpy = g_new0(VFIODisplay, 1);
366 - vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
366 + vdev->dpy->con = qemu_graphic_console_create(DEVICE(vdev), 0,
367 &vfio_display_dmabuf_ops,
368 vdev);
369 if (vdev->enable_ramfb) {
@@ -396,9 +396,9 @@ void vfio_display_reset(VFIOPCIDevice *vdev)
396 return;
397 }
398
399 - dpy_gl_scanout_disable(vdev->dpy->con);
399 + qemu_console_gl_scanout_disable(vdev->dpy->con);
400 vfio_display_dmabuf_exit(vdev->dpy);
401 - dpy_gfx_update_full(vdev->dpy->con);
401 + qemu_console_update_full(vdev->dpy->con);
402 }
403
404 static bool vfio_display_region_update(void *opaque)
@@ -471,13 +471,13 @@ static bool vfio_display_region_update(void *opaque)
471 dpy->region.surface = qemu_create_displaysurface_from
472 (plane.width, plane.height, format,
473 plane.stride, dpy->region.buffer.mmaps[0].mmap);
474 - dpy_gfx_replace_surface(dpy->con, dpy->region.surface);
474 + qemu_console_set_surface(dpy->con, dpy->region.surface);
475 }
476
477 /* full screen update */
478 - dpy_gfx_update(dpy->con, 0, 0,
479 - surface_width(dpy->region.surface),
480 - surface_height(dpy->region.surface));
478 + qemu_console_update(dpy->con, 0, 0,
479 + surface_width(dpy->region.surface),
480 + surface_height(dpy->region.surface));
481 return true;
482
483 err:
@@ -493,7 +493,7 @@ static const GraphicHwOps vfio_display_region_ops = {
493 static bool vfio_display_region_init(VFIOPCIDevice *vdev, Error **errp)
494 {
495 vdev->dpy = g_new0(VFIODisplay, 1);
496 - vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
496 + vdev->dpy->con = qemu_graphic_console_create(DEVICE(vdev), 0,
497 &vfio_display_region_ops,
498 vdev);
499 if (vdev->enable_ramfb) {
@@ -553,7 +553,7 @@ void vfio_display_finalize(VFIOPCIDevice *vdev)
553 return;
554 }
555
556 - graphic_console_close(vdev->dpy->con);
556 + qemu_graphic_console_close(vdev->dpy->con);
557 vfio_display_dmabuf_exit(vdev->dpy);
558 vfio_display_region_exit(vdev->dpy);
559 vfio_display_edid_exit(vdev->dpy);
include/ui/console.h
+54 -54
@@ -294,49 +294,49 @@ DisplayState *init_displaystate(void);
294 void qemu_console_register_listener(QemuConsole *con,
295 DisplayChangeListener *dcl,
296 const DisplayChangeListenerOps *ops);
297 -void update_displaychangelistener(DisplayChangeListener *dcl,
298 - uint64_t interval);
297 +void qemu_console_listener_set_refresh(DisplayChangeListener *dcl,
298 + uint64_t interval);
299 void qemu_console_unregister_listener(DisplayChangeListener *dcl);
300
301 -bool dpy_ui_info_supported(const QemuConsole *con);
302 -const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con);
303 -int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay);
304 -
305 -void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h);
306 -void dpy_gfx_update_full(QemuConsole *con);
307 -void dpy_gfx_replace_surface(QemuConsole *con,
308 - DisplaySurface *surface);
309 -void dpy_text_cursor(QemuConsole *con, int x, int y);
310 -void dpy_text_update(QemuConsole *con, int x, int y, int w, int h);
311 -void dpy_text_resize(QemuConsole *con, int w, int h);
312 -void dpy_mouse_set(QemuConsole *con, int x, int y, bool on);
313 -void dpy_cursor_define(QemuConsole *con, QEMUCursor *cursor);
314 -bool dpy_gfx_check_format(QemuConsole *con,
315 - pixman_format_code_t format);
316 -
317 -void dpy_gl_scanout_disable(QemuConsole *con);
318 -void dpy_gl_scanout_texture(QemuConsole *con,
319 - uint32_t backing_id, bool backing_y_0_top,
320 - uint32_t backing_width, uint32_t backing_height,
321 - uint32_t x, uint32_t y, uint32_t w, uint32_t h,
322 - void *d3d_tex2d);
323 -void dpy_gl_scanout_dmabuf(QemuConsole *con,
324 - QemuDmaBuf *dmabuf);
325 -void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
326 - bool have_hot, uint32_t hot_x, uint32_t hot_y);
327 -void dpy_gl_cursor_position(QemuConsole *con,
328 - uint32_t pos_x, uint32_t pos_y);
329 -void dpy_gl_release_dmabuf(QemuConsole *con,
330 - QemuDmaBuf *dmabuf);
331 -void dpy_gl_update(QemuConsole *con,
332 - uint32_t x, uint32_t y, uint32_t w, uint32_t h);
333 -
334 -QEMUGLContext dpy_gl_ctx_create(QemuConsole *con,
335 - QEMUGLParams *params);
336 -void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx);
337 -int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx);
338 -
339 -bool console_has_gl(QemuConsole *con);
301 +bool qemu_console_ui_info_supported(const QemuConsole *con);
302 +const QemuUIInfo *qemu_console_get_ui_info(const QemuConsole *con);
303 +int qemu_console_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay);
304 +
305 +void qemu_console_update(QemuConsole *con, int x, int y, int w, int h);
306 +void qemu_console_update_full(QemuConsole *con);
307 +void qemu_console_set_surface(QemuConsole *con,
308 + DisplaySurface *surface);
309 +void qemu_console_text_set_cursor(QemuConsole *con, int x, int y);
310 +void qemu_console_text_update(QemuConsole *con, int x, int y, int w, int h);
311 +void qemu_console_text_resize(QemuConsole *con, int w, int h);
312 +void qemu_console_set_mouse(QemuConsole *con, int x, int y, bool on);
313 +void qemu_console_set_cursor(QemuConsole *con, QEMUCursor *cursor);
314 +bool qemu_console_check_format(QemuConsole *con,
315 + pixman_format_code_t format);
316 +
317 +void qemu_console_gl_scanout_disable(QemuConsole *con);
318 +void qemu_console_gl_scanout_texture(QemuConsole *con,
319 + uint32_t backing_id, bool backing_y_0_top,
320 + uint32_t backing_width, uint32_t backing_height,
321 + uint32_t x, uint32_t y, uint32_t w, uint32_t h,
322 + void *d3d_tex2d);
323 +void qemu_console_gl_scanout_dmabuf(QemuConsole *con,
324 + QemuDmaBuf *dmabuf);
325 +void qemu_console_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
326 + bool have_hot, uint32_t hot_x, uint32_t hot_y);
327 +void qemu_console_gl_cursor_position(QemuConsole *con,
328 + uint32_t pos_x, uint32_t pos_y);
329 +void qemu_console_gl_release_dmabuf(QemuConsole *con,
330 + QemuDmaBuf *dmabuf);
331 +void qemu_console_gl_update(QemuConsole *con,
332 + uint32_t x, uint32_t y, uint32_t w, uint32_t h);
333 +
334 +QEMUGLContext qemu_console_gl_ctx_create(QemuConsole *con,
335 + QEMUGLParams *params);
336 +void qemu_console_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx);
337 +int qemu_console_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx);
338 +
339 +bool qemu_console_has_gl(QemuConsole *con);
340
341 enum {
342 GRAPHIC_FLAGS_NONE = 0,
@@ -361,19 +361,19 @@ typedef struct GraphicHwOps {
361 void (*gl_block)(void *opaque, bool block);
362 } GraphicHwOps;
363
364 -QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
365 - const GraphicHwOps *ops,
366 - void *opaque);
367 -void graphic_console_set_hwops(QemuConsole *con,
368 - const GraphicHwOps *hw_ops,
369 - void *opaque);
370 -void graphic_console_close(QemuConsole *con);
371 -
372 -void graphic_hw_update(QemuConsole *con);
373 -void graphic_hw_update_done(QemuConsole *con);
374 -void graphic_hw_invalidate(QemuConsole *con);
375 -void graphic_hw_text_update(QemuConsole *con, uint32_t *chardata);
376 -void graphic_hw_gl_block(QemuConsole *con, bool block);
364 +QemuConsole *qemu_graphic_console_create(DeviceState *dev, uint32_t head,
365 + const GraphicHwOps *ops,
366 + void *opaque);
367 +void qemu_graphic_console_set_hwops(QemuConsole *con,
368 + const GraphicHwOps *hw_ops,
369 + void *opaque);
370 +void qemu_graphic_console_close(QemuConsole *con);
371 +
372 +void qemu_console_hw_update(QemuConsole *con);
373 +void qemu_console_hw_update_done(QemuConsole *con);
374 +void qemu_console_hw_invalidate(QemuConsole *con);
375 +void qemu_console_hw_text_update(QemuConsole *con, uint32_t *chardata);
376 +void qemu_console_hw_gl_block(QemuConsole *con, bool block);
377
378 void qemu_console_early_init(void);
379
ui/cocoa.m
+5 -5
@@ -421,7 +421,7 @@ static CGEventRef handleTapEvent(CGEventTapProxy proxy, CGEventType type, CGEven
421 return;
422 }
423
424 - unregister_displaychangelistener(&dcl);
424 + qemu_console_unregister_listener(&dcl);
425 qkbd_state_switch_console(kbd, con);
426 qemu_console_register_listener(con, &dcl, &dcl_ops);
427 [self notifyMouseModeChange];
@@ -669,8 +669,8 @@ static CGEventRef handleTapEvent(CGEventTapProxy proxy, CGEventType type, CGEven
669 CVTime period = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(displayLink);
670 CVDisplayLinkRelease(displayLink);
671 if (!(period.flags & kCVTimeIsIndefinite)) {
672 - update_displaychangelistener(&dcl,
673 - 1000 * period.timeValue / period.timeScale);
672 + qemu_console_listener_set_refresh(&dcl,
673 + 1000 * period.timeValue / period.timeScale);
674 info.refresh_rate = (int64_t)1000 * period.timeScale / period.timeValue;
675 }
676 }
@@ -688,7 +688,7 @@ static CGEventRef handleTapEvent(CGEventTapProxy proxy, CGEventType type, CGEven
688 info.width = frameSize.width * [[self window] backingScaleFactor];
689 info.height = frameSize.height * [[self window] backingScaleFactor];
690
691 - dpy_set_ui_info(dcl.con, &info, TRUE);
691 + qemu_console_set_ui_info(dcl.con, &info, TRUE);
692 }
693
694 #pragma clang diagnostic pop
@@ -2056,7 +2056,7 @@ static void cocoa_refresh(DisplayChangeListener *dcl)
2056 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
2057
2058 COCOA_DEBUG("qemu_cocoa: cocoa_refresh\n");
2059 - graphic_hw_update(dcl->con);
2059 + qemu_console_hw_update(dcl->con);
2060
2061 if (cbchangecount != [[NSPasteboard generalPasteboard] changeCount]) {
2062 qemu_clipboard_info_unref(cbinfo);
ui/console-vc.c
+6 -6
@@ -90,15 +90,15 @@ static void text_console_update(void *opaque, uint32_t *chardata)
90 s->vt.cells[src].t_attrib.bgcol,
91 s->vt.cells[src].t_attrib.bold);
92 }
93 - dpy_text_update(QEMU_CONSOLE(s), s->vt.text_x[0], s->vt.text_y[0],
94 - s->vt.text_x[1] - s->vt.text_x[0], i - s->vt.text_y[0]);
93 + qemu_console_text_update(QEMU_CONSOLE(s), s->vt.text_x[0], s->vt.text_y[0],
94 + s->vt.text_x[1] - s->vt.text_x[0], i - s->vt.text_y[0]);
95 s->vt.text_x[0] = s->vt.width;
96 s->vt.text_y[0] = s->vt.height;
97 s->vt.text_x[1] = 0;
98 s->vt.text_y[1] = 0;
99 }
100 if (s->vt.cursor_invalidate) {
101 - dpy_text_cursor(QEMU_CONSOLE(s), s->vt.x, s->vt.y);
101 + qemu_console_text_set_cursor(QEMU_CONSOLE(s), s->vt.x, s->vt.y);
102 s->vt.cursor_invalidate = 0;
103 }
104 }
@@ -186,14 +186,14 @@ static void vc_chr_set_echo(Chardev *chr, bool echo)
186
187 void qemu_text_console_update_size(QemuTextConsole *c)
188 {
189 - dpy_text_resize(QEMU_CONSOLE(c), c->vt.width, c->vt.height);
189 + qemu_console_text_resize(QEMU_CONSOLE(c), c->vt.width, c->vt.height);
190 }
191
192 static void text_console_image_update(QemuVT100 *vt, int x, int y, int width, int height)
193 {
194 QemuTextConsole *console = container_of(vt, QemuTextConsole, vt);
195
196 - dpy_gfx_update(QEMU_CONSOLE(console), x, y, width, height);
196 + qemu_console_update(QEMU_CONSOLE(console), x, y, width, height);
197 }
198
199 static void text_console_out_flush(QemuVT100 *vt)
@@ -232,7 +232,7 @@ static bool vc_chr_open(Chardev *chr, ChardevBackend *backend, Error **errp)
232 s = QEMU_TEXT_CONSOLE(object_new(TYPE_QEMU_FIXED_TEXT_CONSOLE));
233 }
234
235 - dpy_gfx_replace_surface(QEMU_CONSOLE(s), qemu_create_displaysurface(width, height));
235 + qemu_console_set_surface(QEMU_CONSOLE(s), qemu_create_displaysurface(width, height));
236 if (vc->has_encoding) {
237 drv->encoding = vc->encoding;
238 }
ui/console.c
+70 -70
@@ -129,26 +129,26 @@ static void gui_setup_refresh(DisplayState *ds)
129 }
130 }
131
132 -void graphic_hw_update_done(QemuConsole *con)
132 +void qemu_console_hw_update_done(QemuConsole *con)
133 {
134 if (con) {
135 qemu_co_enter_all(&con->dump_queue, NULL);
136 }
137 }
138
139 -void graphic_hw_update(QemuConsole *con)
139 +void qemu_console_hw_update(QemuConsole *con)
140 {
141 if (!con) {
142 return;
143 }
144 if (!con->hw_ops->gfx_update || con->hw_ops->gfx_update(con->hw)) {
145 - graphic_hw_update_done(con);
145 + qemu_console_hw_update_done(con);
146 }
147 }
148
149 -static void graphic_hw_update_bh(void *con)
149 +static void console_hw_update_bh(void *con)
150 {
151 - graphic_hw_update(con);
151 + qemu_console_hw_update(con);
152 }
153
154 void qemu_console_co_wait_update(QemuConsole *con)
@@ -156,18 +156,18 @@ void qemu_console_co_wait_update(QemuConsole *con)
156 if (qemu_co_queue_empty(&con->dump_queue)) {
157 /* Defer the update, it will restart the pending coroutines */
158 aio_bh_schedule_oneshot(qemu_get_aio_context(),
159 - graphic_hw_update_bh, con);
159 + console_hw_update_bh, con);
160 }
161 qemu_co_queue_wait(&con->dump_queue, NULL);
162
163 }
164
165 -static void graphic_hw_gl_unblock_timer(void *opaque)
165 +static void console_hw_gl_unblock_timer(void *opaque)
166 {
167 warn_report("console: no gl-unblock within one second");
168 }
169
170 -void graphic_hw_gl_block(QemuConsole *con, bool block)
170 +void qemu_console_hw_gl_block(QemuConsole *con, bool block)
171 {
172 uint64_t timeout;
173 assert(con != NULL);
@@ -205,14 +205,14 @@ void qemu_console_set_window_id(QemuConsole *con, int window_id)
205 con->window_id = window_id;
206 }
207
208 -void graphic_hw_invalidate(QemuConsole *con)
208 +void qemu_console_hw_invalidate(QemuConsole *con)
209 {
210 if (con && con->hw_ops->invalidate) {
211 con->hw_ops->invalidate(con->hw);
212 }
213 }
214
215 -void graphic_hw_text_update(QemuConsole *con, uint32_t *chardata)
215 +void qemu_console_hw_text_update(QemuConsole *con, uint32_t *chardata)
216 {
217 if (con && con->hw_ops->text_update) {
218 con->hw_ops->text_update(con->hw, chardata);
@@ -502,7 +502,7 @@ qemu_graphic_console_init(Object *obj)
502 {
503 }
504
505 -bool console_has_gl(QemuConsole *con)
505 +bool qemu_console_has_gl(QemuConsole *con)
506 {
507 return con->gl != NULL;
508 }
@@ -527,7 +527,7 @@ static bool console_compatible_with(QemuConsole *con,
527
528 flags = con->hw_ops->get_flags ? con->hw_ops->get_flags(con->hw) : 0;
529
530 - if (console_has_gl(con) &&
530 + if (qemu_console_has_gl(con) &&
531 !con->gl->ops->dpy_gl_ctx_is_compatible_dcl(con->gl, dcl)) {
532 error_setg(errp, "Display %s is incompatible with the GL context",
533 dcl->ops->dpy_name);
@@ -535,7 +535,7 @@ static bool console_compatible_with(QemuConsole *con,
535 }
536
537 if (flags & GRAPHIC_FLAGS_GL &&
538 - !console_has_gl(con)) {
538 + !qemu_console_has_gl(con)) {
539 error_setg(errp, "The console requires a GL context.");
540 return false;
541
@@ -605,8 +605,8 @@ void qemu_console_register_listener(QemuConsole *con,
605 vt100_update_cursor();
606 }
607
608 -void update_displaychangelistener(DisplayChangeListener *dcl,
609 - uint64_t interval)
608 +void qemu_console_listener_set_refresh(DisplayChangeListener *dcl,
609 + uint64_t interval)
610 {
611 DisplayState *ds = dcl->ds;
612
@@ -645,7 +645,7 @@ static void dpy_set_ui_info_timer(void *opaque)
645 con->hw_ops->ui_info(con->hw, head, &con->ui_info);
646 }
647
648 -bool dpy_ui_info_supported(const QemuConsole *con)
648 +bool qemu_console_ui_info_supported(const QemuConsole *con)
649 {
650 if (con == NULL) {
651 return false;
@@ -654,16 +654,16 @@ bool dpy_ui_info_supported(const QemuConsole *con)
654 return con->hw_ops->ui_info != NULL;
655 }
656
657 -const QemuUIInfo *dpy_get_ui_info(const QemuConsole *con)
657 +const QemuUIInfo *qemu_console_get_ui_info(const QemuConsole *con)
658 {
659 - assert(dpy_ui_info_supported(con));
659 + assert(qemu_console_ui_info_supported(con));
660
661 return &con->ui_info;
662 }
663
664 -int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay)
664 +int qemu_console_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay)
665 {
666 - if (!dpy_ui_info_supported(con)) {
666 + if (!qemu_console_ui_info_supported(con)) {
667 return -1;
668 }
669 if (memcmp(&con->ui_info, info, sizeof(con->ui_info)) == 0) {
@@ -682,7 +682,7 @@ int dpy_set_ui_info(QemuConsole *con, QemuUIInfo *info, bool delay)
682 return 0;
683 }
684
685 -void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h)
685 +void qemu_console_update(QemuConsole *con, int x, int y, int w, int h)
686 {
687 DisplayState *s = con->ds;
688 DisplayChangeListener *dcl;
@@ -707,15 +707,15 @@ void dpy_gfx_update(QemuConsole *con, int x, int y, int w, int h)
707 }
708 }
709
710 -void dpy_gfx_update_full(QemuConsole *con)
710 +void qemu_console_update_full(QemuConsole *con)
711 {
712 int w = qemu_console_get_width(con, 0);
713 int h = qemu_console_get_height(con, 0);
714
715 - dpy_gfx_update(con, 0, 0, w, h);
715 + qemu_console_update(con, 0, 0, w, h);
716 }
717
718 -void dpy_gfx_replace_surface(QemuConsole *con,
718 +void qemu_console_set_surface(QemuConsole *con,
719 DisplaySurface *surface)
720 {
721 static const char placeholder_msg[] = "Display output is not active.";
@@ -753,8 +753,8 @@ void dpy_gfx_replace_surface(QemuConsole *con,
753 qemu_free_displaysurface(old_surface);
754 }
755
756 -bool dpy_gfx_check_format(QemuConsole *con,
757 - pixman_format_code_t format)
756 +bool qemu_console_check_format(QemuConsole *con,
757 + pixman_format_code_t format)
758 {
759 DisplayChangeListener *dcl;
760 DisplayState *s = con->ds;
@@ -789,7 +789,7 @@ static void dpy_refresh(DisplayState *s)
789 }
790 }
791
792 -void dpy_text_cursor(QemuConsole *con, int x, int y)
792 +void qemu_console_text_set_cursor(QemuConsole *con, int x, int y)
793 {
794 DisplayState *s = con->ds;
795 DisplayChangeListener *dcl;
@@ -804,7 +804,7 @@ void dpy_text_cursor(QemuConsole *con, int x, int y)
804 }
805 }
806
807 -void dpy_text_update(QemuConsole *con, int x, int y, int w, int h)
807 +void qemu_console_text_update(QemuConsole *con, int x, int y, int w, int h)
808 {
809 DisplayState *s = con->ds;
810 DisplayChangeListener *dcl;
@@ -819,7 +819,7 @@ void dpy_text_update(QemuConsole *con, int x, int y, int w, int h)
819 }
820 }
821
822 -void dpy_text_resize(QemuConsole *con, int w, int h)
822 +void qemu_console_text_resize(QemuConsole *con, int w, int h)
823 {
824 DisplayState *s = con->ds;
825 DisplayChangeListener *dcl;
@@ -834,7 +834,7 @@ void dpy_text_resize(QemuConsole *con, int w, int h)
834 }
835 }
836
837 -void dpy_mouse_set(QemuConsole *c, int x, int y, bool on)
837 +void qemu_console_set_mouse(QemuConsole *c, int x, int y, bool on)
838 {
839 QemuGraphicConsole *con = QEMU_GRAPHIC_CONSOLE(c);
840 DisplayState *s = c->ds;
@@ -853,7 +853,7 @@ void dpy_mouse_set(QemuConsole *c, int x, int y, bool on)
853 }
854 }
855
856 -void dpy_cursor_define(QemuConsole *c, QEMUCursor *cursor)
856 +void qemu_console_set_cursor(QemuConsole *c, QEMUCursor *cursor)
857 {
858 QemuGraphicConsole *con = QEMU_GRAPHIC_CONSOLE(c);
859 DisplayState *s = c->ds;
@@ -871,26 +871,26 @@ void dpy_cursor_define(QemuConsole *c, QEMUCursor *cursor)
871 }
872 }
873
874 -QEMUGLContext dpy_gl_ctx_create(QemuConsole *con,
875 - struct QEMUGLParams *qparams)
874 +QEMUGLContext qemu_console_gl_ctx_create(QemuConsole *con,
875 + QEMUGLParams *qparams)
876 {
877 assert(con->gl);
878 return con->gl->ops->dpy_gl_ctx_create(con->gl, qparams);
879 }
880
881 -void dpy_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx)
881 +void qemu_console_gl_ctx_destroy(QemuConsole *con, QEMUGLContext ctx)
882 {
883 assert(con->gl);
884 con->gl->ops->dpy_gl_ctx_destroy(con->gl, ctx);
885 }
886
887 -int dpy_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx)
887 +int qemu_console_gl_ctx_make_current(QemuConsole *con, QEMUGLContext ctx)
888 {
889 assert(con->gl);
890 return con->gl->ops->dpy_gl_ctx_make_current(con->gl, ctx);
891 }
892
893 -void dpy_gl_scanout_disable(QemuConsole *con)
893 +void qemu_console_gl_scanout_disable(QemuConsole *con)
894 {
895 DisplayState *s = con->ds;
896 DisplayChangeListener *dcl;
@@ -908,14 +908,14 @@ void dpy_gl_scanout_disable(QemuConsole *con)
908 }
909 }
910
911 -void dpy_gl_scanout_texture(QemuConsole *con,
912 - uint32_t backing_id,
913 - bool backing_y_0_top,
914 - uint32_t backing_width,
915 - uint32_t backing_height,
916 - uint32_t x, uint32_t y,
917 - uint32_t width, uint32_t height,
918 - void *d3d_tex2d)
911 +void qemu_console_gl_scanout_texture(QemuConsole *con,
912 + uint32_t backing_id,
913 + bool backing_y_0_top,
914 + uint32_t backing_width,
915 + uint32_t backing_height,
916 + uint32_t x, uint32_t y,
917 + uint32_t width, uint32_t height,
918 + void *d3d_tex2d)
919 {
920 DisplayState *s = con->ds;
921 DisplayChangeListener *dcl;
@@ -939,8 +939,8 @@ void dpy_gl_scanout_texture(QemuConsole *con,
939 }
940 }
941
942 -void dpy_gl_scanout_dmabuf(QemuConsole *con,
943 - QemuDmaBuf *dmabuf)
942 +void qemu_console_gl_scanout_dmabuf(QemuConsole *con,
943 + QemuDmaBuf *dmabuf)
944 {
945 DisplayState *s = con->ds;
946 DisplayChangeListener *dcl;
@@ -957,8 +957,8 @@ void dpy_gl_scanout_dmabuf(QemuConsole *con,
957 }
958 }
959
960 -void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
961 - bool have_hot, uint32_t hot_x, uint32_t hot_y)
960 +void qemu_console_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
961 + bool have_hot, uint32_t hot_x, uint32_t hot_y)
962 {
963 DisplayState *s = con->ds;
964 DisplayChangeListener *dcl;
@@ -974,8 +974,8 @@ void dpy_gl_cursor_dmabuf(QemuConsole *con, QemuDmaBuf *dmabuf,
974 }
975 }
976
977 -void dpy_gl_cursor_position(QemuConsole *con,
978 - uint32_t pos_x, uint32_t pos_y)
977 +void qemu_console_gl_cursor_position(QemuConsole *con,
978 + uint32_t pos_x, uint32_t pos_y)
979 {
980 DisplayState *s = con->ds;
981 DisplayChangeListener *dcl;
@@ -990,8 +990,8 @@ void dpy_gl_cursor_position(QemuConsole *con,
990 }
991 }
992
993 -void dpy_gl_release_dmabuf(QemuConsole *con,
994 - QemuDmaBuf *dmabuf)
993 +void qemu_console_gl_release_dmabuf(QemuConsole *con,
994 + QemuDmaBuf *dmabuf)
995 {
996 DisplayState *s = con->ds;
997 DisplayChangeListener *dcl;
@@ -1006,15 +1006,15 @@ void dpy_gl_release_dmabuf(QemuConsole *con,
1006 }
1007 }
1008
1009 -void dpy_gl_update(QemuConsole *con,
1010 - uint32_t x, uint32_t y, uint32_t w, uint32_t h)
1009 +void qemu_console_gl_update(QemuConsole *con,
1010 + uint32_t x, uint32_t y, uint32_t w, uint32_t h)
1011 {
1012 DisplayState *s = con->ds;
1013 DisplayChangeListener *dcl;
1014
1015 assert(con->gl);
1016
1017 - graphic_hw_gl_block(con, true);
1017 + qemu_console_hw_gl_block(con, true);
1018 QLIST_FOREACH(dcl, &s->listeners, next) {
1019 if (con != dcl->con) {
1020 continue;
@@ -1023,7 +1023,7 @@ void dpy_gl_update(QemuConsole *con,
1023 dcl->ops->dpy_gl_update(dcl, x, y, w, h);
1024 }
1025 }
1026 - graphic_hw_gl_block(con, false);
1026 + qemu_console_hw_gl_block(con, false);
1027 }
1028
1029 /***********************************************************/
@@ -1060,17 +1060,17 @@ DisplayState *init_displaystate(void)
1060 return display_state;
1061 }
1062
1063 -void graphic_console_set_hwops(QemuConsole *con,
1064 - const GraphicHwOps *hw_ops,
1065 - void *opaque)
1063 +void qemu_graphic_console_set_hwops(QemuConsole *con,
1064 + const GraphicHwOps *hw_ops,
1065 + void *opaque)
1066 {
1067 con->hw_ops = hw_ops;
1068 con->hw = opaque;
1069 }
1070
1071 -QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
1072 - const GraphicHwOps *hw_ops,
1073 - void *opaque)
1071 +QemuConsole *qemu_graphic_console_create(DeviceState *dev, uint32_t head,
1072 + const GraphicHwOps *hw_ops,
1073 + void *opaque)
1074 {
1075 static const char noinit[] =
1076 "Guest has not initialized the display (yet).";
@@ -1089,16 +1089,16 @@ QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
1089 s = (QemuConsole *)object_new(TYPE_QEMU_GRAPHIC_CONSOLE);
1090 }
1091 QEMU_GRAPHIC_CONSOLE(s)->head = head;
1092 - graphic_console_set_hwops(s, hw_ops, opaque);
1092 + qemu_graphic_console_set_hwops(s, hw_ops, opaque);
1093 if (dev) {
1094 object_property_set_link(OBJECT(s), "device", OBJECT(dev),
1095 &error_abort);
1096 }
1097
1098 surface = qemu_create_placeholder_surface(width, height, noinit);
1099 - dpy_gfx_replace_surface(s, surface);
1099 + qemu_console_set_surface(s, surface);
1100 s->gl_unblock_timer = timer_new_ms(QEMU_CLOCK_REALTIME,
1101 - graphic_hw_gl_unblock_timer, s);
1101 + console_hw_gl_unblock_timer, s);
1102 return s;
1103 }
1104
@@ -1106,7 +1106,7 @@ static const GraphicHwOps unused_ops = {
1106 /* no callbacks */
1107 };
1108
1109 -void graphic_console_close(QemuConsole *con)
1109 +void qemu_graphic_console_close(QemuConsole *con)
1110 {
1111 static const char unplugged[] =
1112 "Guest display has been unplugged";
@@ -1116,13 +1116,13 @@ void graphic_console_close(QemuConsole *con)
1116
1117 trace_console_gfx_close(con->index);
1118 object_property_set_link(OBJECT(con), "device", NULL, &error_abort);
1119 - graphic_console_set_hwops(con, &unused_ops, NULL);
1119 + qemu_graphic_console_set_hwops(con, &unused_ops, NULL);
1120
1121 if (con->gl) {
1122 - dpy_gl_scanout_disable(con);
1122 + qemu_console_gl_scanout_disable(con);
1123 }
1124 surface = qemu_create_placeholder_surface(width, height, unplugged);
1125 - dpy_gfx_replace_surface(con, surface);
1125 + qemu_console_set_surface(con, surface);
1126 }
1127
1128 QemuConsole *qemu_console_lookup_default(void)
@@ -1308,7 +1308,7 @@ void qemu_console_resize(QemuConsole *s, int width, int height)
1308 }
1309
1310 surface = qemu_create_displaysurface(width, height);
1311 - dpy_gfx_replace_surface(s, surface);
1311 + qemu_console_set_surface(s, surface);
1312 }
1313
1314 DisplaySurface *qemu_console_surface(QemuConsole *console)
ui/curses.c
+4 -4
@@ -1,8 +1,8 @@
1 /*
2 * QEMU curses/ncurses display driver
3 - *
3 + *
4 * Copyright (c) 2005 Andrzej Zaborowski <balrog@zabor.org>
5 - *
5 + *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
@@ -275,11 +275,11 @@ static void curses_refresh(DisplayChangeListener *dcl)
275 clear();
276 refresh();
277 curses_calc_pad();
278 - graphic_hw_invalidate(dcl->con);
278 + qemu_console_hw_invalidate(dcl->con);
279 invalidate = 0;
280 }
281
282 - graphic_hw_text_update(dcl->con, screen);
282 + qemu_console_hw_text_update(dcl->con, screen);
283
284 while (1) {
285 /* while there are any pending key strokes to process */
ui/dbus-console.c
+2 -2
@@ -200,7 +200,7 @@ dbus_console_set_ui_info(DBusDisplayConsole *ddc,
200 .height = arg_height,
201 };
202
203 - if (!dpy_ui_info_supported(ddc->dcl.con)) {
203 + if (!qemu_console_ui_info_supported(ddc->dcl.con)) {
204 g_dbus_method_invocation_return_error(invocation,
205 DBUS_DISPLAY_ERROR,
206 DBUS_DISPLAY_ERROR_UNSUPPORTED,
@@ -208,7 +208,7 @@ dbus_console_set_ui_info(DBusDisplayConsole *ddc,
208 return DBUS_METHOD_INVOCATION_HANDLED;
209 }
210
211 - dpy_set_ui_info(ddc->dcl.con, &info, false);
211 + qemu_console_set_ui_info(ddc->dcl.con, &info, false);
212 qemu_dbus_display1_console_complete_set_uiinfo(ddc->iface, invocation);
213 return DBUS_METHOD_INVOCATION_HANDLED;
214 }
ui/dbus-listener.c
+5 -5
@@ -241,7 +241,7 @@ static void dbus_update_gl_cb(GObject *source_object,
241 }
242 #endif
243
244 - graphic_hw_gl_block(ddl->dcl.con, false);
244 + qemu_console_hw_gl_block(ddl->dcl.con, false);
245 g_object_unref(ddl);
246 }
247 #endif
@@ -257,7 +257,7 @@ static void dbus_call_update_gl(DisplayChangeListener *dcl,
257
258 glFlush();
259 #ifdef CONFIG_GBM
260 - graphic_hw_gl_block(ddl->dcl.con, true);
260 + qemu_console_hw_gl_block(ddl->dcl.con, true);
261 qemu_dbus_display1_listener_call_update_dmabuf(ddl->proxy,
262 x, y, w, h,
263 G_DBUS_CALL_FLAGS_NONE,
@@ -276,7 +276,7 @@ static void dbus_call_update_gl(DisplayChangeListener *dcl,
276 Error *err = NULL;
277 assert(ddl->d3d_texture);
278
279 - graphic_hw_gl_block(ddl->dcl.con, true);
279 + qemu_console_hw_gl_block(ddl->dcl.con, true);
280 if (!d3d_texture2d_release0(ddl->d3d_texture, &err)) {
281 error_report_err(err);
282 return;
@@ -711,7 +711,7 @@ static void dbus_gl_refresh(DisplayChangeListener *dcl)
711 {
712 DBusDisplayListener *ddl = container_of(dcl, DBusDisplayListener, dcl);
713
714 - graphic_hw_update(dcl->con);
714 + qemu_console_hw_update(dcl->con);
715
716 if (!ddl->ds || qemu_console_is_gl_blocked(ddl->dcl.con)) {
717 return;
@@ -740,7 +740,7 @@ static void dbus_gl_refresh(DisplayChangeListener *dcl)
740
741 static void dbus_refresh(DisplayChangeListener *dcl)
742 {
743 - graphic_hw_update(dcl->con);
743 + qemu_console_hw_update(dcl->con);
744 }
745
746 #ifdef CONFIG_OPENGL
ui/egl-headless.c
+2 -2
@@ -23,7 +23,7 @@ typedef struct egl_dpy {
23
24 static void egl_refresh(DisplayChangeListener *dcl)
25 {
26 - graphic_hw_update(dcl->con);
26 + qemu_console_hw_update(dcl->con);
27 }
28
29 static void egl_gfx_update(DisplayChangeListener *dcl,
@@ -161,7 +161,7 @@ static void egl_scanout_flush(DisplayChangeListener *dcl,
161 }
162
163 egl_fb_read(edpy->ds, &edpy->blit_fb);
164 - dpy_gfx_update(edpy->dcl.con, x, y, w, h);
164 + qemu_console_update(edpy->dcl.con, x, y, w, h);
165 }
166
167 static const DisplayChangeListenerOps egl_ops = {
ui/gtk-egl.c
+3 -3
@@ -108,7 +108,7 @@ void gd_egl_draw(VirtualConsole *vc)
108 qemu_set_fd_handler(fence_fd, gd_hw_gl_flushed, NULL, vc);
109 return;
110 }
111 - graphic_hw_gl_block(vc->gfx.dcl.con, false);
111 + qemu_console_hw_gl_block(vc->gfx.dcl.con, false);
112 }
113 #endif
114 } else {
@@ -176,7 +176,7 @@ void gd_egl_refresh(DisplayChangeListener *dcl)
176 return;
177 }
178
179 - graphic_hw_update(dcl->con);
179 + qemu_console_hw_update(dcl->con);
180
181 if (vc->gfx.glupdates) {
182 vc->gfx.glupdates = 0;
@@ -405,7 +405,7 @@ void gd_egl_flush(DisplayChangeListener *dcl,
405
406 if (vc->gfx.guest_fb.dmabuf &&
407 !qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
408 - graphic_hw_gl_block(vc->gfx.dcl.con, true);
408 + qemu_console_hw_gl_block(vc->gfx.dcl.con, true);
409 qemu_dmabuf_set_draw_submitted(vc->gfx.guest_fb.dmabuf, true);
410 gtk_egl_set_scanout_mode(vc, true);
411 gtk_widget_queue_draw_area(area, x, y, w, h);
ui/gtk-gl-area.c
+3 -3
@@ -131,7 +131,7 @@ void gd_gl_area_draw(VirtualConsole *vc)
131 qemu_set_fd_handler(fence_fd, gd_hw_gl_flushed, NULL, vc);
132 return;
133 }
134 - graphic_hw_gl_block(vc->gfx.dcl.con, false);
134 + qemu_console_hw_gl_block(vc->gfx.dcl.con, false);
135 }
136 #endif
137 } else {
@@ -195,7 +195,7 @@ void gd_gl_area_refresh(DisplayChangeListener *dcl)
195 }
196 }
197
198 - graphic_hw_update(dcl->con);
198 + qemu_console_hw_update(dcl->con);
199
200 if (vc->gfx.glupdates) {
201 vc->gfx.glupdates = 0;
@@ -347,7 +347,7 @@ void gd_gl_area_scanout_flush(DisplayChangeListener *dcl,
347
348 if (vc->gfx.guest_fb.dmabuf &&
349 !qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
350 - graphic_hw_gl_block(vc->gfx.dcl.con, true);
350 + qemu_console_hw_gl_block(vc->gfx.dcl.con, true);
351 qemu_dmabuf_set_draw_submitted(vc->gfx.guest_fb.dmabuf, true);
352 gtk_gl_area_set_scanout_mode(vc, true);
353 }
ui/gtk.c
+9 -9
@@ -436,7 +436,7 @@ static void gd_update(DisplayChangeListener *dcl,
436
437 static void gd_refresh(DisplayChangeListener *dcl)
438 {
439 - graphic_hw_update(dcl->con);
439 + qemu_console_hw_update(dcl->con);
440 }
441
442 static GdkDevice *gd_get_pointer(GdkDisplay *dpy)
@@ -602,7 +602,7 @@ void gd_hw_gl_flushed(void *vcon)
602 qemu_set_fd_handler(fence_fd, NULL, NULL, NULL);
603 close(fence_fd);
604 qemu_dmabuf_set_fence_fd(dmabuf, -1);
605 - graphic_hw_gl_block(vc->gfx.dcl.con, false);
605 + qemu_console_hw_gl_block(vc->gfx.dcl.con, false);
606 }
607 }
608
@@ -729,27 +729,27 @@ static void gd_set_ui_refresh_rate(VirtualConsole *vc, int refresh_rate)
729 {
730 QemuUIInfo info;
731
732 - if (!dpy_ui_info_supported(vc->gfx.dcl.con)) {
732 + if (!qemu_console_ui_info_supported(vc->gfx.dcl.con)) {
733 return;
734 }
735
736 - info = *dpy_get_ui_info(vc->gfx.dcl.con);
736 + info = *qemu_console_get_ui_info(vc->gfx.dcl.con);
737 info.refresh_rate = refresh_rate;
738 - dpy_set_ui_info(vc->gfx.dcl.con, &info, true);
738 + qemu_console_set_ui_info(vc->gfx.dcl.con, &info, true);
739 }
740
741 static void gd_set_ui_size(VirtualConsole *vc, gint width, gint height)
742 {
743 QemuUIInfo info;
744
745 - if (!dpy_ui_info_supported(vc->gfx.dcl.con)) {
745 + if (!qemu_console_ui_info_supported(vc->gfx.dcl.con)) {
746 return;
747 }
748
749 - info = *dpy_get_ui_info(vc->gfx.dcl.con);
749 + info = *qemu_console_get_ui_info(vc->gfx.dcl.con);
750 info.width = width;
751 info.height = height;
752 - dpy_set_ui_info(vc->gfx.dcl.con, &info, true);
752 + qemu_console_set_ui_info(vc->gfx.dcl.con, &info, true);
753 }
754
755 #if defined(CONFIG_OPENGL)
@@ -2333,7 +2333,7 @@ static GSList *gd_vc_gfx_init(GtkDisplayState *s, VirtualConsole *vc,
2333 gd_connect_vc_gfx_signals(vc);
2334 group = gd_vc_menu_init(s, vc, idx, group, view_menu);
2335
2336 - if (dpy_ui_info_supported(vc->gfx.dcl.con)) {
2336 + if (qemu_console_ui_info_supported(vc->gfx.dcl.con)) {
2337 zoom_to_fit = true;
2338 }
2339 if (s->opts->u.gtk.has_zoom_to_fit) {
ui/sdl2-2d.c
+1 -1
@@ -129,7 +129,7 @@ void sdl2_2d_refresh(DisplayChangeListener *dcl)
129 struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
130
131 assert(!scon->opengl);
132 - graphic_hw_update(dcl->con);
132 + qemu_console_hw_update(dcl->con);
133 sdl2_poll_events(scon);
134 }
135
ui/sdl2-gl.c
+1 -1
@@ -115,7 +115,7 @@ void sdl2_gl_refresh(DisplayChangeListener *dcl)
115
116 assert(scon->opengl);
117
118 - graphic_hw_update(dcl->con);
118 + qemu_console_hw_update(dcl->con);
119 if (scon->updates && scon->real_window) {
120 scon->updates = 0;
121 sdl2_gl_render_surface(scon);
ui/sdl2.c
+3 -3
@@ -604,7 +604,7 @@ static void handle_windowevent(SDL_Event *ev)
604 .width = ev->window.data1,
605 .height = ev->window.data2,
606 };
607 - dpy_set_ui_info(scon->dcl.con, &info, true);
607 + qemu_console_set_ui_info(scon->dcl.con, &info, true);
608 }
609 sdl2_redraw(scon);
610 break;
@@ -632,10 +632,10 @@ static void handle_windowevent(SDL_Event *ev)
632 }
633 break;
634 case SDL_WINDOWEVENT_RESTORED:
635 - update_displaychangelistener(&scon->dcl, GUI_REFRESH_INTERVAL_DEFAULT);
635 + qemu_console_listener_set_refresh(&scon->dcl, GUI_REFRESH_INTERVAL_DEFAULT);
636 break;
637 case SDL_WINDOWEVENT_MINIMIZED:
638 - update_displaychangelistener(&scon->dcl, 500);
638 + qemu_console_listener_set_refresh(&scon->dcl, 500);
639 break;
640 case SDL_WINDOWEVENT_CLOSE:
641 if (qemu_console_is_graphic(scon->dcl.con)) {
ui/spice-display.c
+8 -8
@@ -468,7 +468,7 @@ void qemu_spice_cursor_refresh_bh(void *opaque)
468 assert(ssd->dcl.con);
469 cursor_ref(c);
470 qemu_mutex_unlock(&ssd->lock);
471 - dpy_cursor_define(ssd->dcl.con, c);
471 + qemu_console_set_cursor(ssd->dcl.con, c);
472 qemu_mutex_lock(&ssd->lock);
473 cursor_unref(c);
474 }
@@ -481,7 +481,7 @@ void qemu_spice_cursor_refresh_bh(void *opaque)
481 ssd->mouse_x = -1;
482 ssd->mouse_y = -1;
483 qemu_mutex_unlock(&ssd->lock);
484 - dpy_mouse_set(ssd->dcl.con, x, y, true);
484 + qemu_console_set_mouse(ssd->dcl.con, x, y, true);
485 } else {
486 qemu_mutex_unlock(&ssd->lock);
487 }
@@ -489,7 +489,7 @@ void qemu_spice_cursor_refresh_bh(void *opaque)
489
490 void qemu_spice_display_refresh(SimpleSpiceDisplay *ssd)
491 {
492 - graphic_hw_update(ssd->dcl.con);
492 + qemu_console_hw_update(ssd->dcl.con);
493
494 WITH_QEMU_LOCK_GUARD(&ssd->lock) {
495 if (QTAILQ_EMPTY(&ssd->updates) && ssd->ds) {
@@ -668,7 +668,7 @@ static int interface_client_monitors_config(QXLInstance *sin,
668 QemuUIInfo info;
669 int head;
670
671 - if (!dpy_ui_info_supported(ssd->dcl.con)) {
671 + if (!qemu_console_ui_info_supported(ssd->dcl.con)) {
672 return 0; /* == not supported by guest */
673 }
674
@@ -676,7 +676,7 @@ static int interface_client_monitors_config(QXLInstance *sin,
676 return 1;
677 }
678
679 - info = *dpy_get_ui_info(ssd->dcl.con);
679 + info = *qemu_console_get_ui_info(ssd->dcl.con);
680
681 head = qemu_console_get_index(ssd->dcl.con);
682 if (mc->num_of_monitors > head) {
@@ -690,7 +690,7 @@ static int interface_client_monitors_config(QXLInstance *sin,
690 }
691
692 trace_qemu_spice_ui_info(ssd->qxl.id, info.width, info.height);
693 - dpy_set_ui_info(ssd->dcl.con, &info, false);
693 + qemu_console_set_ui_info(ssd->dcl.con, &info, false);
694 return 1;
695 }
696
@@ -817,7 +817,7 @@ static void qemu_spice_gl_block(SimpleSpiceDisplay *ssd, bool block)
817 } else {
818 timer_del(ssd->gl_unblock_timer);
819 }
820 - graphic_hw_gl_block(ssd->dcl.con, block);
820 + qemu_console_hw_gl_block(ssd->dcl.con, block);
821 }
822
823 static void qemu_spice_gl_unblock_bh(void *opaque)
@@ -861,7 +861,7 @@ static void spice_gl_refresh(DisplayChangeListener *dcl)
861 return;
862 }
863
864 - graphic_hw_update(dcl->con);
864 + qemu_console_hw_update(dcl->con);
865 if (ssd->gl_updates && ssd->have_surface) {
866 qemu_spice_gl_block(ssd, true);
867 glFlush();
ui/vnc.c
+11 -11
@@ -2325,8 +2325,8 @@ static void set_pixel_format(VncState *vs, int bits_per_pixel,
2325
2326 set_pixel_conversion(vs);
2327
2328 - graphic_hw_invalidate(vs->vd->dcl.con);
2329 - graphic_hw_update(vs->vd->dcl.con);
2328 + qemu_console_hw_invalidate(vs->vd->dcl.con);
2329 + qemu_console_hw_update(vs->vd->dcl.con);
2330 }
2331
2332 static void pixel_format_message (VncState *vs) {
@@ -2384,7 +2384,7 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
2384 VncDisplay *vd = vs->vd;
2385
2386 if (data[0] > 3) {
2387 - update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
2387 + qemu_console_listener_set_refresh(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
2388 }
2389
2390 switch (data[0]) {
@@ -2638,9 +2638,9 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
2638 h = read_u16(data, 4);
2639
2640 trace_vnc_msg_client_set_desktop_size(vs, vs->ioc, w, h, screens);
2641 - if (dpy_ui_info_supported(vs->vd->dcl.con)) {
2641 + if (qemu_console_ui_info_supported(vs->vd->dcl.con)) {
2642 QemuUIInfo info = { .width = w, .height = h };
2643 - dpy_set_ui_info(vs->vd->dcl.con, &info, false);
2643 + qemu_console_set_ui_info(vs->vd->dcl.con, &info, false);
2644 vnc_desktop_resize_ext(vs, 4 /* Request forwarded */);
2645 } else {
2646 vnc_desktop_resize_ext(vs, 3 /* Invalid screen layout */);
@@ -3242,14 +3242,14 @@ static void vnc_refresh(DisplayChangeListener *dcl)
3242 int has_dirty, rects = 0;
3243
3244 if (QTAILQ_EMPTY(&vd->clients)) {
3245 - update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_MAX);
3245 + qemu_console_listener_set_refresh(&vd->dcl, VNC_REFRESH_INTERVAL_MAX);
3246 return;
3247 }
3248
3249 - graphic_hw_update(vd->dcl.con);
3249 + qemu_console_hw_update(vd->dcl.con);
3250
3251 if (vnc_trylock_display(vd)) {
3252 - update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3252 + qemu_console_listener_set_refresh(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3253 return;
3254 }
3255
@@ -3323,7 +3323,7 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
3323 sioc, websocket, vs->auth, vs->subauth);
3324
3325 VNC_DEBUG("New client on socket %p\n", vs->sioc);
3326 - update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3326 + qemu_console_listener_set_refresh(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3327 qio_channel_set_blocking(vs->ioc, false, &error_abort);
3328 g_clear_handle_id(&vs->ioc_tag, g_source_remove);
3329 if (websocket) {
@@ -3363,7 +3363,7 @@ static void vnc_connect(VncDisplay *vd, QIOChannelSocket *sioc,
3363 vnc_update_server_surface(vd);
3364 }
3365
3366 - graphic_hw_update(vd->dcl.con);
3366 + qemu_console_hw_update(vd->dcl.con);
3367
3368 if (!vs->websocket) {
3369 vnc_start_protocol(vs);
@@ -3419,7 +3419,7 @@ static void vmstate_change_handler(void *opaque, bool running, RunState state)
3419 if (state != RUN_STATE_RUNNING) {
3420 return;
3421 }
3422 - update_displaychangelistener(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3422 + qemu_console_listener_set_refresh(&vd->dcl, VNC_REFRESH_INTERVAL_BASE);
3423 }
3424
3425 static bool vnc_display_open(VncDisplay *vd, Error **errp);