355 lines
12 KiB
C
355 lines
12 KiB
C
/*
|
|
* This file is part of NetSurf, http://netsurf.sourceforge.net/
|
|
* Licensed under the GNU General Public License,
|
|
* http://www.opensource.org/licenses/gpl-license
|
|
* Copyright 2005 James Bursa <bursa@users.sourceforge.net>
|
|
* Copyright 2003 Philip Pemberton <philpem@users.sourceforge.net>
|
|
*/
|
|
|
|
/** \file
|
|
* Content handling (interface).
|
|
*
|
|
* The content functions manipulate struct contents, which correspond to URLs.
|
|
*
|
|
* Each content has a type. The type is used to call a specific implementation
|
|
* of functions such as content_process_data().
|
|
*
|
|
* The source data fetched from the URL is placed in the source_data buffer as
|
|
* it arrives.
|
|
*
|
|
* Contents have an associated set of users, which are informed by a callback
|
|
* when the state of the content changes or something interesting happens.
|
|
*
|
|
* Depending on the type of content, there may be either one content structure
|
|
* per URL which is shared among all users, or one per URL per user. For
|
|
* example, CONTENT_JPEGs are shared, while there is one CONTENT_HTML per user
|
|
* (because each instance of an HTML page may have different parameters such as
|
|
* window width). This is controlled by no_share in ::handler_map.
|
|
*
|
|
* The status of a content follows a fixed order. Certain content functions
|
|
* change the state, and each change of state results in a message to all users
|
|
* of the content. The diagram below shows this:
|
|
* \dot
|
|
* digraph status {
|
|
* node [shape=plaintext, fontname=Helvetica, fontsize=9];
|
|
* edge [fontname=Helvetica, fontsize=9];
|
|
*
|
|
* content_create -> TYPE_UNKNOWN [style=bold];
|
|
* TYPE_UNKNOWN -> content_set_type [style=bold];
|
|
* content_set_type -> LOADING [label=MSG_LOADING, style=bold];
|
|
* content_set_type -> LOADING [label="MSG_NEWPTR\nMSG_LOADING"];
|
|
* content_set_type -> ERROR [label=MSG_ERROR];
|
|
* LOADING -> content_process_data [style=bold];
|
|
* content_process_data -> LOADING [style=bold];
|
|
* content_process_data -> ERROR [label=MSG_ERROR];
|
|
* LOADING -> content_convert [style=bold];
|
|
* content_convert -> READY [label=MSG_READY, style=bold];
|
|
* content_convert -> DONE [label="MSG_READY\nMSG_DONE", style=bold];
|
|
* content_convert -> ERROR [label=MSG_ERROR];
|
|
* READY -> READY [style=bold];
|
|
* READY -> DONE [label=MSG_DONE, style=bold];
|
|
* READY -> content_stop;
|
|
* content_stop -> DONE [label=MSG_DONE];
|
|
*
|
|
* TYPE_UNKNOWN [shape=ellipse];
|
|
* LOADING [shape=ellipse];
|
|
* READY [shape=ellipse];
|
|
* DONE [shape=ellipse];
|
|
* ERROR [shape=ellipse];
|
|
* }
|
|
* \enddot
|
|
*
|
|
* To implement a new content type, implement the following functions:
|
|
*
|
|
* - <i>type</i>_create(): called to initialise type-specific fields in the
|
|
* content structure. Optional.
|
|
*
|
|
* - <i>type</i>_process_data(): called when some data arrives. Optional.
|
|
*
|
|
* - <i>type</i>_convert(): called when data has finished arriving. The
|
|
* content needs to be converted for display. Must set the status to one of
|
|
* CONTENT_STATUS_READY or CONTENT_STATUS_DONE if no error occurs. Optional,
|
|
* but probably required for non-trivial types.
|
|
*
|
|
* - <i>type</i>_reformat(): called when, for example, the window has been
|
|
* resized, and the content needs reformatting for the new size. Optional.
|
|
*
|
|
* - <i>type</i>_destroy(): called when the content is being destroyed. Free all
|
|
* resources. Optional.
|
|
*
|
|
* - <i>type</i>_redraw(): called to plot the content to screen.
|
|
*
|
|
* - <i>type</i>_stop(): called when the user interrupts in status
|
|
* CONTENT_STATUS_READY. Must stop any processing and set the status to
|
|
* CONTENT_STATUS_DONE. Required iff the status can be CONTENT_STATUS_READY.
|
|
*
|
|
* - <i>type</i>_open(): called when a window containing the content is
|
|
* opened. Probably only makes sense if no_share is set for the content type
|
|
* in handler_map. Optional.
|
|
*
|
|
* - <i>type</i>_close(): called when the window containing the content is
|
|
* closed. Optional.
|
|
*
|
|
* - <i>type</i>_create(), <i>type</i>_process_data(), <i>type</i>_convert():
|
|
* if an error occurs, must broadcast CONTENT_MSG_ERROR and return false.
|
|
* Optionally use warn_user() for serious errors. The _destroy function will
|
|
* be called soon after.
|
|
*
|
|
* Each content structure is allocated using talloc, and all data related to a
|
|
* content should be allocated as a child block of the content structure using
|
|
* talloc. This will ensure that all memory used by a page is freed.
|
|
*/
|
|
|
|
#ifndef _NETSURF_DESKTOP_CONTENT_H_
|
|
#define _NETSURF_DESKTOP_CONTENT_H_
|
|
|
|
#include <stdint.h>
|
|
#include "netsurf/utils/config.h"
|
|
#include "netsurf/content/content_type.h"
|
|
#include "netsurf/css/css.h"
|
|
#include "netsurf/render/html.h"
|
|
#include "netsurf/render/textplain.h"
|
|
#ifdef WITH_JPEG
|
|
#include "netsurf/image/jpeg.h"
|
|
#endif
|
|
#ifdef WITH_GIF
|
|
#include "netsurf/image/gif.h"
|
|
#endif
|
|
#ifdef WITH_BMP
|
|
#include "netsurf/image/bmp.h"
|
|
#include "netsurf/image/ico.h"
|
|
#endif
|
|
#ifdef WITH_PLUGIN
|
|
#include "netsurf/riscos/plugin.h"
|
|
#endif
|
|
#ifdef WITH_MNG
|
|
#include "netsurf/image/mng.h"
|
|
#endif
|
|
#ifdef WITH_SPRITE
|
|
#include "netsurf/riscos/sprite.h"
|
|
#endif
|
|
#ifdef WITH_DRAW
|
|
#include "netsurf/riscos/draw.h"
|
|
#endif
|
|
#ifdef WITH_ARTWORKS
|
|
#include "netsurf/riscos/artworks.h"
|
|
#endif
|
|
|
|
|
|
struct bitmap;
|
|
struct box;
|
|
struct browser_window;
|
|
struct cache_data;
|
|
struct content;
|
|
struct fetch;
|
|
struct object_params;
|
|
struct ssl_cert_info;
|
|
|
|
|
|
/** Used in callbacks to indicate what has occurred. */
|
|
typedef enum {
|
|
CONTENT_MSG_LOADING, /**< fetching or converting */
|
|
CONTENT_MSG_READY, /**< may be displayed */
|
|
CONTENT_MSG_DONE, /**< finished */
|
|
CONTENT_MSG_ERROR, /**< error occurred */
|
|
CONTENT_MSG_STATUS, /**< new status string */
|
|
CONTENT_MSG_REDIRECT, /**< replacement URL */
|
|
CONTENT_MSG_REFORMAT, /**< content_reformat done */
|
|
CONTENT_MSG_REDRAW, /**< needs redraw (eg. new animation frame) */
|
|
CONTENT_MSG_NEWPTR, /**< address of structure has changed */
|
|
CONTENT_MSG_REFRESH, /**< wants refresh */
|
|
#ifdef WITH_AUTH
|
|
CONTENT_MSG_AUTH, /**< authentication required */
|
|
#endif
|
|
#ifdef WITH_SSL
|
|
CONTENT_MSG_SSL /**< SSL cert verify failed */
|
|
#endif
|
|
} content_msg;
|
|
|
|
/** Extra data for some content_msg messages. */
|
|
union content_msg_data {
|
|
const char *error; /**< Error message, for CONTENT_MSG_ERROR. */
|
|
char *redirect; /**< Redirect URL, for CONTENT_MSG_REDIRECT. */
|
|
/** Area of content which needs redrawing, for CONTENT_MSG_REDRAW. */
|
|
struct {
|
|
float x, y, width, height;
|
|
/** Redraw the area fully. If false, object must be set,
|
|
* and only the object will be redrawn. */
|
|
bool full_redraw;
|
|
/** Object to redraw if full_redraw is false. */
|
|
struct content *object;
|
|
/** Coordinates to plot object at. */
|
|
float object_x, object_y;
|
|
/** Dimensions to plot object with. */
|
|
float object_width, object_height;
|
|
} redraw;
|
|
const char *auth_realm; /**< Realm, for CONTENT_MSG_AUTH. */
|
|
int delay; /**< Minimum delay, for CONTENT_MSG_REFRESH */
|
|
struct {
|
|
/** Certificate chain (certs[0] == server) */
|
|
const struct ssl_cert_info *certs;
|
|
unsigned long num; /**< Number of certs in chain */
|
|
} ssl;
|
|
};
|
|
|
|
/** Linked list of users of a content. */
|
|
struct content_user
|
|
{
|
|
void (*callback)(content_msg msg, struct content *c, intptr_t p1,
|
|
intptr_t p2, union content_msg_data data);
|
|
intptr_t p1;
|
|
intptr_t p2;
|
|
bool stop;
|
|
struct content_user *next;
|
|
};
|
|
|
|
/** Corresponds to a single URL. */
|
|
struct content {
|
|
char *url; /**< URL, in standard form as from url_join. */
|
|
content_type type; /**< Type of content. */
|
|
char *mime_type; /**< Original MIME type of data, or 0. */
|
|
|
|
enum {
|
|
CONTENT_STATUS_TYPE_UNKNOWN, /**< Type not yet known. */
|
|
CONTENT_STATUS_LOADING, /**< Content is being fetched or
|
|
converted and is not safe to display. */
|
|
CONTENT_STATUS_READY, /**< Some parts of content still being
|
|
loaded, but can be displayed. */
|
|
CONTENT_STATUS_DONE, /**< All finished. */
|
|
CONTENT_STATUS_ERROR /**< Error occurred, content will be
|
|
destroyed imminently. */
|
|
} status; /**< Current status. */
|
|
|
|
int width, height; /**< Dimensions, if applicable. */
|
|
int available_width; /**< Available width (eg window width). */
|
|
|
|
/** Data dependent on type. */
|
|
union {
|
|
struct content_html_data html;
|
|
struct content_textplain_data textplain;
|
|
struct content_css_data css;
|
|
#ifdef WITH_JPEG
|
|
struct content_jpeg_data jpeg;
|
|
#endif
|
|
#ifdef WITH_GIF
|
|
struct content_gif_data gif;
|
|
#endif
|
|
#ifdef WITH_BMP
|
|
struct content_bmp_data bmp;
|
|
struct content_ico_data ico;
|
|
#endif
|
|
#ifdef WITH_MNG
|
|
struct content_mng_data mng;
|
|
#endif
|
|
#ifdef WITH_SPRITE
|
|
struct content_sprite_data sprite;
|
|
#endif
|
|
#ifdef WITH_DRAW
|
|
struct content_draw_data draw;
|
|
#endif
|
|
#ifdef WITH_PLUGIN
|
|
struct content_plugin_data plugin;
|
|
#endif
|
|
#ifdef WITH_ARTWORKS
|
|
struct content_artworks_data artworks;
|
|
#endif
|
|
} data;
|
|
|
|
/**< URL for refresh request, in standard form as from url_join. */
|
|
char *refresh;
|
|
|
|
/** Bitmap, for various image contents. */
|
|
struct bitmap *bitmap;
|
|
|
|
/** This content may be given to new users. Indicates that the content
|
|
* was fetched using a simple GET, has not expired, and may be
|
|
* shared between users. */
|
|
bool fresh;
|
|
struct cache_data *cache_data; /**< Cache control data */
|
|
|
|
unsigned int size; /**< Estimated size of all data
|
|
associated with this content. */
|
|
char *title; /**< Title for browser window. */
|
|
unsigned int active; /**< Number of child fetches or
|
|
conversions currently in progress. */
|
|
struct content_user *user_list; /**< List of users. */
|
|
char status_message[80]; /**< Text for status bar. */
|
|
/** Content is being processed: data structures may be inconsistent
|
|
* and content must not be redrawn or modified. */
|
|
bool locked;
|
|
|
|
struct fetch *fetch; /**< Associated fetch, or 0. */
|
|
char *source_data; /**< Source data, as received. */
|
|
unsigned long source_size; /**< Amount of data fetched so far. */
|
|
unsigned long source_allocated; /**< Amount of space allocated so far. */
|
|
unsigned long total_size; /**< Total data size, 0 if unknown. */
|
|
|
|
bool no_error_pages; /**< Used by fetchcache(). */
|
|
bool download; /**< Used by fetchcache(). */
|
|
|
|
/** Array of first n rendering errors or warnings. */
|
|
struct {
|
|
const char *token;
|
|
unsigned int line; /**< Line no, 0 if not applicable. */
|
|
} error_list[40];
|
|
unsigned int error_count; /**< Number of valid error entries. */
|
|
|
|
struct content *prev; /**< Previous in global content list. */
|
|
struct content *next; /**< Next in global content list. */
|
|
};
|
|
|
|
extern struct content *content_list;
|
|
extern const char *content_type_name[];
|
|
extern const char *content_status_name[];
|
|
|
|
|
|
content_type content_lookup(const char *mime_type);
|
|
struct content * content_create(const char *url);
|
|
struct content * content_get(const char *url);
|
|
struct content * content_get_ready(const char *url);
|
|
bool content_set_type(struct content *c, content_type type,
|
|
const char *mime_type, const char *params[]);
|
|
void content_set_status(struct content *c, const char *status_message, ...);
|
|
bool content_process_data(struct content *c, const char *data,
|
|
unsigned int size);
|
|
void content_convert(struct content *c, int width, int height);
|
|
void content_reformat(struct content *c, int width, int height);
|
|
void content_clean(void);
|
|
void content_reset(struct content *c);
|
|
void content_quit(void);
|
|
bool content_redraw(struct content *c, int x, int y,
|
|
int width, int height,
|
|
int clip_x0, int clip_y0, int clip_x1, int clip_y1,
|
|
float scale, unsigned long background_colour);
|
|
bool content_redraw_tiled(struct content *c, int x, int y,
|
|
int width, int height,
|
|
int clip_x0, int clip_y0, int clip_x1, int clip_y1,
|
|
float scale, unsigned long background_colour,
|
|
bool repeat_x, bool repeat_y);
|
|
bool content_add_user(struct content *c,
|
|
void (*callback)(content_msg msg, struct content *c,
|
|
intptr_t p1, intptr_t p2, union content_msg_data data),
|
|
intptr_t p1, intptr_t p2);
|
|
struct content_user * content_find_user(struct content *c,
|
|
void (*callback)(content_msg msg, struct content *c,
|
|
intptr_t p1, intptr_t p2, union content_msg_data data),
|
|
intptr_t p1, intptr_t p2);
|
|
void content_remove_user(struct content *c,
|
|
void (*callback)(content_msg msg, struct content *c,
|
|
intptr_t p1, intptr_t p2, union content_msg_data data),
|
|
intptr_t p1, intptr_t p2);
|
|
void content_broadcast(struct content *c, content_msg msg,
|
|
union content_msg_data data);
|
|
void content_stop(struct content *c,
|
|
void (*callback)(content_msg msg, struct content *c,
|
|
intptr_t p1, intptr_t p2, union content_msg_data data),
|
|
intptr_t p1, intptr_t p2);
|
|
void content_open(struct content *c, struct browser_window *bw,
|
|
struct content *page, unsigned int index, struct box *box,
|
|
struct object_params *params);
|
|
void content_close(struct content *c);
|
|
void content_add_error(struct content *c, const char *token,
|
|
unsigned int line);
|
|
|
|
#endif
|