// 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;
}
JSBool
cairo::JSSurface::Constructor(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
DOC_BEGIN("");
DOC_END;
if (JSA_GetClass(cx,obj) != Class()) {
JS_ReportError(cx,"Constructor for %s bad object; did you forget a 'new'?",ClassName());
return JS_FALSE;
}
NATIVE * newNative;
cairo::JSSurface * myNewObject = 0;
dom::NodePtr myImageNode;
std::string myPath;
if (argc == 1) {
if (convertFrom(cx, argv[0], myImageNode)) {
cairo_surface_t *mySurface = createFromImageNode(myImageNode);
newNative = NATIVE::get(mySurface);
cairo_surface_destroy(mySurface);
} else if(convertFrom(cx, argv[0], myPath)) {
cairo_surface_t *mySurface = cairo_image_surface_create_from_png(myPath.c_str());
newNative = NATIVE::get(mySurface);
cairo_surface_destroy(mySurface);
} else {
JS_ReportError(cx, "Need an image node or png path to construct a cairo context.");
return JS_FALSE;
}
} else {
JS_ReportError(cx,"Constructor for %s: bad number of arguments: expected none () %d",ClassName(), argc);
return JS_FALSE;
}
JSCairoSurfaceWrapper::STRONGPTR _myOwnerPtr(newNative);
myNewObject = new cairo::JSSurface(dynamic_cast_Ptr<NATIVE>(_myOwnerPtr), newNative);
JSCairoSurfaceWrapper::WEAKPTR _mySelfPtr(_myOwnerPtr);
newNative->setSelfPtr(_mySelfPtr);
myNewObject->_myImageNode = myImageNode;
if (myNewObject) {
JS_SetPrivate(cx,obj,myNewObject);
return JS_TRUE;
}
JS_ReportError(cx,"cairo::JSSurface::Constructor: bad parameters");
return JS_FALSE;
}
int l_cairo_image_surface_create_from_png(lua_State * L)
{
const char * filename = luaL_checkstring(L, 1);
cairo_surface_t ** cs = lua_newuserdata(L, sizeof(cairo_surface_t *));
*cs = cairo_image_surface_create_from_png(filename);
luaL_setmetatable(L, MT_NAME_CAIRO_SURFACE);
return 1;
}
cairo_surface_t *
cairo_boilerplate_get_image_surface_from_png (const char *filename,
int width,
int height,
cairo_bool_t flatten)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface))
return surface;
if (flatten) {
cairo_t *cr;
cairo_surface_t *flattened;
flattened = cairo_image_surface_create (cairo_image_surface_get_format (surface),
width,
height);
cr = cairo_create (flattened);
cairo_surface_destroy (flattened);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_set_source_surface (cr, surface,
width - cairo_image_surface_get_width (surface),
height - cairo_image_surface_get_height (surface));
cairo_paint (cr);
cairo_surface_destroy (surface);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
} else if (cairo_image_surface_get_width (surface) != width ||
cairo_image_surface_get_height (surface) != height)
{
cairo_t *cr;
cairo_surface_t *sub;
sub = cairo_image_surface_create (cairo_image_surface_get_format (surface),
width,
height);
cr = cairo_create (sub);
cairo_surface_destroy (sub);
cairo_set_source_surface (cr, surface,
width - cairo_image_surface_get_width (surface),
height - cairo_image_surface_get_height (surface));
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_surface_destroy (surface);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
}
return surface;
}
char* handle_icon(GdkPixbuf* icon, gboolean use_board)
{
int left_offset = 0;
int top_offset = 0;
if (_board== NULL) {
_board = cairo_image_surface_create_from_png(BOARD_PATH);
_board_mask = cairo_image_surface_create_from_png(BOARD_MASK_PATH);
}
g_assert(_board_mask != NULL);
cairo_surface_t* surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
BOARD_WIDTH,
BOARD_HEIGHT);
cairo_t* cr = cairo_create(surface);
if (use_board) {
double r, g, b;
calc_dominant_color_by_pixbuf(icon, &r, &g, &b);
cairo_set_source_rgb(cr, r, g, b);
cairo_mask_surface(cr, _board_mask, 0, BOARD_OFFSET);
/*cairo_paint(cr);*/
left_offset = (IMG_WIDTH - gdk_pixbuf_get_width(icon)) / 2;
top_offset = (IMG_HEIGHT - gdk_pixbuf_get_height(icon)) / 2;
gdk_cairo_set_source_pixbuf(cr, icon, MARGIN_LEFT + left_offset,
MARGIN_TOP-1 + top_offset);
} else {
gdk_cairo_set_source_pixbuf(cr, icon, left_offset, top_offset);
}
cairo_paint(cr);
if (use_board) {
cairo_set_source_surface(cr, _board, 0, BOARD_OFFSET);
cairo_paint(cr);
}
char* data = get_data_uri_by_surface(surface);
cairo_surface_destroy(surface);
cairo_destroy(cr);
return data;
}
static void init_vars() {
glob.image = cairo_image_surface_create_from_png("sample.png");
glob.img_width = cairo_image_surface_get_width(glob.image);
glob.img_height = cairo_image_surface_get_height(glob.image);
glob.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, glob.img_width, glob.img_height);
glob.timer = TRUE;
}
void Button_t::setPNG(std::string path, Point position)
{
pathToLoad = true;
pngPosition = position;
png = cairo_image_surface_create_from_png(path.c_str());
markFor(COMPONENT_REQUIREMENT_PAINT);
}
int
main (int argc, char **argv)
{
if (argc < 3) {
printf ("You must specify two PNG image files to compare\n");
return 1;
}
cairo_surface_t* a =
cairo_image_surface_create_from_png (argv[1]);
cairo_surface_t* b =
cairo_image_surface_create_from_png (argv[2]);
double dist = ti_objective (a, b);
printf("Distance: %e\n", dist);
return 0;
}
/*static*/
HBITMAP Win32UIBinding::LoadPNGAsBitmap(std::string& path, int sizeX, int sizeY)
{
std::string systemPath(UTF8ToSystem(path));
cairo_surface_t* pngSurface =
cairo_image_surface_create_from_png(systemPath.c_str());
cairo_t* pngcr = cairo_create(pngSurface);
if (cairo_status(pngcr) != CAIRO_STATUS_SUCCESS)
return 0;
BITMAPINFO bitmapInfo;
memset(&bitmapInfo, 0, sizeof(bitmapInfo));
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = sizeX;
bitmapInfo.bmiHeader.biHeight = -sizeY; // Bottom-up
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
bitmapInfo.bmiHeader.biSizeImage = 0;
bitmapInfo.bmiHeader.biXPelsPerMeter = 1000;
bitmapInfo.bmiHeader.biYPelsPerMeter = bitmapInfo.bmiHeader.biXPelsPerMeter;
bitmapInfo.bmiHeader.biClrUsed = 0;
bitmapInfo.bmiHeader.biClrImportant = 0;
void* pixels = NULL;
HDC hdc = ::GetDC(NULL);
HBITMAP out = CreateDIBSection(hdc, &bitmapInfo,
DIB_RGB_COLORS, &pixels, NULL, 0);
::ReleaseDC(NULL, hdc);
BITMAP info;
::GetObjectW(out, sizeof(info), &info);
cairo_surface_t* outSurface = cairo_image_surface_create_for_data(
(unsigned char*) pixels, CAIRO_FORMAT_ARGB32,
sizeX, sizeY, info.bmWidthBytes);
cairo_surface_t* scaledSurface = ScaleCairoSurface(pngSurface, sizeX, sizeY);
cairo_t *cr = cairo_create(outSurface);
cairo_save(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_restore(cr);
cairo_set_source_surface(cr, scaledSurface, 0, 0);
cairo_rectangle(cr, 0, 0, sizeX, sizeY);
cairo_fill(cr);
cairo_destroy(cr);
cairo_surface_destroy(outSurface);
cairo_surface_destroy(scaledSurface);
cairo_destroy(pngcr);
cairo_surface_destroy(pngSurface);
return out;
}
cairo_surface_t* getImage(string path)
{
auto it = images.find(path);
if (it != images.end())
return (*it).second;
cairo_surface_t* image = cairo_image_surface_create_from_png(path.c_str());
images.insert(std::make_pair(path, image));
return image;
}
Button::Button(Display* display, Window parent, XContext context, BrowserControl* control, WKRect size, ButtonType type)
: VisualComponent(display, control, size)
, m_type(type)
{
createXWindow(parent, context);
m_surface = cairo_xlib_surface_create(display, m_window, DefaultVisual(display, 0), m_size.size.width, m_size.size.height);
m_image = cairo_image_surface_create_from_png(imagePath(type));
m_cairo = cairo_create(m_surface);
}
