C++ cairo_surface_flush函数代码示例

void CairoFont::CairoFontTexture::Clear(Vector<4,float> color) {
    clearcol = color;
    cairo_set_source_rgba (cr, color[0], color[1], color[2], color[3]);
    cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
    cairo_paint(cr);
    cairo_surface_flush(surface);
    FireChangedEvent(0, 0, width, height);
}

static cairo_status_t
_cairo_surface_subsurface_flush (void *abstract_surface)
{
    cairo_surface_subsurface_t *surface = abstract_surface;

    cairo_surface_flush (surface->target);
    return surface->target->status;
}

static void _x11_backwin_end_paint(
    struct _x11_backwin *self, cairo_t *cr)
{
    assert(self->managed);

    cairo_destroy(cr);
    cairo_surface_flush(self->surface);
}

void DrawVKWindow(VKWindow* vkWindow)
{
    int             i;
    int             iPos;
    cairo_t *cr;
    FcitxVKState *vkstate = vkWindow->owner;
    VKS *vks = vkstate->vks;

    FcitxConfigColor *fontColor = InvokeVaArgs(vkstate->owner, FCITX_CLASSIC_UI,
                                               GETKEYBOARDFONTCOLOR);
    char **font = InvokeVaArgs(vkstate->owner, FCITX_CLASSIC_UI, GETFONT);

    if (!fontColor || !font) {
        fontColor = &blackColor;
        font = &vkWindow->defaultFont;
    }

    cr = cairo_create(vkWindow->surface);
    cairo_surface_t* vkimage = LoadVKImage(vkWindow);
    cairo_set_source_surface(cr, vkimage, 0, 0);
    cairo_paint(cr);
    /* 显示字符 */
    /* 名称 */
    OutputString(cr, vks[vkstate->iCurrentVK].strName, *font, vkWindow->fontSize, false , (VK_WINDOW_WIDTH - StringWidth(vks[vkstate->iCurrentVK].strName, *font, vkWindow->fontSize, false)) / 2, 6, fontColor);

    /* 第一排 */
    iPos = 13;
    for (i = 0; i < 13; i++) {
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][1], *font, vkWindow->fontSize, false, iPos, 27, fontColor);
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][0], *font, vkWindow->fontSize, false, iPos - 5, 40, fontColor);
        iPos += 24;
    }
    /* 第二排 */
    iPos = 48;
    for (i = 13; i < 26; i++) {
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][1], *font, vkWindow->fontSize, false, iPos, 55, fontColor);
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][0], *font, vkWindow->fontSize, false, iPos - 5, 68, fontColor);
        iPos += 24;
    }
    /* 第三排 */
    iPos = 55;
    for (i = 26; i < 37; i++) {
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][1], *font, vkWindow->fontSize, false, iPos, 83, fontColor);
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][0], *font, vkWindow->fontSize, false, iPos - 5, 96, fontColor);
        iPos += 24;
    }

    /* 第四排 */
    iPos = 72;
    for (i = 37; i < 47; i++) {
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][1], *font, vkWindow->fontSize, false, iPos, 111, fontColor);
        OutputString(cr, vks[vkstate->iCurrentVK].strSymbol[i][0], *font, vkWindow->fontSize, false, iPos - 5, 124, fontColor);
        iPos += 24;
    }

    cairo_destroy(cr);
    cairo_surface_flush(vkWindow->surface);
}

na_tray_child_expose_event (GtkWidget      *widget,
                            GdkEventExpose *event)
#endif
{
  NaTrayChild *child = NA_TRAY_CHILD (widget);
  GdkWindow *window = gtk_widget_get_window (widget);

  if (na_tray_child_has_alpha (child))
    {
      /* Clear to transparent */
#if !GTK_CHECK_VERSION (3, 0, 0)
      cairo_t *cr = gdk_cairo_create (window);
#endif
      cairo_set_source_rgba (cr, 0, 0, 0, 0);
      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
#if GTK_CHECK_VERSION (3, 0, 0)
      cairo_paint (cr);
#else
      gdk_cairo_region (cr, event->region);
      cairo_fill (cr);
      cairo_destroy (cr);
#endif
    }
  else if (child->parent_relative_bg)
    {
      /* Clear to parent-relative pixmap */
#if GTK_CHECK_VERSION (3, 0, 0)
      GdkWindow *window;
      cairo_surface_t *target;
      GdkRectangle clip_rect;

      window = gtk_widget_get_window (widget);
      target = cairo_get_group_target (cr);

      gdk_cairo_get_clip_rectangle (cr, &clip_rect);

      /* Clear to parent-relative pixmap
       * We need to use direct X access here because GDK doesn't know about
       * the parent relative pixmap. */
      cairo_surface_flush (target);

      XClearArea (GDK_WINDOW_XDISPLAY (window),
                  GDK_WINDOW_XID (window),
                  clip_rect.x, clip_rect.y,
                  clip_rect.width, clip_rect.height,
                  False);
      cairo_surface_mark_dirty_rectangle (target,
                                          clip_rect.x, clip_rect.y,
                                          clip_rect.width, clip_rect.height);
#else
      gdk_window_clear_area (window,
                             event->area.x, event->area.y,
                             event->area.width, event->area.height);
#endif
    }

  return FALSE;
}

static PyObject *
surface_flush (PycairoSurface *o)
{
    cairo_surface_flush (o->surface);

    if (Pycairo_Check_Status (cairo_surface_status(o->surface)))
	return NULL;
    Py_RETURN_NONE;
}

static PyObject *
surface_flush (PycairoSurface *o)
{
    Py_BEGIN_ALLOW_THREADS
    cairo_surface_flush (o->surface);
    Py_END_ALLOW_THREADS
    RETURN_NULL_IF_CAIRO_SURFACE_ERROR(o->surface);
    Py_RETURN_NONE;
}

void drawPointerText(){
	cairo_surface_t *surface;
        cairo_t *cr;
	const unsigned char* surfaceData;

	if (viewType == TWO_D){
		xX = 1.4, yY = Ypointer + 0.1, zZ = 0;
		}
	else {
		xX = Xpointer - 0.1, yY = 0.45, zZ = 0;
		}
	
	if (viewType == TWO_D){
		sprintf(textToRender, " %d Hz", (int)(storedFreq * hzStep));
		}
	else {
		sprintf(textToRender, "%d Hz      %f dB", (int)(storedFreq * hzStep), storedIntensity);
		}
		
	surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 128, 32);
	cr = cairo_create (surface);
	cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
	cairo_set_font_size (cr, 10.0);
	cairo_move_to (cr, 0, 16);
	cairo_show_text (cr, textToRender);
	cairo_surface_flush(surface);
	surfaceData = cairo_image_surface_get_data (surface);

	unsigned Texture = 0;

	glGenTextures(1, &Texture);
	glBindTexture(GL_TEXTURE_2D, Texture);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, cairo_image_surface_get_width(surface), cairo_image_surface_get_height(surface), 0, GL_BGRA, GL_UNSIGNED_BYTE, surfaceData);
	
	glBegin(GL_QUADS);
	glColor3f(1, 1, 1);
	glTexCoord2d(0, 0); glVertex3d(xX, yY, 0.01);
	glTexCoord2d(1, 0); glVertex3d(xX+0.3, yY, 0.01);
	glTexCoord2d(1, 1); glVertex3d(xX+0.3, yY-0.15, 0.01);
	glTexCoord2d(0, 1); glVertex3d(xX, yY-0.15, 0.01);
	glEnd();
	
	glDeleteTextures(1, &Texture);
	cairo_destroy (cr);
        cairo_surface_destroy (surface);
	
	if (viewType == TWO_D){
		yY += y_2d/10;
		}
	else {
		xX += x/10;
		}
}

static void
glide_window_export_pdf_real (GlideWindow *w,
			      const gchar *filename)
{
  cairo_surface_t *pdf_surface;
  cairo_t *cr;
  gint width, height;
  gint o_slide;
  int i = 0;
  
  glide_window_fullscreen_stage (w);  
  while (g_main_context_pending (NULL))
    g_main_context_iteration (NULL, TRUE);
  
  width = clutter_actor_get_width (w->priv->stage);
  height = clutter_actor_get_height (w->priv->stage);

  pdf_surface = cairo_pdf_surface_create (filename, width, height);
  cr = cairo_create (pdf_surface);
  
  o_slide = glide_stage_manager_get_current_slide (w->priv->manager);
  
  for (i = 0; i < glide_document_get_n_slides (w->priv->document); i++)
    {
      guchar *pixels;
      guchar *p;
      GdkPixbuf *pb;

      glide_stage_manager_set_current_slide (w->priv->manager, i);

      pixels = clutter_stage_read_pixels (CLUTTER_STAGE (w->priv->stage), 0, 0, width, height);
      for (p = pixels + width * height * 4; p > pixels; p -= 3)
	*(--p) = 255; 


      pb = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE,
				     8, width, height, width * 4,
				     (GdkPixbufDestroyNotify) g_free,
				     NULL); 
      
      gdk_cairo_set_source_pixbuf (cr, pb, 0, 0);
      cairo_rectangle (cr, 0, 0, width, height);
      cairo_fill (cr);

      cairo_surface_show_page (pdf_surface);      
      
      g_object_unref (G_OBJECT (pb));
    }
  cairo_surface_flush (pdf_surface);

  cairo_destroy (cr);
  cairo_surface_destroy (pdf_surface);
  
  glide_window_unfullscreen_stage (w);
  glide_stage_manager_set_current_slide (w->priv->manager, o_slide);
}

int 
main(int argc, char** argv) {
   
   cairo_surface_t *sfc;
   cairo_t *ctx;
   
   int x, y;
   struct timespec ts = {0, 500000000};
   
   int running;

   x = y = 0;
   sfc = cairo_create_x11_surface(&x, &y);
   ctx = cairo_create(sfc);
   cairo_set_antialias(ctx, CAIRO_ANTIALIAS_NONE);

   mesh_t* m = mesh_create(x, y);

   for (running = 1; running;) {

      cairo_push_group(ctx);
      
         cairo_set_source_rgb(ctx, 0.1, 0.1, 0.1);
         cairo_paint(ctx);
         
         mesh_draw(ctx, m);

      cairo_pop_group_to_source(ctx);
      cairo_paint(ctx);

      cairo_surface_flush(sfc);

      int event=0;
      switch (event=cairo_check_event(sfc, 0)) {
         case 0xff53:   // right cursor
            break;

         case 0xff51:   // left cursor
            break;

         case 0xff1b:   // Esc
         case -1:       // left mouse button
            running = 0;
            break;
      }

      nanosleep(&ts, NULL);
   }

   mesh_free(m);

   cairo_destroy(ctx);
   cairo_close_x11_surface(sfc);

   return 0;
}

void widgetDraw(widget *self)
{
	int i;

	// See if we need to be redrawn
	if (self->needsRedraw)
	{
		void *bits = cairo_image_surface_get_data(cairo_get_target(self->cr));

		self->needsRedraw = false;

		// Mark the texture as needing uploading
		self->textureNeedsUploading = true;

		// Clear the current context
		cairo_set_operator(self->cr, CAIRO_OPERATOR_SOURCE);
		cairo_set_source_rgba(self->cr, 0.0, 0.0, 0.0, 0.0);
		cairo_paint(self->cr);

		// Restore the compositing operator back to the default
		cairo_set_operator(self->cr, CAIRO_OPERATOR_OVER);

		// Save (push) the current context
		cairo_save(self->cr);

		// Redaw ourself
		widgetDoDraw(self);

		// Restore the context
		cairo_restore(self->cr);

		// Update the texture if widgetEndGL has not done it for us
		if (self->textureNeedsUploading)
		{
			// Flush the cairo surface to ensure that all drawing is completed
			cairo_surface_flush(cairo_get_target(self->cr));

			glBindTexture(GL_TEXTURE_RECTANGLE_ARB, self->textureId);

			glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, self->size.x,
			             self->size.y, 0, GL_BGRA, GL_UNSIGNED_BYTE, bits);

			self->textureNeedsUploading = false;
		}

	}

	// Draw our children (even if we did not need redrawing our children might)
	for (i = 0; i < vectorSize(self->children); i++)
	{
		widget *child = vectorAt(self->children, i);

		// Ask the child to re-draw itself
		widgetDraw(child);
	}
}

    void start()
    {
        cairo_surface_t* cairo_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, m_width, m_height);
        cairo_t* cr = cairo_create(cairo_surface);

        cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.0);
        cairo_paint(cr);

        PangoFontDescription *font_description = pango_font_description_new();
        pango_font_description_set_family(font_description, m_font.Family.c_str());
        pango_font_description_set_style(font_description, m_font.Style);
        pango_font_description_set_weight(font_description, m_font.Weight);
        pango_font_description_set_variant(font_description, m_font.Variant);
        pango_font_description_set_size(font_description, m_font.Size * PANGO_SCALE);

        PangoLayout *layout = pango_cairo_create_layout(cr);
        pango_layout_set_font_description(layout, font_description);
        pango_layout_set_text(layout, m_text_file.file_content_p(), -1);

        unsigned char* color = m_font.ColorRGB; // shortcut
        cairo_set_source_rgb(cr, color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
        cairo_move_to(cr, 0.0, 0.0);
        pango_cairo_show_layout(cr, layout);

        // To texture
        {
            cairo_surface_flush(cairo_surface);
            std::vector<unsigned char> rgba_data;
            rgba_from_cairo_ARGB32(
                cairo_image_surface_get_data(cairo_surface)
                , m_width
                , m_height
                , cairo_image_surface_get_stride(cairo_surface)
                , rgba_data
            );

            glPixelStorei ( GL_UNPACK_ALIGNMENT, 1 );
            m_texture.bind();

            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, &(rgba_data[0]));

            assert(glGetError() == GL_NO_ERROR);

            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            assert(glGetError() == GL_NO_ERROR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            assert(glGetError() == GL_NO_ERROR);
        }

        g_object_unref(layout);
        pango_font_description_free(font_description);

        cairo_destroy(cr);
        cairo_surface_destroy(cairo_surface);
    }

PP_Bool
ppb_browser_font_trusted_draw_text_at(PP_Resource font, PP_Resource image_data,
                                      const struct PP_BrowserFont_Trusted_TextRun *text,
                                      const struct PP_Point *position, uint32_t color,
                                      const struct PP_Rect *clip, PP_Bool image_data_is_opaque)
{
    (void)image_data_is_opaque; // TODO: is it worth implementing?
    struct pp_browser_font_s *bf = pp_resource_acquire(font, PP_RESOURCE_BROWSER_FONT);
    if (!bf)
        return PP_FALSE;
    struct pp_image_data_s *id = pp_resource_acquire(image_data, PP_RESOURCE_IMAGE_DATA);
    if (!id) {
        pp_resource_release(font);
        return PP_FALSE;
    }

    cairo_t *cr = cairo_create(id->cairo_surf);
    if (clip) {
        cairo_rectangle(cr, clip->point.x, clip->point.y, clip->size.width, clip->size.height);
        cairo_clip(cr);
    }

    PangoFontMetrics *m = pango_font_get_metrics(bf->font, NULL);
    int32_t ascent = pango_font_metrics_get_ascent(m) / PANGO_SCALE;
    cairo_surface_mark_dirty(id->cairo_surf);
    if (position)
        cairo_move_to(cr, position->x, position->y - ascent);
    else
        cairo_move_to(cr, 0, 0);
    pango_font_metrics_unref(m);

    cairo_set_source_rgba(cr, ((color >> 16) & 0xffu) / 255.0,
                              ((color >> 8) & 0xffu) / 255.0,
                              ((color >> 0) & 0xffu) / 255.0,
                              ((color >> 24) & 0xffu) / 255.0);

    PangoLayout *layout = pango_cairo_create_layout(cr);
    uint32_t len = 0;
    const char *s = "";
    if (text->text.type == PP_VARTYPE_STRING)
        s = ppb_var_var_to_utf8(text->text, &len);

    // TODO: factor into rtl direction
    pango_layout_set_font_description(layout, bf->font_desc);
    pango_layout_set_text(layout, s, len);
    pango_cairo_layout_path(cr, layout);
    cairo_fill(cr);
    g_object_unref(layout);
    cairo_surface_flush(id->cairo_surf);
    cairo_destroy(cr);

    pp_resource_release(font);
    pp_resource_release(image_data);
    return PP_FALSE;
}

int gt_graphics_cairo_save_to_file(const GtGraphics *gg, const char *filename,
                                GtError *err)
{
  const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg;
  cairo_surface_t *bgsurf = NULL;
  cairo_t *bgc = NULL;
  cairo_status_t rval;
  GtFile *outfile;
  gt_error_check(err);
  gt_assert(g && filename);

  /* do nothing if no surface was created */
  if (g->from_context)
    return 0;
  switch (g->type)
  {
    case GT_GRAPHICS_PNG:
      /* blend rendered image with background color */
      bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width,
                                          g->height);
      bgc = cairo_create(bgsurf);
      cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green,
                                 g->bg_color.blue, g->bg_color.alpha);
      cairo_paint(bgc);
      cairo_set_source_surface(bgc, g->surf, 0, 0);
      cairo_paint(bgc);
      rval = cairo_surface_write_to_png(bgsurf, filename);
      gt_assert(rval == CAIRO_STATUS_SUCCESS ||
                rval == CAIRO_STATUS_WRITE_ERROR);
      if (rval == CAIRO_STATUS_WRITE_ERROR)
      {
        cairo_destroy(bgc);
        cairo_surface_destroy(bgsurf);
        gt_error_set(err, "an I/O error occurred while attempting "
                          "to write image file \"%s\"", filename);
        return -1;
      }
      cairo_destroy(bgc);
      cairo_surface_destroy(bgsurf);
      break;
    default:
      cairo_show_page(g->cr);
      cairo_surface_flush(g->surf);
      cairo_surface_finish(g->surf);
      outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, filename, "w+", err);
      if (outfile)
      {
        gt_file_xwrite(outfile, gt_str_get_mem(g->outbuf),
                       gt_str_length(g->outbuf));
        gt_file_delete(outfile);
      } else return -1;
      break;
  }
  return 0;
}

int window_get_pixel_color(struct OsecpuWindow* window, int x, int y)
{
	// XXX: 必ずARGB32形式であると仮定して処理が書いてある
	// 透過はされてないはずなので上位8bitは必ず0になるようにする
	const unsigned char* surface_data;
	int width;
	width = cairo_image_surface_get_width(window->surface);
	cairo_surface_flush(window->surface);
	surface_data = cairo_image_surface_get_data(window->surface);
	return *((int*)surface_data + x + y*width) & 0x00ffffff;
}