path.h

Go to the documentation of this file.

// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_PATH_H
#define MUPDF_FITZ_PATH_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"

 
typedef struct fz_path fz_path;
 
typedef enum
{
    FZ_LINECAP_BUTT = 0,
    FZ_LINECAP_ROUND = 1,
    FZ_LINECAP_SQUARE = 2,
    FZ_LINECAP_TRIANGLE = 3
} fz_linecap;
 
typedef enum
{
    FZ_LINEJOIN_MITER = 0,
    FZ_LINEJOIN_ROUND = 1,
    FZ_LINEJOIN_BEVEL = 2,
    FZ_LINEJOIN_MITER_XPS = 3
} fz_linejoin;
 
typedef struct
{
    int refs;
    fz_linecap start_cap, dash_cap, end_cap;
    fz_linejoin linejoin;
    float linewidth;
    float miterlimit;
    float dash_phase;
    int dash_len;
    float dash_list[FZ_FLEXIBLE_ARRAY];
} fz_stroke_state;
 
typedef struct
{
    /* Compulsory ones */
    void (*moveto)(fz_context *ctx, void *arg, float x, float y);
    void (*lineto)(fz_context *ctx, void *arg, float x, float y);
    void (*curveto)(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2, float x3, float y3);
    void (*closepath)(fz_context *ctx, void *arg);
    /* Optional ones */
    void (*quadto)(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2);
    void (*curvetov)(fz_context *ctx, void *arg, float x2, float y2, float x3, float y3);
    void (*curvetoy)(fz_context *ctx, void *arg, float x1, float y1, float x3, float y3);
    void (*rectto)(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2);
} fz_path_walker;

void fz_walk_path(fz_context *ctx, const fz_path *path, const fz_path_walker *walker, void *arg);

fz_path *fz_new_path(fz_context *ctx);

fz_path *fz_keep_path(fz_context *ctx, const fz_path *path);

void fz_drop_path(fz_context *ctx, const fz_path *path);

void fz_trim_path(fz_context *ctx, fz_path *path);

int fz_packed_path_size(const fz_path *path);

size_t fz_pack_path(fz_context *ctx, uint8_t *pack, const fz_path *path);

fz_path *fz_clone_path(fz_context *ctx, fz_path *path);

int fz_path_is_empty(fz_context *ctx, const fz_path *path);

fz_point fz_currentpoint(fz_context *ctx, fz_path *path);

void fz_moveto(fz_context *ctx, fz_path *path, float x, float y);

void fz_lineto(fz_context *ctx, fz_path *path, float x, float y);

void fz_rectto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1);

void fz_quadto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1);

void fz_curveto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1, float x2, float y2);

void fz_curvetov(fz_context *ctx, fz_path *path, float x1, float y1, float x2, float y2);

void fz_curvetoy(fz_context *ctx, fz_path *path, float x0, float y0, float x2, float y2);

void fz_closepath(fz_context *ctx, fz_path *path);

void fz_transform_path(fz_context *ctx, fz_path *path, fz_matrix transform);

fz_rect fz_bound_path(fz_context *ctx, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm);

fz_rect fz_adjust_rect_for_stroke(fz_context *ctx, fz_rect rect, const fz_stroke_state *stroke, fz_matrix ctm);

FZ_DATA extern const fz_stroke_state fz_default_stroke_state;

fz_stroke_state *fz_new_stroke_state(fz_context *ctx);

fz_stroke_state *fz_new_stroke_state_with_dash_len(fz_context *ctx, int len);

fz_stroke_state *fz_keep_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);
int fz_stroke_state_eq(fz_context *ctx, const fz_stroke_state *a, const fz_stroke_state *b);

void fz_drop_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);

fz_stroke_state *fz_unshare_stroke_state(fz_context *ctx, fz_stroke_state *shared);

fz_stroke_state *fz_unshare_stroke_state_with_dash_len(fz_context *ctx, fz_stroke_state *shared, int len);

fz_stroke_state *fz_clone_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);
 
fz_linecap fz_linecap_from_string(const char *s);
const char *fz_string_from_linecap(fz_linecap cap);
fz_linejoin fz_linejoin_from_string(const char *s);
const char *fz_string_from_linejoin(fz_linejoin join);

int fz_path_is_rect(fz_context *ctx, const fz_path *path, fz_matrix ctm);

int fz_path_is_rect_with_bounds(fz_context *ctx, const fz_path *path, fz_matrix ctm, fz_rect *bounds);

int fz_path_is_closed(fz_context *ctx, const fz_path *path);
 
 
#endif