// default constructor sets y coordinate to bottom left of the screen
	Balloon(int X,double UPMOVE_LENGTH,int SWIRL_THRESHOLD,const char* filename):y(WINDOW_HEIGHT + height/2),hit(false), wait(0), swirl(0), swirling(false)
	{
		x=X;
		upmove_length = UPMOVE_LENGTH;
        swirl_threshold=SWIRL_THRESHOLD;
		image = cairo_image_surface_create_from_png(filename);
		blast_image = cairo_image_surface_create_from_png("blast.png");
    }

	//constructor
	Bird(int a, int b, double speed):y(a), isout(true), tip(0), x(b),isdead(false) ,rightmove_length(speed),hit(false), image_switcher(true), wait(10)
	{
		swirl_threshold=30;
		image1 = cairo_image_surface_create_from_png("bird1.png");
		image2 = cairo_image_surface_create_from_png("bird2.png");
		deadbird = cairo_image_surface_create_from_png("deadbird.png");
		tip=x;
	}

bool
args_parse (args_t *args, int argc, char **argv)
{
    int i;
    if (argc < 3) {
	fprintf (stderr, "%s", copyright);
	fprintf (stderr, "%s", usage);
	return false;
    }
    for (i = 0; i < argc; i++) {
	if (i == 1) {
	    args->surface_a = cairo_image_surface_create_from_png (argv[1]);
	    if (cairo_surface_status (args->surface_a))
	    {
		fprintf (stderr, "FAIL: Cannot open %s: %s\n",
			 argv[1], cairo_status_to_string (cairo_surface_status (args->surface_a)));
		return false;
	    }
	} else if (i == 2) {
	    args->surface_b = cairo_image_surface_create_from_png (argv[2]);
	    if (cairo_surface_status (args->surface_b))
	    {
		fprintf (stderr, "FAIL: Cannot open %s: %s\n",
			 argv[2], cairo_status_to_string (cairo_surface_status (args->surface_b)));
		return false;
	    }
	} else {
	    if (strstr(argv[i], "-fov")) {
		if (i + 1 < argc) {
		    args->FieldOfView = (float) atof(argv[i + 1]);
		}
	    } else if (strstr(argv[i], "-verbose")) {
		args->Verbose = true;
	    } else 	if (strstr(argv[i], "-threshold")) {
		if (i + 1 < argc) {
		    args->ThresholdPixels = atoi(argv[i + 1]);
		}
	    } else 	if (strstr(argv[i], "-gamma")) {
		if (i + 1 < argc) {
		    args->Gamma = (float) atof(argv[i + 1]);
		}
	    }else 	if (strstr(argv[i], "-luminance")) {
		if (i + 1 < argc) {
		    args->Luminance = (float) atof(argv[i + 1]);
		}
	    }
	}
    } /* i */
    return true;
}

cairo_surface_t *
cairo_test_get_reference_image (cairo_test_context_t *ctx,
				const char *filename,
				cairo_bool_t flatten)
{
    cairo_surface_t *surface;

    if (ctx->ref_name != NULL) {
	if (strcmp (ctx->ref_name, filename) == 0)
	    return _cairo_test_flatten_reference_image (ctx, flatten);

	cairo_surface_destroy (ctx->ref_image);
	ctx->ref_image = NULL;

	cairo_surface_destroy (ctx->ref_image_flattened);
	ctx->ref_image_flattened = NULL;

	free (ctx->ref_name);
	ctx->ref_name = NULL;
    }

    surface = cairo_image_surface_create_from_png (filename);
    if (cairo_surface_status (surface))
	return surface;

    ctx->ref_name = xstrdup (filename);
    ctx->ref_image = surface;
    return _cairo_test_flatten_reference_image (ctx, flatten);
}

HippoCanvasThemeImage *
hippo_canvas_theme_image_new (const char *filename,
			      int         border_top,
			      int         border_right,
			      int         border_bottom,
			      int         border_left,
			      GError    **error)
{
    HippoCanvasThemeImage *image;

    g_return_val_if_fail(error == NULL || *error == NULL, NULL);

    image = g_object_new(HIPPO_TYPE_CANVAS_THEME_IMAGE, NULL);

#ifdef HAVE_LIBRSVG
    if (g_str_has_suffix(filename, ".svg") || g_str_has_suffix(filename, ".SVG")) {
	image->type = THEME_IMAGE_SVG;

	image->u.svg = rsvg_handle_new_from_file(filename, error);
	if (image->u.svg == NULL) {
	    /* librsvg does a horrible job setting error, it's probably NULL */
	    if (*error == NULL)
		g_set_error(error,
			    HIPPO_CANVAS_THEME_IMAGE_ERROR,
			    HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
			    "Failed to read SVG image '%s'", filename);
	    goto fail;
	}
    } else
#endif	
    if (g_str_has_suffix(filename, ".png") || g_str_has_suffix(filename, ".PNG")) {
	image->type = THEME_IMAGE_SURFACE;

	image->u.surface = cairo_image_surface_create_from_png(filename);
	if (image->u.surface == NULL) {
	    g_set_error(error,
			HIPPO_CANVAS_THEME_IMAGE_ERROR,
			HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
			"Failed to read PNG image '%s'", filename);
	    goto fail;
	}
    } else {
	g_set_error(error,
		    HIPPO_CANVAS_THEME_IMAGE_ERROR,
		    HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
		    "Unknown filetype for image '%s'", filename);
	goto fail;
    }

    image->border_top = border_top;
    image->border_right = border_right;
    image->border_bottom = border_bottom;
    image->border_left = border_left;

    return image;

fail:
    g_object_unref(image);
    return NULL;
}

static cairo_surface_t *
png_acquire (cairo_pattern_t *pattern, void *closure,
	     cairo_surface_t *target,
	     const cairo_rectangle_int_t *extents)
{
    return cairo_image_surface_create_from_png (closure);
}

static cairo_pattern_t *
_cairo_film_pattern_create (void)
{
	static cairo_pattern_t *film_pattern = NULL;
	cairo_pattern_t        *pattern;
	static GMutex           mutex;

	g_mutex_lock (&mutex);
	if (film_pattern == NULL) {
		char            *filename;
		cairo_surface_t *surface;

		filename = g_build_filename (GTHUMB_ICON_DIR, "filmholes.png", NULL);
		surface = cairo_image_surface_create_from_png (filename);
		film_pattern = cairo_pattern_create_for_surface (surface);
		cairo_pattern_set_filter (film_pattern, CAIRO_FILTER_GOOD);
		cairo_pattern_set_extend (film_pattern, CAIRO_EXTEND_REPEAT);

		cairo_surface_destroy (surface);
		g_free (filename);

	}
	pattern = cairo_pattern_reference (film_pattern);
	g_mutex_unlock (&mutex);

	return pattern;
}

gboolean load_color(GtkWidget* w, GdkEvent* event)
{
    printf("sdd\n");
    img = cairo_image_surface_create_from_png("board.png");
    gtk_widget_queue_draw(w);
    return TRUE;
}

/* @brief Draw an image at the given offset.
 *
 * @param cr A cairo context for drawing to the screen.
 * @param file The image to be drawn.
 * @return The advance in the x direction.
 */
static uint32_t draw_image(cairo_t *cr, const char *file, offset_t offset) {
  wordexp_t expanded_file;
  if (wordexp(file, &expanded_file, 0)) {
    fprintf(stderr, "Error expanding file %s\n", file);
  } else {
    file = expanded_file.we_wordv[0];
  }

  if (access(file, F_OK) == -1) {
    fprintf(stderr, "Cannot open image file %s\n", file);
    return 0;
  }

  cairo_surface_t *img;
  img = cairo_image_surface_create_from_png(file);
  int w = cairo_image_surface_get_width(img);
  int h = cairo_image_surface_get_height(img);
  int neww = (int)(((float)(settings.height) * ((float)(w) / (float)(h))) + 0.49999999);
  img = scale_surface (img, w, h, neww, settings.height);
  h = settings.height;
  w = neww;
  /* Attempt to center the image if it is not the height of the line. */ 
  int image_offset = (h - settings.height) / 2;
  cairo_set_source_surface(cr, img, offset.x, offset.image_y - h + image_offset);
  cairo_mask_surface(cr, img, offset.x, offset.image_y - h + image_offset);

  return w;
}

int main(int argc, char *argv[])
{
  GtkWidget *window;
  GtkWidget *darea;
  
  glob.image = cairo_image_surface_create_from_png("/home/httpd/html/gartner_hype_cycle20112.png");

  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  darea = gtk_drawing_area_new();
  gtk_container_add(GTK_CONTAINER (window), darea);

  /* GTK 3 uses "draw", GTK 2 uses "expose-event" - http://stackoverflow.com/questions/8932426/how-to-draw-a-line-in-a-gtkdrawingarea-using-cairo-with-gtk3 */
  g_signal_connect(G_OBJECT(darea), "draw", 
      G_CALLBACK(on_draw_event), NULL); 
  g_signal_connect(window, "destroy",
      G_CALLBACK (gtk_main_quit), NULL);

  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 1000, 900); 
  gtk_window_set_title(GTK_WINDOW(window), "Image");

  gtk_widget_show_all(window);

  gtk_main();

  cairo_surface_destroy(glob.image);

  return 0;
}

static JSBool
createFromPNG_func(JSContext *context,
                   JSObject  *obj,
                   uintN      argc,
                   jsval     *argv,
                   jsval     *retval)
{
    char *filename;
    cairo_surface_t *surface;
    JSObject *surface_wrapper;

    if (!gjs_parse_args(context, "createFromPNG", "s", argc, argv,
                        "filename", &filename))
        return JS_FALSE;

    surface = cairo_image_surface_create_from_png(filename);

    if (!gjs_cairo_check_status(context, cairo_surface_status(surface), "surface"))
        return JS_FALSE;

    surface_wrapper = JS_NewObject(context, &gjs_cairo_image_surface_class, NULL, NULL);
    if (!surface_wrapper) {
        gjs_throw(context, "failed to create surface");
        return JS_FALSE;
    }
    gjs_cairo_surface_construct(context, surface_wrapper, surface);
    cairo_surface_destroy(surface);

    *retval = OBJECT_TO_JSVAL(surface_wrapper);
    return JS_TRUE;
}

void set_graphics(int g)
{
	char buf[1024];
	term_data* td = &term_window[0];
	int i = 0;
	
	do 
	{
		if (g == graphics_modes[i].grafID) 
		{
			arg_graphics = g;
			ANGBAND_GRAF = graphics_modes[i].pref;
			path_build(buf, sizeof(buf), ANGBAND_DIR_XTRA_GRAF, graphics_modes[i].file);
			use_transparency = FALSE;
			tile_w = graphics_modes[i].cell_width;
			tile_h = graphics_modes[i].cell_height;
			break;
		}
	} while (graphics_modes[i++].grafID != 0);

	/* Free up old graphics */
	if (graphical_tiles != NULL) cairo_surface_destroy(graphical_tiles);
	if (tile_pattern != NULL) cairo_pattern_destroy(tile_pattern);
		
	graphical_tiles = cairo_image_surface_create_from_png(buf);
	tile_pattern = cairo_pattern_create_for_surface(graphical_tiles);
	
	g_assert(graphical_tiles != NULL);
	g_assert(tile_pattern != NULL);
	scale = cairo_font_scaling(td);
	cairo_pattern_set_matrix(tile_pattern, &scale);
	force_redraw();
}

static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
    const cairo_test_context_t *ctx = cairo_test_get_context (cr);
    char *filename;
    cairo_surface_t *surface;

    xasprintf (&filename, "%s/%s", ctx->srcdir,
	       "create-from-png.ref.png");

    surface = cairo_image_surface_create_from_png (filename);
    if (cairo_surface_status (surface)) {
	cairo_test_status_t result;

	result = cairo_test_status_from_status (ctx,
						cairo_surface_status (surface));
	if (result == CAIRO_TEST_FAILURE) {
	    cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
			    filename,
			    cairo_status_to_string (cairo_surface_status (surface)));
	}

	free (filename);
	return result;
    }

    cairo_set_source_surface (cr, surface, 0, 0);
    cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
    cairo_paint (cr);

    cairo_surface_destroy (surface);

    free (filename);
    return CAIRO_TEST_SUCCESS;
}

void gui_init(dt_lib_module_t *self)
{
  char filename[DT_MAX_PATH_LEN];
  char datadir[DT_MAX_PATH_LEN];
  /* initialize ui widgets */
  dt_lib_darktable_t *d = (dt_lib_darktable_t *)g_malloc(sizeof(dt_lib_darktable_t));
  self->data = (void *)d;
  memset(d,0,sizeof(dt_lib_darktable_t));

  /* create drawingarea */
  self->widget = gtk_event_box_new();

  /* connect callbacks */
  g_signal_connect (G_OBJECT (self->widget), "expose-event",
                    G_CALLBACK (_lib_darktable_expose_callback), self);
  g_signal_connect (G_OBJECT (self->widget), "button-press-event",
                    G_CALLBACK (_lib_darktable_button_press_callback), self);

  /* set size of draw area */
  gtk_widget_set_size_request(self->widget, 220, 48);

  /* create a cairo surface of dt icon */
  dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
  snprintf(filename, DT_MAX_PATH_LEN, "%s/pixmaps/idbutton.png", datadir);
  d->image = cairo_image_surface_create_from_png(filename);

}

int
main (int argc, char *argv[])
{

  GtkWidget *window;

  gtk_init(&argc, &argv);
  
  image = cairo_image_surface_create_from_png("desktop1.png");
  /*不支持jpg格式的图片？
   */
  //image = cairo_image_surface_create_from_png("bg1.jpg");
  //image = cairo_image_surface_create_from_png("desktop1.png");
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
  g_signal_connect(window, "expose-event",
      G_CALLBACK(on_expose_event), NULL);
  g_signal_connect(window, "destroy",
      G_CALLBACK(gtk_main_quit), NULL);
  
 
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 800, 480); 
  gtk_widget_set_app_paintable(window, TRUE);

  gtk_widget_show_all(window);

  gtk_main();
  cairo_surface_destroy(image);

  return 0;
}

/* METH_O | METH_CLASS */
static PyObject *
image_surface_create_from_png (PyTypeObject *type, PyObject *file)
{
    PyObject* reader;

    if (PyObject_TypeCheck (file, &PyBaseString_Type)) {
	return PycairoSurface_FromSurface (
            cairo_image_surface_create_from_png (PyString_AsString(file)),
            NULL);
    }

    /* file or file-like object argument */
    reader = PyObject_GetAttrString (file, "read");
    if (reader == NULL || !PyCallable_Check (reader)) {
	Py_XDECREF(reader);
	PyErr_SetString(PyExc_TypeError,
"ImageSurface.create_from_png argument must be a filename (str), file object, "
"or an object that has a \"read\" method (like StringIO)");
	return NULL;
    }
    Py_DECREF(reader);

    return PycairoSurface_FromSurface (
        cairo_image_surface_create_from_png_stream (_read_func, file), NULL);
}

/* Load a file image in the window. */
static void
load_file               ()
{
  if (background_data->background_cr)
    {
      cairo_surface_t *surface = cairo_image_surface_create_from_png (background_data->background_image);
      cairo_t *cr = cairo_create (surface);

      gtk_window_set_opacity (GTK_WINDOW (background_data->background_window), 1.0);
	
      gint new_height = 0;
      gint new_width = 0;
      new_height = gdk_window_get_height (gtk_widget_get_window (background_data->background_window));
      new_width = gdk_window_get_width (gtk_widget_get_window (background_data->background_window));

      cairo_surface_t *scaled_surface = scale_surface (surface, new_width, new_height );
	
      cairo_surface_destroy (surface);
	
      cairo_destroy (cr);
	
      cairo_set_source_surface (background_data->background_cr, scaled_surface, 0.0, 0.0);
	
      cairo_paint (background_data->background_cr);
      cairo_stroke (background_data->background_cr);
	
      cairo_surface_destroy (scaled_surface);
	
#ifndef _WIN32
      gtk_widget_input_shape_combine_region (background_data->background_window, NULL);
#endif
    }
}

static inline cairo_surface_t *
get_icon_from_gconf (GConfClient *client,
                     const gchar *plugin_id)
{
  gchar *icon_path;

  icon_path = get_icon_path_from_gconf (client, plugin_id);

  if (icon_path)
    {
      cairo_surface_t *icon, *scaled_icon = NULL;
      cairo_status_t status;

      icon = cairo_image_surface_create_from_png (icon_path);
      status = cairo_surface_status (icon);

      if (status != CAIRO_STATUS_SUCCESS)
        g_warning ("%s. Could not get thumbnail from file %s. %s",
                   __FUNCTION__,
                   icon_path,
                   cairo_status_to_string (status));
      else
        scaled_icon = scale_icon_if_required (icon);

      cairo_surface_destroy (icon);
      g_free (icon_path);

      return scaled_icon;
    }

  return NULL;
}

Picture *Picture::from_png(const char *filename) {
    cairo_surface_t *pngs = cairo_image_surface_create_from_png(filename);

    if (cairo_surface_status(pngs) != CAIRO_STATUS_SUCCESS) {
        cairo_surface_destroy(pngs);
        throw std::runtime_error("Failed to load PNG to Cairo surface");
    }

    cairo_format_t nf = cairo_image_surface_get_format(pngs);

    if (nf != CAIRO_FORMAT_ARGB32 && nf != CAIRO_FORMAT_RGB24) {
        cairo_surface_destroy(pngs);
        throw std::runtime_error("PNG uses unsupported pixel format");
    } 

    Picture *ret = Picture::alloc(
        cairo_image_surface_get_width(pngs),
        cairo_image_surface_get_height(pngs),
        4*cairo_image_surface_get_width(pngs),
        BGRA8
    );
        
    int xcopy = 4*ret->w;
    int stride = cairo_image_surface_get_stride(pngs);
    uint8_t *data = (uint8_t *)cairo_image_surface_get_data(pngs);

    /* copy data */
    for (int ycopy = 0; ycopy < ret->h; ++ycopy) {
        memcpy(ret->scanline(ycopy), data + stride * ycopy, xcopy);
    }
    
    cairo_surface_destroy(pngs);
    return ret;
}

int main(int argc, char** argv)
{
    cairo_surface_t *surface;
    cairo_t *cr;
    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1300, 760);
    cr = cairo_create (surface);

int w, h;
cairo_surface_t *image;

cairo_arc (cr, 128.0, 128.0, 76.8, 0, 2*M_PI);
cairo_clip (cr);
cairo_new_path (cr); /* path not consumed by clip()*/

image = cairo_image_surface_create_from_png ("new.png");
w = cairo_image_surface_get_width (image);
h = cairo_image_surface_get_height (image);

cairo_scale (cr, 256.0/w, 256.0/h);

cairo_set_source_surface (cr, image, 0, 0);
cairo_paint (cr);

cairo_surface_destroy (image);
    cairo_destroy (cr);
    cairo_surface_write_to_png (surface, "hello.png");
    cairo_surface_destroy (surface);

    return 0;
}