markmental/evil-qemacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

moved input_methods to QEmacsState

Browse source 
qe_register_binding takes ModeDef* and returns status
cosmetic changes in QEDisplay API
added int dpy_init(QEditScreen *s, QEDisplay *dpy, int w, int h);
  copies *dpy (or dummy_dpy if NULL) to QEditScreen and calls method
simplified dpy_init methods and calls
inlined 5 more methods
moved dummy_dpy to display.c and simplified
simplified to_hex
simplified qe_colors array handling
This commit is contained in:
Charlie Gordon 2008-01-11 11:29:28 +00:00
commit 28397f424f
14 changed files with 256 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

147
display.c
View file

@ -22,6 +22,101 @@
static QEDisplay *first_dpy;
/* dummy display driver for initialization time */
static int dummy_dpy_init(QEditScreen *s, __unused__ int w, __unused__ int h)
{
s->charset = &charset_8859_1;
return 0;
}
static void dummy_dpy_close(__unused__ QEditScreen *s)
{
}
static void dummy_dpy_flush(__unused__ QEditScreen *s)
{
}
static int dummy_dpy_is_user_input_pending(__unused__ QEditScreen *s)
{
return 0;
}
static void dummy_dpy_fill_rectangle(__unused__ QEditScreen *s,
__unused__ int x1, __unused__ int y1,
__unused__ int w, __unused__ int h,
__unused__ QEColor color)
{
}
static QEFont *dummy_dpy_open_font(__unused__ QEditScreen *s,
__unused__ int style, __unused__ int size)
{
return NULL;
}
static void dummy_dpy_close_font(__unused__ QEditScreen *s,
__unused__ QEFont *font)
{
}
static void dummy_dpy_text_metrics(__unused__ QEditScreen *s,
__unused__ QEFont *font,
QECharMetrics *metrics,
__unused__ const unsigned int *str,
__unused__ int len)
{
metrics->font_ascent = 1;
metrics->font_descent = 0;
metrics->width = len;
}
static void dummy_dpy_draw_text(__unused__ QEditScreen *s,
__unused__ QEFont *font,
__unused__ int x, __unused__ int y,
__unused__ const unsigned int *str,
__unused__ int len,
__unused__ QEColor color)
{
}
static void dummy_dpy_set_clip(__unused__ QEditScreen *s,
__unused__ int x, __unused__ int y,
__unused__ int w, __unused__ int h)
{
}
static QEDisplay const dummy_dpy = {
"dummy",
NULL,
dummy_dpy_init,
dummy_dpy_close,
dummy_dpy_flush,
dummy_dpy_is_user_input_pending,
dummy_dpy_fill_rectangle,
dummy_dpy_open_font,
dummy_dpy_close_font,
dummy_dpy_text_metrics,
dummy_dpy_draw_text,
dummy_dpy_set_clip,
NULL, /* dpy_selection_activate */
NULL, /* dpy_selection_request */
NULL, /* dpy_invalidate */
NULL, /* dpy_cursor_at */
NULL, /* dpy_bmp_alloc */
NULL, /* dpy_bmp_free */
NULL, /* dpy_bmp_draw */
NULL, /* dpy_bmp_lock */
NULL, /* dpy_bmp_unlock */
NULL, /* dpy_full_screen */
NULL, /* next */
};
/*----------------*/
void fill_rectangle(QEditScreen *s,
int x1, int y1, int w, int h, QEColor color)
{
@ -113,12 +208,12 @@ void push_clip_rectangle(QEditScreen *s, CSSRect *or, CSSRect *r)
int qe_register_display(QEDisplay *dpy)
{
QEDisplay **p;
QEDisplay **pp;
p = &first_dpy;
while (*p != NULL)
p = &(*p)->next;
*p = dpy;
pp = &first_dpy;
while (*pp != NULL)
pp = &(*pp)->next;
*pp = dpy;
dpy->next = NULL;
return 0;
}
@ -132,8 +227,7 @@ QEDisplay *probe_display(void)
dpy = NULL;
probe_max = 0;
while (p != NULL) {
// CG: probe = p->dpy_probe ? p->dpy_probe() : 0;
probe = p->dpy_probe();
probe = p->dpy_probe ? p->dpy_probe() : 0;
if (probe >= probe_max) {
probe_max = probe;
dpy = p;
@ -143,6 +237,12 @@ QEDisplay *probe_display(void)
return dpy;
}
int dpy_init(QEditScreen *s, QEDisplay *dpy, int w, int h)
{
s->dpy = dpy ? *dpy : dummy_dpy;
return s->dpy.dpy_init(s, w, h);
}
/* simple font cache */
#define FONT_CACHE_SIZE 32
@ -205,18 +305,6 @@ QEFont *select_font(QEditScreen *s, int style, int size)
return fc;
}
void selection_activate(QEditScreen *s)
{
if (s->dpy.dpy_selection_activate)
s->dpy.dpy_selection_activate(s);
}
void selection_request(QEditScreen *s)
{
if (s->dpy.dpy_selection_request)
s->dpy.dpy_selection_request(s);
}
QEBitmap *bmp_alloc(QEditScreen *s, int width, int height, int flags)
{
QEBitmap *b;
@ -244,27 +332,6 @@ void bmp_free(QEditScreen *s, QEBitmap **bp)
}
}
void bmp_draw(QEditScreen *s, QEBitmap *b,
int dst_x, int dst_y, int dst_w, int dst_h,
int offset_x, int offset_y, int flags)
{
s->dpy.dpy_bmp_draw(s, b, dst_x, dst_y, dst_w, dst_h,
offset_x, offset_y, flags);
}
/* used to access the bitmap data. Return the necessary pointers to
modify the image in 'pict'. */
void bmp_lock(QEditScreen *s, QEBitmap *bitmap, QEPicture *pict,
int x1, int y1, int w1, int h1)
{
s->dpy.dpy_bmp_lock(s, bitmap, pict, x1, y1, w1, h1);
}
void bmp_unlock(QEditScreen *s, QEBitmap *bitmap)
{
s->dpy.dpy_bmp_unlock(s, bitmap);
}
#if 0
/* bitmap cache */
typedef struct QECachedBitmap {

98
display.h
View file

@ -106,7 +106,6 @@ struct QEDisplay {
int (*dpy_probe)(void);
int (*dpy_init)(QEditScreen *s, int w, int h);
void (*dpy_close)(QEditScreen *s);
void (*dpy_cursor_at)(QEditScreen *s, int x1, int y1, int w, int h);
void (*dpy_flush)(QEditScreen *s);
int (*dpy_is_user_input_pending)(QEditScreen *s);
void (*dpy_fill_rectangle)(QEditScreen *s,
@ -121,9 +120,13 @@ struct QEDisplay {
QEColor color);
void (*dpy_set_clip)(QEditScreen *s,
int x, int y, int w, int h);
/* These are optional, may be NULL */
void (*dpy_selection_activate)(QEditScreen *s);
void (*dpy_selection_request)(QEditScreen *s);
void (*dpy_invalidate)(void);
void (*dpy_invalidate)(QEditScreen *s);
void (*dpy_cursor_at)(QEditScreen *s, int x1, int y1, int w, int h);
/* bitmap support */
int (*dpy_bmp_alloc)(QEditScreen *s, QEBitmap *b);
void (*dpy_bmp_free)(QEditScreen *s, QEBitmap *b);
@ -139,7 +142,7 @@ struct QEDisplay {
};
struct QEditScreen {
struct QEDisplay dpy;
QEDisplay dpy;
FILE *STDIN, *STDOUT;
int width, height;
QECharset *charset; /* the charset of the TTY, XXX: suppress that,
@ -153,11 +156,19 @@ struct QEditScreen {
void *private;
};
static inline void draw_text(QEditScreen *s, QEFont *font,
int x, int y, const unsigned int *str, int len,
QEColor color)
int qe_register_display(QEDisplay *dpy);
QEDisplay *probe_display(void);
int dpy_init(QEditScreen *s, QEDisplay *dpy, int w, int h);
static inline void dpy_close(QEditScreen *s)
{
s->dpy.dpy_draw_text(s, font, x, y, str, len, color);
s->dpy.dpy_close(s);
}
static inline void dpy_flush(QEditScreen *s)
{
s->dpy.dpy_flush(s);
}
static inline QEFont *open_font(QEditScreen *s,
@ -179,6 +190,55 @@ static inline void text_metrics(QEditScreen *s, QEFont *font,
s->dpy.dpy_text_metrics(s, font, metrics, str, len);
}
static inline void draw_text(QEditScreen *s, QEFont *font,
int x, int y, const unsigned int *str, int len,
QEColor color)
{
s->dpy.dpy_draw_text(s, font, x, y, str, len, color);
}
static inline void selection_activate(QEditScreen *s)
{
if (s->dpy.dpy_selection_activate)
s->dpy.dpy_selection_activate(s);
}
static inline void selection_request(QEditScreen *s)
{
if (s->dpy.dpy_selection_request)
s->dpy.dpy_selection_request(s);
}
static inline void dpy_invalidate(QEditScreen *s)
{
if (s->dpy.dpy_invalidate)
s->dpy.dpy_invalidate(s);
}
QEBitmap *bmp_alloc(QEditScreen *s, int width, int height, int flags);
void bmp_free(QEditScreen *s, QEBitmap **bp);
static inline void bmp_draw(QEditScreen *s, QEBitmap *b,
int dst_x, int dst_y, int dst_w, int dst_h,
int offset_x, int offset_y, int flags)
{
s->dpy.dpy_bmp_draw(s, b, dst_x, dst_y, dst_w, dst_h,
offset_x, offset_y, flags);
}
/* used to access the bitmap data. Return the necessary pointers to
modify the image in 'pict'. */
static inline void bmp_lock(QEditScreen *s, QEBitmap *bitmap, QEPicture *pict,
int x1, int y1, int w1, int h1)
{
s->dpy.dpy_bmp_lock(s, bitmap, pict, x1, y1, w1, h1);
}
static inline void bmp_unlock(QEditScreen *s, QEBitmap *bitmap)
{
s->dpy.dpy_bmp_unlock(s, bitmap);
}
/* XXX: only needed for backward compatibility */
static inline int glyph_width(QEditScreen *s, QEFont *font, int ch)
{
@ -189,23 +249,11 @@ static inline int glyph_width(QEditScreen *s, QEFont *font, int ch)
return metrics.width;
}
static inline void dpy_flush(QEditScreen *s)
{
s->dpy.dpy_flush(s);
}
static inline void dpy_close(QEditScreen *s)
{
s->dpy.dpy_close(s);
}
void fill_rectangle(QEditScreen *s,
int x1, int y1, int w, int h, QEColor color);
void set_clip_rectangle(QEditScreen *s, CSSRect *r);
void push_clip_rectangle(QEditScreen *s, CSSRect *or, CSSRect *r);
int qe_register_display(QEDisplay *dpy);
QEDisplay *probe_display(void);
QEFont *select_font(QEditScreen *s, int style, int size);
static inline QEFont *lock_font(__unused__ QEditScreen *s, QEFont *font) {
@ -218,16 +266,4 @@ static inline void release_font(__unused__ QEditScreen *s, QEFont *font) {
font->refcount--;
}
void selection_activate(QEditScreen *s);
void selection_request(QEditScreen *s);
QEBitmap *bmp_alloc(QEditScreen *s, int width, int height, int flags);
void bmp_free(QEditScreen *s, QEBitmap **bp);
void bmp_draw(QEditScreen *s, QEBitmap *b,
int dst_x, int dst_y, int dst_w, int dst_h,
int offset_x, int offset_y, int flags);
void bmp_lock(QEditScreen *s, QEBitmap *bitmap, QEPicture *pict,
int x1, int y1, int w1, int h1);
void bmp_unlock(QEditScreen *s, QEBitmap *bitmap);
#endif

4
hex.c
View file

@ -367,8 +367,8 @@ static int hex_init(void)
qe_register_cmd_table(hex_commands, &ascii_mode);
/* additional mode specific keys */
qe_register_binding(KEY_TAB, "toggle-hex", "hex");
qe_register_binding(KEY_SHIFT_TAB, "toggle-hex", "hex");
qe_register_binding(KEY_TAB, "toggle-hex", &hex_mode);
qe_register_binding(KEY_SHIFT_TAB, "toggle-hex", &hex_mode);
return 0;
}

10
html2png.c
View file

@ -111,7 +111,6 @@ static QEDisplay ppm_dpy = {
NULL,
ppm_init,
ppm_close,
NULL, /* dpy_cursor_at */
NULL, /* dpy_flush */
NULL, /* dpy_is_user_input_pending */
NULL, /* dpy_fill_rectangle */
@ -123,6 +122,7 @@ static QEDisplay ppm_dpy = {
NULL, /* dpy_selection_activate */
NULL, /* dpy_selection_request */
NULL, /* dpy_invalidate */
NULL, /* dpy_cursor_at */
NULL, /* dpy_bmp_alloc */
NULL, /* dpy_bmp_free */
NULL, /* dpy_bmp_draw */
@ -156,8 +156,6 @@ static int ppm_init(QEditScreen *s, int w, int h)
{
CFBContext *cfb;
memcpy(&s->dpy, &ppm_dpy, sizeof(QEDisplay));
cfb = qe_malloc(CFBContext);
if (!cfb)
return -1;
@ -430,7 +428,6 @@ static void help(void)
int main(int argc, char **argv)
{
QEDisplay *dpy;
QEditScreen screen1, *screen = &screen1;
int page_width, c, strict_xml, flags;
const char *outfilename, *infilename;
@ -485,8 +482,7 @@ int main(int argc, char **argv)
infilename = argv[optind];
/* init display driver with dummy height */
dpy = &ppm_dpy;
if (dpy->dpy_init(screen, page_width, 1) < 0) {
if (dpy_init(screen, &ppm_dpy, page_width, 1) < 0) {
fprintf(stderr, "Could not init display driver\n");
exit(1);
}
@ -508,6 +504,6 @@ int main(int argc, char **argv)
#endif
/* close screen */
screen->dpy.dpy_close(screen);
dpy_close(screen);
return 0;
}

2
image.c
View file

@ -855,7 +855,7 @@ static int image_init(void)
qe_register_cmd_table(image_commands, &image_mode);
register_completion("pixel_format", pixel_format_completion);
/* additional mode specific keys */
qe_register_binding('f', "toggle-full-screen", "image");
qe_register_binding('f', "toggle-full-screen", &image_mode);
return 0;
}

17
input.c
View file

@ -24,8 +24,6 @@
#include <sys/mman.h>
#endif
static InputMethod *input_methods;
static int default_input(__unused__ int *match_buf,
__unused__ int match_buf_size,
__unused__ int *match_len_ptr,
@ -74,9 +72,10 @@ static InputMethod unicode_input_method = {
void register_input_method(InputMethod *m)
{
QEmacsState *qs = &qe_state;
InputMethod **p;
p = &input_methods;
p = &qs->input_methods;
while (*p != NULL) {
p = &(*p)->next;
}
@ -86,18 +85,20 @@ void register_input_method(InputMethod *m)
static void input_completion(CompleteState *cp)
{
QEmacsState *qs = cp->s->qe_state;
InputMethod *m;
for (m = input_methods; m != NULL; m = m->next) {
for (m = qs->input_methods; m != NULL; m = m->next) {
complete_test(cp, m->name);
}
}
static InputMethod *find_input_method(const char *name)
{
QEmacsState *qs = &qe_state;
InputMethod *m;
for (m = input_methods; m != NULL; m = m->next) {
for (m = qs->input_methods; m != NULL; m = m->next) {
if (strequal(m->name, name))
return m;
}
@ -118,10 +119,10 @@ void do_set_input_method(EditState *s, const char *name)
void do_switch_input_method(EditState *s)
{
if (!s->input_method)
s->input_method = s->selected_input_method;
else
if (s->input_method)
s->input_method = NULL;
else
s->input_method = s->selected_input_method;
}
void init_input_methods(void)

187
qe.c
View file

@ -61,7 +61,6 @@ static void display1(DisplayState *s);
static void save_selection(void);
#endif
static CompletionFunc find_completion(const char *name);
static int dummy_dpy_init(QEditScreen *s, int w, int h);
QEmacsState qe_state;
/* should handle multiple screens, and multiple sessions */
@ -166,6 +165,9 @@ static int qe_register_binding1(unsigned int *keys, int nb_keys,
KeyDef **lp, *p;
int i;
if (!d)
return -1;
/* add key */
p = qe_malloc_hack(KeyDef, (nb_keys - 1) * sizeof(p->keys[0]));
if (!p)
@ -190,7 +192,7 @@ static int qe_register_binding1(unsigned int *keys, int nb_keys,
}
/* convert compressed mappings to real ones */
static void qe_register_binding2(int key, CmdDef *d, ModeDef *m)
static int qe_register_binding2(int key, CmdDef *d, ModeDef *m)
{
int nb_keys;
unsigned int keys[3];
@ -209,7 +211,7 @@ static void qe_register_binding2(int key, CmdDef *d, ModeDef *m)
} else {
keys[nb_keys++] = key;
}
qe_register_binding1(keys, nb_keys, d, m);
return qe_register_binding1(keys, nb_keys, d, m);
}
#if 0
@ -278,36 +280,9 @@ void qe_register_cmd_table(CmdDef *cmds, ModeDef *m)
/* key binding handling */
void qe_register_binding(int key, const char *cmd_name, const char *mode_names)
int qe_register_binding(int key, const char *cmd_name, ModeDef *m)
{
CmdDef *d;
ModeDef *m;
const char *p, *r;
char mode_name[64];
d = qe_find_cmd(cmd_name);
if (!d)
return;
if (!mode_names || mode_names[0] == '\0') {
qe_register_binding2(key, d, NULL);
} else {
p = mode_names;
for (;;) {
r = strchr(p, '|');
if (r) {
pstrncpy(mode_name, sizeof(mode_name), p, r - p);
} else {
pstrcpy(mode_name, sizeof(mode_name), p);
}
m = find_mode(mode_name);
if (m) {
qe_register_binding2(key, d, m);
}
if (!r)
break;
p = r + 1;
}
}
return qe_register_binding2(key, qe_find_cmd(cmd_name), m);
}
void command_completion(CompleteState *cp)
@ -2123,6 +2098,9 @@ void display_window_borders(EditState *e)
}
}
#if 1
/* Should move all this to display.c */
/* compute style */
static void apply_style(QEStyleDef *style, int style_index)
{
@ -2173,8 +2151,8 @@ void style_completion(CompleteState *cp)
int i;
QEStyleDef *style;
for (i = 0; i < QE_STYLE_NB; i++) {
style = &qe_styles[i];
style = qe_styles;
for (i = 0; i < QE_STYLE_NB; i++, style++) {
complete_test(cp, style->name);
}
}
@ -2184,20 +2162,14 @@ QEStyleDef *find_style(const char *name)
int i;
QEStyleDef *style;
for (i = 0; i < QE_STYLE_NB; i++) {
style = &qe_styles[i];
style = qe_styles;
for (i = 0; i < QE_STYLE_NB; i++, style++) {
if (strequal(style->name, name))
return style;
}
return NULL;
}
void do_define_color(EditState *e, const char *name, const char *value)
{
if (css_define_color(name, value))
put_status(e, "Invalid color '%s'", value);
}
/* Note: we use the same syntax as CSS styles to ease merging */
void do_set_style(EditState *e, const char *stylestr,
const char *propstr, const char *value)
@ -2212,7 +2184,9 @@ void do_set_style(EditState *e, const char *stylestr,
}
prop_index = css_get_enum(propstr,
"color,background-color,font-family,font-style,font-weight,font-size,text-decoration");
"color,background-color,font-family,"
"font-style,font-weight,font-size,"
"text-decoration");
if (prop_index < 0) {
put_status(e, "Unknown property '%s'", propstr);
return;
@ -2274,6 +2248,13 @@ void do_set_style(EditState *e, const char *stylestr,
}
}
void do_define_color(EditState *e, const char *name, const char *value)
{
if (css_define_color(name, value))
put_status(e, "Invalid color '%s'", value);
}
#endif
void do_set_display_size(__unused__ EditState *s, int w, int h)
{
if (w != NO_ARG && h != NO_ARG) {
@ -4279,7 +4260,7 @@ void put_status(__unused__ EditState *s, const char *fmt, ...)
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (qs->screen->dpy.dpy_init == dummy_dpy_init) {
if (!qs->screen->dpy.dpy_probe) {
eb_format_message(qs, "*errors*", buf);
} else {
if (!strequal(buf, qs->status_shadow)) {
@ -6119,8 +6100,7 @@ void do_refresh(__unused__ EditState *s1)
int width, height, resized;
if (qs->complete_refresh) {
if (qs->screen->dpy.dpy_invalidate)
qs->screen->dpy.dpy_invalidate();
dpy_invalidate(qs->screen);
}
/* recompute various dimensions */
@ -7388,115 +7368,6 @@ static CmdOptionDef cmd_options[] = {
#include "qeconfig.h"
/* dummy display driver for initialization time */
static int dummy_dpy_probe(void)
{
return 1;
}
extern QEDisplay dummy_dpy;
static int dummy_dpy_init(QEditScreen *s, __unused__ int w, __unused__ int h)
{
memcpy(&s->dpy, &dummy_dpy, sizeof(QEDisplay));
s->charset = &charset_8859_1;
return 0;
}
static void dummy_dpy_close(__unused__ QEditScreen *s)
{
}
static void dummy_dpy_cursor_at(__unused__ QEditScreen *s,
__unused__ int x1, __unused__ int y1,
__unused__ int w, __unused__ int h)
{
}
static int dummy_dpy_is_user_input_pending(__unused__ QEditScreen *s)
{
return 0;
}
static void dummy_dpy_fill_rectangle(__unused__ QEditScreen *s,
__unused__ int x1, __unused__ int y1,
__unused__ int w, __unused__ int h,
__unused__ QEColor color)
{
}
static QEFont *dummy_dpy_open_font(__unused__ QEditScreen *s,
__unused__ int style, __unused__ int size)
{
return NULL;
}
static void dummy_dpy_close_font(__unused__ QEditScreen *s,
__unused__ QEFont *font)
{
}
static void dummy_dpy_text_metrics(__unused__ QEditScreen *s,
__unused__ QEFont *font,
QECharMetrics *metrics,
__unused__ const unsigned int *str,
__unused__ int len)
{
metrics->font_ascent = 1;
metrics->font_descent = 0;
metrics->width = len;
}
static void dummy_dpy_draw_text(__unused__ QEditScreen *s,
__unused__ QEFont *font,
__unused__ int x, __unused__ int y,
__unused__ const unsigned int *str,
__unused__ int len,
__unused__ QEColor color)
{
}
static void dummy_dpy_set_clip(__unused__ QEditScreen *s,
__unused__ int x, __unused__ int y,
__unused__ int w, __unused__ int h)
{
}
static void dummy_dpy_flush(__unused__ QEditScreen *s)
{
}
QEDisplay dummy_dpy = {
"dummy",
dummy_dpy_probe,
dummy_dpy_init,
dummy_dpy_close,
dummy_dpy_cursor_at,
dummy_dpy_flush,
dummy_dpy_is_user_input_pending,
dummy_dpy_fill_rectangle,
dummy_dpy_open_font,
dummy_dpy_close_font,
dummy_dpy_text_metrics,
dummy_dpy_draw_text,
dummy_dpy_set_clip,
NULL, /* dpy_selection_activate */
NULL, /* dpy_selection_request */
NULL, /* dpy_invalidate */
NULL, /* dpy_bmp_alloc */
NULL, /* dpy_bmp_free */
NULL, /* dpy_bmp_draw */
NULL, /* dpy_bmp_lock */
NULL, /* dpy_bmp_unlock */
NULL, /* dpy_full_screen */
NULL, /* next */
};
#if (defined(__GNUC__) || defined(__TINYC__)) && defined(CONFIG_INIT_CALLS)
static void init_all_modules(void)
@ -7675,10 +7546,10 @@ static void qe_init(void *opaque)
s = edit_new(b, 0, 0, 0, 0, WF_MODELINE);
/* at this stage, no screen is defined. Initialize a
* dummy display driver to have a consistent state
* null display driver to have a consistent state
* else many commands such as put_status would crash.
*/
dummy_dpy.dpy_init(&global_screen, screen_width, screen_height);
dpy_init(&global_screen, NULL, screen_width, screen_height);
/* handle options */
_optind = parse_command_line(argc, argv);
@ -7696,7 +7567,7 @@ static void qe_init(void *opaque)
fprintf(stderr, "No suitable display found, exiting\n");
exit(1);
}
if (dpy->dpy_init(&global_screen, screen_width, screen_height) < 0) {
if (dpy_init(&global_screen, dpy, screen_width, screen_height) < 0) {
/* Just disable the display and try another */
//fprintf(stderr, "Could not initialize display '%s', exiting\n",
// dpy->name);

5
qe.h
View file

@ -1121,7 +1121,7 @@ struct QEmacsState {
//struct QECharset *first_charset;
//struct QETimer *first_timer;
//struct VarDef *first_variable;
//struct InputMethod *input_methods;
struct InputMethod *input_methods;
EditState *first_window;
EditState *active_window; /* window in which we edit */
EditBuffer *first_buffer;
@ -1264,8 +1264,7 @@ typedef struct CmdDef {
void qe_register_mode(ModeDef *m);
void mode_completion(CompleteState *cp);
void qe_register_cmd_table(CmdDef *cmds, ModeDef *m);
void qe_register_binding(int key, const char *cmd_name,
const char *mode_names);
int qe_register_binding(int key, const char *cmd_name, ModeDef *m);
CmdDef *qe_find_cmd(const char *cmd_name);
/* text display system */

8
tty.c
View file

@ -101,8 +101,6 @@ static int tty_term_probe(void)
return 1;
}
static QEDisplay tty_dpy;
static int tty_term_init(QEditScreen *s,
__unused__ int w, __unused__ int h)
{
@ -110,8 +108,6 @@ static int tty_term_init(QEditScreen *s,
struct termios tty;
struct sigaction sig;
memcpy(&s->dpy, &tty_dpy, sizeof(QEDisplay));
s->STDIN = stdin;
s->STDOUT = stdout;
@ -295,7 +291,7 @@ static void tty_resize(__unused__ int sig)
s->clip_y2 = s->height;
}
static void tty_term_invalidate(void)
static void tty_term_invalidate(QEditScreen *s)
{
tty_resize(0);
}
@ -841,7 +837,6 @@ static QEDisplay tty_dpy = {
tty_term_probe,
tty_term_init,
tty_term_close,
tty_term_cursor_at,
tty_term_flush,
tty_term_is_user_input_pending,
tty_term_fill_rectangle,
@ -853,6 +848,7 @@ static QEDisplay tty_dpy = {
NULL, /* dpy_selection_activate */
NULL, /* dpy_selection_request */
tty_term_invalidate,
tty_term_cursor_at,
NULL, /* dpy_bmp_alloc */
NULL, /* dpy_bmp_free */
NULL, /* dpy_bmp_draw */

8
unihex.c
View file

@ -187,10 +187,10 @@ static int unihex_init(void)
qe_register_mode(&unihex_mode);
/* additional mode specific keys */
qe_register_binding(KEY_CTRL_LEFT, "decrease-width", "unihex");
qe_register_binding(KEY_CTRL_RIGHT, "increase-width", "unihex");
qe_register_binding(KEY_TAB, "toggle-hex", "unihex");
qe_register_binding(KEY_SHIFT_TAB, "toggle-hex", "unihex");
qe_register_binding(KEY_CTRL_LEFT, "decrease-width", &unihex_mode);
qe_register_binding(KEY_CTRL_RIGHT, "increase-width", &unihex_mode);
qe_register_binding(KEY_TAB, "toggle-hex", &unihex_mode);
qe_register_binding(KEY_SHIFT_TAB, "toggle-hex", &unihex_mode);
return 0;
}

61
util.c
View file

@ -909,23 +909,26 @@ void keytostr(char *buf, int buf_size, int key)
int to_hex(int key)
{
/* Only ASCII supported */
if (qe_isdigit(key))
return key - '0';
else if (key >= 'a' && key <= 'f')
return key - 'a' + 10;
else if (key >= 'A' && key <= 'F')
return key - 'A' + 10;
else
if (qe_inrange(key | ('a' - 'A'), 'a', 'f'))
return (key & 7) + 9;
else
return -1;
}
#if 1
/* Should move all this to display.c */
typedef struct ColorDef {
const char *name;
unsigned int color;
} ColorDef;
static ColorDef const css_colors[] = {
/*from HTML 4.0 spec */
static ColorDef const default_colors[] = {
/* From HTML 4.0 spec */
{ "black", QERGB(0x00, 0x00, 0x00) },
{ "green", QERGB(0x00, 0x80, 0x00) },
{ "silver", QERGB(0xc0, 0xc0, 0xc0) },
@ -952,22 +955,18 @@ static ColorDef const css_colors[] = {
{ "grey", QERGB(0xbe, 0xbe, 0xbe) },
{ "transparent", COLOR_TRANSPARENT },
};
#define nb_css_colors countof(css_colors)
#define nb_default_colors countof(default_colors)
static ColorDef *custom_colors;
static int nb_custom_colors;
static ColorDef *qe_colors = (ColorDef *)default_colors;
static int nb_qe_colors = nb_default_colors;
void color_completion(CompleteState *cp)
{
ColorDef const *def;
int count;
def = custom_colors;
count = nb_custom_colors;
if (!count) {
def = css_colors;
count = nb_css_colors;
}
def = qe_colors;
count = nb_qe_colors;
while (count > 0) {
if (strxstart(def->name, cp->current, NULL))
add_string(&cp->cs, def->name);
@ -998,32 +997,29 @@ int css_define_color(const char *name, const char *value)
if (css_get_color(&color, value))
return -1;
/* First color definition: allocate custom_colors array */
if (!nb_custom_colors) {
custom_colors = qe_malloc_dup(css_colors, sizeof(css_colors));
if (!custom_colors)
return -1;
nb_custom_colors = nb_css_colors;
/* First color definition: allocate modifiable array */
if (qe_colors == default_colors) {
qe_colors = qe_malloc_dup(default_colors, sizeof(default_colors));
}
/* Make room: reallocate table in chunks of 8 entries */
if (((nb_custom_colors - nb_css_colors) & 7) == 0) {
if (!qe_realloc(&custom_colors,
(nb_custom_colors + 8) * sizeof(ColorDef))) {
if (((nb_qe_colors - nb_default_colors) & 7) == 0) {
if (!qe_realloc(&qe_colors,
(nb_qe_colors + 8) * sizeof(ColorDef))) {
return -1;
}
}
/* Check for redefinition */
index = css_lookup_color(custom_colors, nb_custom_colors, name);
index = css_lookup_color(qe_colors, nb_qe_colors, name);
if (index >= 0) {
custom_colors[index].color = color;
qe_colors[index].color = color;
return 0;
}
def = &custom_colors[nb_custom_colors];
def = &qe_colors[nb_qe_colors];
def->name = qe_strdup(name);
def->color = color;
nb_custom_colors++;
nb_qe_colors++;
return 0;
}
@ -1036,12 +1032,8 @@ int css_get_color(QEColor *color_ptr, const char *p)
unsigned char rgba[4];
/* search in tables */
def = custom_colors;
count = nb_custom_colors;
if (!count) {
def = css_colors;
count = nb_css_colors;
}
def = qe_colors;
count = nb_qe_colors;
index = css_lookup_color(def, count, p);
if (index >= 0) {
*color_ptr = def[index].color;
@ -1127,6 +1119,7 @@ int css_get_font_family(const char *str)
v = 0; /* inherit */
return v;
}
#endif /* style stuff */
/* a = a union b */
void css_union_rect(CSSRect *a, const CSSRect *b)

2
video.c
View file

@ -973,7 +973,7 @@ int video_init(void)
qe_register_mode(&video_mode);
qe_register_cmd_table(video_commands, &video_mode);
/* additional mode specific keys */
qe_register_binding('f', "toggle-full-screen", "av");
qe_register_binding('f', "toggle-full-screen", &video_mode);
return 0;
}

6
win32.c
View file

@ -25,8 +25,6 @@
extern int main1(int argc, char **argv);
LRESULT CALLBACK qe_wnd_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
extern QEDisplay win32_dpy;
static HINSTANCE _hPrev, _hInstance;
static int font_xsize;
@ -141,8 +139,6 @@ static int win_init(QEditScreen *s, int w, int h)
if (!_hPrev)
init_application();
memcpy(&s->dpy, &win32_dpy, sizeof(QEDisplay));
s->private = NULL;
s->media = CSS_MEDIA_SCREEN;
@ -504,7 +500,6 @@ static QEDisplay win32_dpy = {
win_probe,
win_init,
win_close,
NULL,
win_flush,
win_is_user_input_pending,
win_fill_rectangle,
@ -516,6 +511,7 @@ static QEDisplay win32_dpy = {
NULL, /* dpy_selection_activate */
NULL, /* dpy_selection_request */
NULL, /* dpy_invalidate */
NULL, /* dpy_cursor_at */
NULL, /* dpy_bmp_alloc */
NULL, /* dpy_bmp_free */
NULL, /* dpy_bmp_draw */

5
x11.c
View file

@ -80,7 +80,6 @@ static int update_nb;
static CSSRect update_rects[UPDATE_MAX_REGIONS];
#endif
static QEDisplay x11_dpy;
static int visual_depth;
static int force_tty;
@ -193,8 +192,6 @@ static int term_init(QEditScreen *s, int w, int h)
QEStyleDef default_style;
XGCValues gc_val;
memcpy(&s->dpy, &x11_dpy, sizeof(QEDisplay));
s->private = NULL;
s->media = CSS_MEDIA_SCREEN;
@ -1679,7 +1676,6 @@ static QEDisplay x11_dpy = {
term_probe,
term_init,
term_close,
NULL,
term_flush,
x11_is_user_input_pending,
term_fill_rectangle,
@ -1691,6 +1687,7 @@ static QEDisplay x11_dpy = {
term_selection_activate,
term_selection_request,
NULL, /* dpy_invalidate */
NULL, /* dpy_cursor_at */
x11_bmp_alloc,
x11_bmp_free,
x11_bmp_draw,