kate.h

Go to the documentation of this file.

/* Copyright (C) 2008, 2009 Vincent Penquerc'h.
   This file is part of the Kate codec library.
   Written by Vincent Penquerc'h.
 
   Use, distribution and reproduction of this library is governed
   by a BSD style source license included with this source in the
   file 'COPYING'. Please read these terms before distributing. */
 
 
#ifndef KATE_kate_h_GUARD
#define KATE_kate_h_GUARD
 
#include "kate/kate_config.h"
 
#define KATE_VERSION_MAJOR 0             
#define KATE_VERSION_MINOR 4             
#define KATE_VERSION_PATCH 3             
#define KATE_BITSTREAM_VERSION_MAJOR 0   
#define KATE_BITSTREAM_VERSION_MINOR 7   
typedef enum {
  kate_utf8                      
} kate_text_encoding;
 
typedef enum {
  kate_markup_none,              
  kate_markup_simple             
} kate_markup_type;
 
typedef enum {
  kate_pixel,                    
  kate_percentage,               
  kate_millionths                
} kate_space_metric;
 
struct kate_meta;
typedef struct kate_meta kate_meta;
 
typedef struct kate_region {
  kate_space_metric metric;      
  int x;                         
  int y;                         
  int w;                         
  int h;                         
  int style;                     
  unsigned int clip:1;           
  unsigned int pad0:31;
  kate_meta *meta;
  kate_uintptr_t pad1[5];
} kate_region;
 
typedef struct kate_color {
  unsigned char r;               
  unsigned char g;               
  unsigned char b;               
  unsigned char a;               
} kate_color;
 
typedef enum {
  kate_wrap_word,                
  kate_wrap_none                 
} kate_wrap_mode;
 
typedef struct kate_style {
  kate_float halign;                 
  kate_float valign;                 
  kate_color text_color;             
  kate_color background_color;       
  kate_color draw_color;             
  kate_space_metric font_metric;     
  kate_float font_width;             
  kate_float font_height;            
  kate_space_metric margin_metric;   
  kate_float left_margin;            
  kate_float top_margin;             
  kate_float right_margin;           
  kate_float bottom_margin;          
  unsigned int bold:1;               
  unsigned int italics:1;            
  unsigned int underline:1;          
  unsigned int strike:1;             
  unsigned int justify:1;            
  unsigned int wrap_mode:2;          
  unsigned int pad0:25;
 
  kate_const char *font;             
  kate_meta *meta;
 
  kate_uintptr_t pad1[8];
} kate_style;
 
typedef enum kate_curve_type {
  kate_curve_none,                   
  kate_curve_static,                 
  kate_curve_linear,                 
  kate_curve_catmull_rom_spline,     
  kate_curve_bezier_cubic_spline,    
  kate_curve_bspline                 
} kate_curve_type;
 
typedef struct kate_curve {
  kate_curve_type type;              
  size_t npts;                       
  kate_float *pts;                   
  kate_uintptr_t pad[5];
} kate_curve;
 
typedef enum kate_motion_mapping {
  /* these can be used for a x/y position mapping */
  kate_motion_mapping_none,                  
  kate_motion_mapping_frame,                 
  kate_motion_mapping_window,                
  kate_motion_mapping_region,                
  kate_motion_mapping_event_duration,        
  kate_motion_mapping_bitmap_size,           
#if 0
  text is useful, find a way to readd it easily
  kate_motion_mapping_text,                  
#endif
 
  /* more mapping may be added in future versions */
 
  kate_motion_mapping_user=128               
} kate_motion_mapping;
 
typedef enum kate_motion_semantics {
  kate_motion_semantics_time,                    
  kate_motion_semantics_z,                       
  kate_motion_semantics_region_position,         
  kate_motion_semantics_region_size,             
  kate_motion_semantics_text_alignment_int,      
  kate_motion_semantics_text_alignment_ext,      
  kate_motion_semantics_text_position,           
  kate_motion_semantics_text_size,               
  kate_motion_semantics_marker1_position,        
  kate_motion_semantics_marker2_position,        
  kate_motion_semantics_marker3_position,        
  kate_motion_semantics_marker4_position,        
  kate_motion_semantics_glyph_pointer_1,         
  kate_motion_semantics_glyph_pointer_2,         
  kate_motion_semantics_glyph_pointer_3,         
  kate_motion_semantics_glyph_pointer_4,         
  kate_motion_semantics_text_color_rg,           
  kate_motion_semantics_text_color_ba,           
  kate_motion_semantics_background_color_rg,     
  kate_motion_semantics_background_color_ba,     
  kate_motion_semantics_draw_color_rg,           
  kate_motion_semantics_draw_color_ba,           
  kate_motion_semantics_style_morph,             
  kate_motion_semantics_text_path,               
  kate_motion_semantics_text_path_section,       
  kate_motion_semantics_draw,                    
  kate_motion_semantics_text_visible_section,    
  kate_motion_semantics_horizontal_margins,      
  kate_motion_semantics_vertical_margins,        
  kate_motion_semantics_bitmap_position,         
  kate_motion_semantics_bitmap_size,             
  kate_motion_semantics_marker1_bitmap,          
  kate_motion_semantics_marker2_bitmap,          
  kate_motion_semantics_marker3_bitmap,          
  kate_motion_semantics_marker4_bitmap,          
  kate_motion_semantics_glyph_pointer_1_bitmap,  
  kate_motion_semantics_glyph_pointer_2_bitmap,  
  kate_motion_semantics_glyph_pointer_3_bitmap,  
  kate_motion_semantics_glyph_pointer_4_bitmap,  
  kate_motion_semantics_draw_width,              
  /* more semantics may be added in future versions */
 
  kate_motion_semantics_user = 128               
} kate_motion_semantics;
 
typedef struct kate_motion {
  size_t ncurves;                                
  kate_curve **curves;                           
  kate_float *durations;                         
  kate_motion_mapping x_mapping;                 
  kate_motion_mapping y_mapping;                 
  kate_motion_semantics semantics;               
  unsigned int periodic:1;                       
  unsigned int pad0:31;
  kate_meta *meta;
  kate_uintptr_t pad1[4];
} kate_motion;
 
typedef enum kate_text_directionality {
  kate_l2r_t2b,                                  
  kate_r2l_t2b,                                  
  kate_t2b_r2l,                                  
  kate_t2b_l2r                                   
} kate_text_directionality;
 
typedef struct kate_palette {
  size_t ncolors;                                
  kate_color *colors;                            
  kate_meta *meta;
  kate_uintptr_t pad[1];
} kate_palette;
 
typedef enum kate_bitmap_type {
  kate_bitmap_type_paletted,                     
  kate_bitmap_type_png                           
} kate_bitmap_type;
 
typedef struct kate_bitmap {
  size_t width;                                  
  size_t height;                                 
  unsigned char bpp;                             
  kate_bitmap_type type;                         
  unsigned char pad0[1];
  unsigned char internal;
  int palette;                                   
  unsigned char *pixels;                         
  size_t size;                                   
  int x_offset;                                  
  int y_offset;                                  
  kate_meta *meta;
  kate_uintptr_t pad1[14];
} kate_bitmap;
 
typedef struct kate_font_range {
  int first_code_point;                          
  int last_code_point;                           
  int first_bitmap;                              
  kate_uintptr_t pad[5];
} kate_font_range;
 
typedef struct kate_font_mapping {
  size_t nranges;                                
  kate_font_range **ranges;                      
  kate_uintptr_t pad[6];
} kate_font_mapping;
 
typedef struct kate_info {
  unsigned char bitstream_version_major;         
  unsigned char bitstream_version_minor;         
  unsigned char pad0[2];
 
  kate_text_encoding text_encoding;              
  kate_text_directionality text_directionality;  
  unsigned char num_headers;                     
  unsigned char granule_shift;                   
  unsigned char pad1[2];
 
  kate_uint32_t gps_numerator;                   
  kate_uint32_t gps_denominator;                 
  kate_const char *language;                     
  kate_const char *category;                     
  size_t nregions;                               
  kate_const kate_region *kate_const *regions;   
  size_t nstyles;                                
  kate_const kate_style *kate_const *styles;     
  size_t ncurves;                                
  kate_const kate_curve *kate_const *curves;     
  size_t nmotions;                               
  kate_const kate_motion *kate_const *motions;   
  size_t npalettes;                              
  kate_const kate_palette *kate_const *palettes; 
  size_t nbitmaps;                               
  kate_const kate_bitmap *kate_const *bitmaps;   
  size_t nfont_ranges;                                       
  kate_const kate_font_range *kate_const *font_ranges;       
  size_t nfont_mappings;                                     
  kate_const kate_font_mapping *kate_const *font_mappings;   
  kate_markup_type text_markup_type;             
  size_t original_canvas_width;                  
  size_t original_canvas_height;                 
  kate_uintptr_t pad2[11];
 
  /* internal */
  int remove_markup;
  int no_limits;
  int probe;
 
  kate_uintptr_t pad3[13];
} kate_info;
 
struct kate_encode_state; /* internal */
struct kate_decode_state; /* internal */
 
typedef struct kate_state {
  kate_const kate_info *ki;                      
  /* internal */
  kate_const struct kate_encode_state *kes;
  kate_const struct kate_decode_state *kds;
 
  kate_uintptr_t pad[5];
} kate_state;
 
typedef struct kate_comment {
  char **user_comments;                         
  int *comment_lengths;                         
  int comments;                                 
  char *vendor;                                 
} kate_comment;
 
typedef struct kate_event {
  kate_int64_t start;                           
  kate_int64_t duration;                        
  kate_int64_t backlink;                        
  kate_float start_time;                        
  kate_float end_time;                          
  kate_int32_t id;                              
  kate_text_encoding text_encoding;             
  kate_text_directionality text_directionality; 
  kate_const char *language;                    
  kate_const char *text;                        
  size_t len;                                   
  size_t len0;                                  
  size_t nmotions;                              
  kate_const kate_motion *kate_const *motions;  
  kate_const kate_region *region;               
  kate_const kate_style *style;                 
  kate_const kate_style *secondary_style;       
  kate_const kate_font_mapping *font_mapping;   
  kate_const kate_palette *palette;             
  kate_const kate_bitmap *bitmap;               
  kate_markup_type text_markup_type;            
  size_t nbitmaps;                              
  kate_const kate_bitmap *kate_const *bitmaps;  
  kate_meta *meta;
 
  kate_uintptr_t pad0[5];
 
  /* internal */
  const kate_info *ki;
  size_t trackers;
 
  kate_uintptr_t pad1[10];
} kate_event;
 
struct kate_tracker_internal; /* internal */
 
typedef struct kate_tracker {
  const kate_info *ki;                          
  kate_const kate_event *event;                 
  kate_float t;                                 
  struct {
    unsigned int region:1;                      
    unsigned int text_alignment_int:1;          
    unsigned int text_alignment_ext:1;          
    unsigned int text_pos:1;                    
    unsigned int text_size:1;                   
    unsigned int marker_pos:4;                  
    unsigned int text_color:1;                  
    unsigned int background_color:1;            
    unsigned int draw_color:1;                  
    unsigned int glyph_pointer:4;               
    unsigned int path:1;                        
    unsigned int draw:1;                        
    unsigned int visible_section:1;             
    unsigned int z:1;                           
    unsigned int hmargins:1;                    
    unsigned int vmargins:1;                    
    unsigned int bitmap_pos:1;                  
    unsigned int bitmap_size:1;                 
    unsigned int marker_bitmap:4;               
    unsigned int glyph_pointer_bitmap:4;        
    unsigned int draw_width:1;                  
    /* 33 bits */
    unsigned int pad0:31;
    /* 64 bits */
  } has;                                        
  int window_w;                                 
  int window_h;                                 
  int frame_x;                                  
  int frame_y;                                  
  int frame_w;                                  
  int frame_h;                                  
  /* has.region */
  kate_float region_x;                          
  kate_float region_y;                          
  kate_float region_w;                          
  kate_float region_h;                          
  /* has.text_alignment (int/ext) */
  kate_float text_halign;                       
  kate_float text_valign;                       
  /* has.text_pos */
  kate_float text_x;                            
  kate_float text_y;                            
  /* has.text_size */
  kate_float text_size_x;                       
  kate_float text_size_y;                       
  /* has.marker_pos&(1<<n) */
  kate_float marker_x[4];                       
  kate_float marker_y[4];                       
  /* has.text_color */
  kate_color text_color;                        
  /* has.background_color */
  kate_color background_color;                  
  /* has.draw_color */
  kate_color draw_color;                        
  /* has.glyph_pointer&(1<<n) */
  kate_float glyph_pointer[4];                  
  kate_float glyph_height[4];                   
  /* has.path */
  kate_float path_start;                        
  kate_float path_end;                          
  /* has.draw */
  kate_float draw_x;                            
  kate_float draw_y;                            
  /* has.visible_section */
  kate_float visible_x;                         
  kate_float visible_y;                         
  /* has.z */
  kate_float z;                                 
  /* has.hmargins */
  kate_float left_margin;                       
  kate_float right_margin;                      
  /* has.vmargins */
  kate_float top_margin;                        
  kate_float bottom_margin;                     
  /* has.bitmap_pos */
  kate_float bitmap_x;                          
  kate_float bitmap_y;                          
  /* has.bitmap_size */
  kate_float bitmap_size_x;                     
  kate_float bitmap_size_y;                     
  /* has.marker_bitmap&(1<<n) */
  const kate_bitmap *marker_bitmap[4];          
  /* has.glyph_pointer_bitmap&(1<<n) */
  const kate_bitmap *glyph_pointer_bitmap[4];   
  /* has.draw_width */
  kate_float draw_width;                        
  /* internal */
  struct kate_tracker_internal *internal;
 
  kate_uintptr_t pad[19];
 
} kate_tracker;
 
typedef struct kate_packet {
  size_t nbytes;             
  void *data;                
} kate_packet;
 
#ifdef __cplusplus
extern "C" {
#endif
 
extern int kate_get_version(void);
extern const char *kate_get_version_string(void);
extern int kate_get_bitstream_version(void);
extern const char *kate_get_bitstream_version_string(void);
 
extern int kate_info_init(kate_info *ki);
extern int kate_info_set_granule_encoding(kate_info *ki,kate_float resolution,kate_float max_length,kate_float max_event_lifetime);
extern int kate_info_set_language(kate_info *ki,const char *language);
extern int kate_info_set_text_directionality(kate_info *ki,kate_text_directionality text_directionality);
extern int kate_info_set_markup_type(kate_info *ki,kate_markup_type text_markup_type);
extern int kate_info_set_category(kate_info *ki,const char *category);
extern int kate_info_set_original_canvas_size(kate_info *ki,size_t width,size_t height);
extern int kate_info_add_region(kate_info *ki,kate_region *kr);
extern int kate_info_add_style(kate_info *ki,kate_style *ks);
extern int kate_info_add_curve(kate_info *ki,kate_curve *kc);
extern int kate_info_add_motion(kate_info *ki,kate_motion *km);
extern int kate_info_add_palette(kate_info *ki,kate_palette *kp);
extern int kate_info_add_bitmap(kate_info *ki,kate_bitmap *kb);
extern int kate_info_add_font_range(kate_info *ki,kate_font_range *kfr);
extern int kate_info_add_font_mapping(kate_info *ki,kate_font_mapping *kfm);
extern int kate_info_matches_language(const kate_info *ki,const char *language);
extern int kate_info_remove_markup(kate_info *ki,int flag);
extern int kate_info_no_limits(kate_info *ki,int flag);
extern int kate_info_clear(kate_info *ki);
 
extern int kate_granule_shift(const kate_info *ki);
extern int kate_granule_split_time(const kate_info *ki,kate_int64_t granulepos,kate_float *base,kate_float *offset);
extern kate_float kate_granule_time(const kate_info *ki,kate_int64_t granulepos);
extern kate_int64_t kate_duration_granule(const kate_info *ki,kate_float duration);
extern kate_float kate_granule_duration(const kate_info *ki,kate_int64_t duration);
 
extern int kate_clear(kate_state *k);
extern int kate_motion_get_point(const kate_motion *km,kate_float duration,kate_float t,kate_float *x,kate_float *y);
extern int kate_curve_get_point(const kate_curve *kc,kate_float t,kate_float *x,kate_float *y);
extern int kate_region_init(kate_region *kr);
extern int kate_style_init(kate_style *ks);
extern int kate_palette_init(kate_palette *kp);
extern int kate_bitmap_init(kate_bitmap *kb);
extern int kate_bitmap_init_new(kate_bitmap *kb);
extern int kate_curve_init(kate_curve *kc);
extern int kate_motion_init(kate_motion *km);
 
extern int kate_text_get_character(kate_text_encoding text_encoding,const char ** const text,size_t *len0);
extern int kate_text_set_character(kate_text_encoding text_encoding,int c,char ** const text,size_t *len0);
extern int kate_text_remove_markup(kate_text_encoding text_encoding,char *text,size_t *len0);
extern int kate_text_validate(kate_text_encoding text_encoding,const char *text,size_t len0);
 
extern int kate_comment_init(kate_comment *kc);
extern int kate_comment_clear(kate_comment *kc);
extern int kate_comment_add(kate_comment *kc,const char *comment);
extern int kate_comment_add_length(kate_comment *kc,const char *comment,size_t len);
extern int kate_comment_add_tag(kate_comment *kc,const char *tag,const char *value);
extern const char *kate_comment_query(const kate_comment *kc,const char *tag,int count);
extern int kate_comment_query_count(const kate_comment *kc,const char *tag);
 
extern int kate_encode_init(kate_state *k,kate_info *ki);
extern int kate_encode_headers(kate_state *k,kate_comment *kc,kate_packet *kp);
extern int kate_encode_text(kate_state *k,kate_float start_time,kate_float stop_time,const char *text,size_t sz,kate_packet *kp); /* text is not null terminated */
extern int kate_encode_text_raw_times(kate_state *k,kate_int64_t start_time,kate_int64_t stop_time,const char *text,size_t sz,kate_packet *kp); /* text is not null terminated */
extern int kate_encode_keepalive(kate_state *k,kate_float t,kate_packet *kp);
extern int kate_encode_keepalive_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp);
extern int kate_encode_repeat(kate_state *k,kate_float t,kate_float threshold,kate_packet *kp);
extern int kate_encode_repeat_raw_times(kate_state *k,kate_int64_t t,kate_int64_t threshold,kate_packet *kp);
extern int kate_encode_finish(kate_state *k,kate_float t,kate_packet *kp); /* t may be negative to use the end granule of the last event */
extern int kate_encode_finish_raw_times(kate_state *k,kate_int64_t t,kate_packet *kp); /* t may be negative to use the end granule of the last event */
extern int kate_encode_set_id(kate_state *k,kate_int32_t id);
extern int kate_encode_set_language(kate_state *k,const char *language); /* language can be NULL */
extern int kate_encode_set_text_encoding(kate_state *k,kate_text_encoding text_encoding);
extern int kate_encode_set_text_directionality(kate_state *k,kate_text_directionality text_directionality);
extern int kate_encode_set_region_index(kate_state *k,size_t region);
extern int kate_encode_set_region(kate_state *k,const kate_region *kr);
extern int kate_encode_set_style_index(kate_state *k,size_t style);
extern int kate_encode_set_style(kate_state *k,const kate_style *ks);
extern int kate_encode_set_secondary_style_index(kate_state *k,size_t style);
extern int kate_encode_set_secondary_style(kate_state *k,const kate_style *ks);
extern int kate_encode_set_font_mapping_index(kate_state *k,size_t font_mapping);
extern int kate_encode_add_motion(kate_state *k,kate_motion *km,int destroy);
extern int kate_encode_add_motion_index(kate_state *k,size_t motion);
extern int kate_encode_set_palette_index(kate_state *k,size_t palette);
extern int kate_encode_set_palette(kate_state *k,const kate_palette *kp);
extern int kate_encode_set_bitmap_index(kate_state *k,size_t bitmap);
extern int kate_encode_set_bitmap(kate_state *k,const kate_bitmap *kb);
extern int kate_encode_add_bitmap(kate_state *k,const kate_bitmap *kb);
extern int kate_encode_add_bitmap_index(kate_state *k,size_t bitmap);
extern int kate_encode_set_markup_type(kate_state *k,int markup_type);
extern int kate_encode_merge_meta(kate_state *k,kate_meta *meta);
extern int kate_encode_add_meta(kate_state *k,const kate_meta *meta);
extern kate_int64_t kate_encode_get_granule(const kate_state *k);
 
extern int kate_decode_is_idheader(const kate_packet *kp);
extern int kate_decode_init(kate_state *k,kate_info *ki);
extern int kate_decode_headerin(kate_info *ki,kate_comment *kc,kate_packet *kp);
extern int kate_decode_packetin(kate_state *k,kate_packet *kp);
extern int kate_decode_eventout(kate_state *k,kate_const kate_event **ev); /* event can be NULL */
extern int kate_decode_seek(kate_state *k);
 
extern int kate_tracker_init(kate_tracker *kin,const kate_info *ki,kate_const kate_event *ev);
extern int kate_tracker_clear(kate_tracker *kin);
extern int kate_tracker_update(kate_tracker *kin,kate_float t,int window_w,int window_h,int frame_x,int frame_y,int frame_w,int frame_h);
extern int kate_tracker_morph_styles(kate_style *style,kate_float t,const kate_style *from,const kate_style *to);
extern int kate_tracker_get_text_path_position(kate_tracker *kin,size_t glyph,int *x,int *y);
extern int kate_tracker_update_property_at_duration(const kate_tracker *kin,kate_float duration,kate_float t,kate_motion_semantics semantics,kate_float *x,kate_float *y);
extern int kate_tracker_remap(const kate_tracker *kin,kate_motion_mapping x_mapping,kate_motion_mapping y_mapping,kate_float *x,kate_float *y);
 
extern int kate_font_get_index_from_code_point(const kate_font_mapping *kfm,int c);
 
extern int kate_high_decode_init(kate_state *k);
extern int kate_high_decode_packetin(kate_state *k,kate_packet *kp,kate_const kate_event **ev);
extern int kate_high_decode_clear(kate_state *k);
extern const kate_comment *kate_high_decode_get_comments(kate_state *k);
 
extern int kate_packet_wrap(kate_packet *kp,size_t nbytes,const void *data);
extern int kate_packet_init(kate_packet *kp,size_t nbytes,const void *data);
extern int kate_packet_clear(kate_packet *kp);
 
extern int kate_meta_create(kate_meta **km);
extern int kate_meta_destroy(kate_meta *km);
extern int kate_meta_add(kate_meta *km,const char *tag,const char *value,size_t len);
extern int kate_meta_add_string(kate_meta *km,const char *tag,const char *value);
extern int kate_meta_query_tag_count(const kate_meta *km,const char *tag);
extern int kate_meta_query_tag(const kate_meta *km,const char *tag,unsigned int idx,const char **value,size_t *len);
extern int kate_meta_remove_tag(kate_meta *km,const char *tag,unsigned int idx);
extern int kate_meta_query_count(const kate_meta *km);
extern int kate_meta_query(const kate_meta *km,unsigned int idx,const char **tag,const char **value,size_t *len);
extern int kate_meta_remove(kate_meta *km,unsigned int idx);
extern int kate_meta_merge(kate_meta *km,kate_meta *km2);
 
#ifdef __cplusplus
}
#endif
 
#define KATE_E_NOT_FOUND (-1)            
#define KATE_E_INVALID_PARAMETER (-2)    
#define KATE_E_OUT_OF_MEMORY (-3)        
#define KATE_E_BAD_GRANULE (-4)          
#define KATE_E_INIT (-5)                 
#define KATE_E_BAD_PACKET (-6)           
#define KATE_E_TEXT (-7)                 
#define KATE_E_LIMIT (-8)                
#define KATE_E_VERSION (-9)              
#define KATE_E_NOT_KATE (-10)            
#define KATE_E_BAD_TAG (-11)             
#define KATE_E_IMPL (-12)                
#endif