BLF_api.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2009 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLF_enums.hh"
 
#include "BLI_array.hh"
#include "BLI_bounds_types.hh"
#include "BLI_compiler_attrs.h"
#include "BLI_function_ref.hh"
#include "BLI_string_ref.hh"
#include "BLI_sys_types.h"
#include "BLI_vector.hh"

#define BLF_DATAFILES_FONTS_DIR "fonts"

#define BLF_DEFAULT_PROPORTIONAL_FONT "Inter.woff2"

#define BLF_DEFAULT_MONOSPACED_FONT "DejaVuSansMono.woff2"
 
struct ListBase;
struct ResultBLF;
struct rcti;
struct rctf;
 
namespace blender::ocio {
class ColorSpace;
}  // namespace blender::ocio
using ColorSpace = blender::ocio::ColorSpace;
 
int BLF_init();
void BLF_exit();

void BLF_reset_fonts();
 
void BLF_cache_clear();

void BLF_cache_flush_set_fn(void (*cache_flush_fn)());

int BLF_load(const char *filepath) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1);
int BLF_load_mem(const char *name, const unsigned char *mem, int mem_size) ATTR_WARN_UNUSED_RESULT
    ATTR_NONNULL(1, 2);
 
bool BLF_is_loaded(const char *filepath) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1);
bool BLF_is_loaded_mem(const char *name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1);
bool BLF_is_loaded_id(int fontid) ATTR_WARN_UNUSED_RESULT;

int BLF_load_unique(const char *filepath) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1);
int BLF_load_mem_unique(const char *name, const unsigned char *mem, int mem_size)
    ATTR_NONNULL(1, 2);

void BLF_unload(const char *filepath) ATTR_NONNULL(1);
#if 0 /* Not needed at the moment. */
void BLF_unload_mem(const char *name) ATTR_NONNULL(1);
#endif

bool BLF_unload_id(int fontid);
 
void BLF_unload_all();

void BLF_addref_id(int fontid);
 
char *BLF_display_name_from_file(const char *filepath) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1);
 
char *BLF_display_name_from_id(int fontid);

bool BLF_get_vfont_metrics(int fontid, float *ascend_ratio, float *em_ratio, float *scale);
 
#define BLF_VFONT_METRICS_SCALE_DEFAULT float(1.0 / 1000.0)
#define BLF_VFONT_METRICS_EM_RATIO_DEFAULT 1.0f
#define BLF_VFONT_METRICS_ASCEND_RATIO_DEFAULT 0.8f

bool BLF_character_to_curves(int fontid,
                             unsigned int unicode,
                             ListBase *nurbsbase,
                             const float scale,
                             bool use_fallback,
                             float *r_advance);

bool BLF_has_glyph(int fontid, unsigned int unicode) ATTR_WARN_UNUSED_RESULT;

void BLF_metrics_attach(int fontid, const unsigned char *mem, int mem_size) ATTR_NONNULL(2);
 
void BLF_aspect(int fontid, float x, float y, float z);
void BLF_position(int fontid, float x, float y, float z);
void BLF_size(int fontid, float size);

void BLF_character_weight(int fontid, int weight);

int BLF_default_weight(int fontid) ATTR_WARN_UNUSED_RESULT;

bool BLF_has_variable_weight(int fontid) ATTR_WARN_UNUSED_RESULT;
 
/* Goal: small but useful color API. */
 
void BLF_color4ubv(int fontid, const unsigned char rgba[4]);
void BLF_color3ubv(int fontid, const unsigned char rgb[3]);
void BLF_color3ubv_alpha(int fontid, const unsigned char rgb[3], unsigned char alpha);
void BLF_color4ub(
    int fontid, unsigned char r, unsigned char g, unsigned char b, unsigned char alpha);
void BLF_color3ub(int fontid, unsigned char r, unsigned char g, unsigned char b);
void BLF_color4f(int fontid, float r, float g, float b, float a);
void BLF_color4fv(int fontid, const float rgba[4]);
void BLF_color3f(int fontid, float r, float g, float b);
void BLF_color3fv_alpha(int fontid, const float rgb[3], float alpha);
/* Also available: `UI_FontThemeColor(fontid, colorid)`. */

void BLF_batch_draw_begin();
void BLF_batch_draw_flush();
void BLF_batch_draw_end();
 
/* Discard any batching in process and restart.
 * Only used as a workaround for glitchy driver sync. */
void BLF_batch_discard();

void BLF_draw(int fontid, const char *str, size_t str_len, ResultBLF *r_info = nullptr)
    ATTR_NONNULL(2);
int BLF_draw_mono(int fontid, const char *str, size_t str_len, int cwidth, int tab_columns)
    ATTR_NONNULL(2);
 
void BLF_draw_svg_icon(uint icon_id,
                       float x,
                       float y,
                       float size,
                       const float color[4] = nullptr,
                       float outline_alpha = 1.0f,
                       bool multicolor = false,
                       blender::FunctionRef<void(std::string &)> edit_source_cb = nullptr);
 
blender::Array<uchar> BLF_svg_icon_bitmap(
    uint icon_id,
    float size,
    int *r_width,
    int *r_height,
    bool multicolor = false,
    blender::FunctionRef<void(std::string &)> edit_source_cb = nullptr);
 
using BLF_GlyphBoundsFn = bool (*)(const char *str,
                                   size_t str_step_ofs,
                                   const rcti *bounds,
                                   void *user_dataconst);

void BLF_boundbox_foreach_glyph(int fontid,
                                const char *str,
                                size_t str_len,
                                BLF_GlyphBoundsFn user_fn,
                                void *user_data) ATTR_NONNULL(2);

size_t BLF_str_offset_from_cursor_position(int fontid,
                                           const char *str,
                                           size_t str_len,
                                           int location_x) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);

bool BLF_str_offset_to_glyph_bounds(int fontid,
                                    const char *str,
                                    size_t str_offset,
                                    rcti *r_glyph_bounds) ATTR_WARN_UNUSED_RESULT
    ATTR_NONNULL(2, 4);

int BLF_str_offset_to_cursor(
    int fontid, const char *str, size_t str_len, size_t str_offset, int cursor_width);

blender::Vector<blender::Bounds<int>> BLF_str_selection_boxes(
    int fontid, const char *str, size_t str_len, size_t sel_start, size_t sel_length);

size_t BLF_width_to_strlen(int fontid,
                           const char *str,
                           size_t str_len,
                           float width,
                           float *r_width) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);
size_t BLF_width_to_rstrlen(int fontid,
                            const char *str,
                            size_t str_len,
                            float width,
                            float *r_width) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);

void BLF_boundbox(int fontid,
                  const char *str,
                  size_t str_len,
                  rcti *r_box,
                  ResultBLF *r_info = nullptr) ATTR_NONNULL(2);

float BLF_width(int fontid, const char *str, size_t str_len, ResultBLF *r_info = nullptr)
    ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);
float BLF_height(int fontid, const char *str, size_t str_len, ResultBLF *r_info = nullptr)
    ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);

int BLF_height_max(int fontid) ATTR_WARN_UNUSED_RESULT;
int BLF_width_max(int fontid) ATTR_WARN_UNUSED_RESULT;
int BLF_descender(int fontid) ATTR_WARN_UNUSED_RESULT;
int BLF_ascender(int fontid) ATTR_WARN_UNUSED_RESULT;

bool BLF_bounds_max(int fontid, rctf *r_bounds) ATTR_NONNULL(2);

void BLF_width_and_height(
    int fontid, const char *str, size_t str_len, float *r_width, float *r_height) ATTR_NONNULL();

float BLF_fixed_width(int fontid) ATTR_WARN_UNUSED_RESULT;

int BLF_glyph_advance(int fontid, const char *str);

void BLF_rotation(int fontid, float angle);
void BLF_clipping(int fontid, int xmin, int ymin, int xmax, int ymax);
void BLF_wordwrap(int fontid, int wrap_width, BLFWrapMode mode = BLFWrapMode::Minimal);
 
blender::Vector<blender::StringRef> BLF_string_wrap(int fontid,
                                                    blender::StringRef str,
                                                    const int max_pixel_width,
                                                    BLFWrapMode mode = BLFWrapMode::Minimal);
 
void BLF_enable(int fontid, FontFlags flag);
void BLF_disable(int fontid, FontFlags flag);

bool BLF_is_builtin(int fontid);

void BLF_shadow(int fontid, FontShadowType type, const float rgba[4] = nullptr);

void BLF_shadow_offset(int fontid, int x, int y);

void BLF_buffer(
    int fontid, float *fbuf, unsigned char *cbuf, int w, int h, const ColorSpace *colorspace);

struct BLFBufferState;
BLFBufferState *BLF_buffer_state_push(int fontid);
void BLF_buffer_state_pop(BLFBufferState *buffer_state);
void BLF_buffer_state_free(BLFBufferState *buffer_state);

void BLF_buffer_col(int fontid, const float srgb_color[4]) ATTR_NONNULL(2);

void BLF_draw_buffer(int fontid, const char *str, size_t str_len, ResultBLF *r_info = nullptr)
    ATTR_NONNULL(2);
 
/* `blf_thumbs.cc` */

bool BLF_thumb_preview(const char *filepath, unsigned char *buf, int w, int h, int channels)
    ATTR_NONNULL();
 
/* `blf_default.cc` */
 
void BLF_default_size(float size);
void BLF_default_set(int fontid);
int BLF_default();
void BLF_draw_default(float x, float y, float z, const char *str, size_t str_len) ATTR_NONNULL();
int BLF_set_default();
 
/* `blf_font_default.cc` */
 
int BLF_load_default(bool unique);
int BLF_load_mono_default(bool unique);
void BLF_load_font_stack();
 
#ifndef NDEBUG
void BLF_state_print(int fontid);
#endif
 
#define BLF_DRAW_STR_DUMMY_MAX 1024
 
/* XXX, bad design */
extern int blf_mono_font;
extern int blf_mono_font_render; /* don't mess drawing with render threads. */

struct ResultBLF {
  int lines;
  int width;
};