- Fix for possible unset uid/gid in toproto - Fix for default mtree style - Update libelf - Importing libexecinfo - Resynchronize GCC, mpc, gmp, mpfr - build.sh: Replace params with show-params. This has been done as the make target has been renamed in the same way, while a new target named params has been added. This new target generates a file containing all the parameters, instead of printing it on the console. - Update test48 with new etc/services (Fix by Ben Gras <ben@minix3.org) get getservbyport() out of the inner loop Change-Id: Ie6ad5226fa2621ff9f0dee8782ea48f9443d2091
764 lines
20 KiB
C
764 lines
20 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <gtk/gtkmain.h>
|
|
#include <gtk/gtksignal.h>
|
|
#include "gtkviscreen.h"
|
|
#include <gdk/gdkx.h>
|
|
|
|
#define INTISUCS(c) ((c & ~0x7F) && !(((c) >> 16) & 0x7F))
|
|
#define INTUCS(c) (c)
|
|
#ifdef USE_WIDECHAR
|
|
#define CHAR_WIDTH(sp, ch) wcwidth(ch)
|
|
#else
|
|
#define CHAR_WIDTH(sp, ch) 1
|
|
#endif
|
|
|
|
void * v_strset __P((CHAR_T *s, CHAR_T c, size_t n));
|
|
|
|
#define DEFAULT_VI_SCREEN_WIDTH_CHARS 80
|
|
#define DEFAULT_VI_SCREEN_HEIGHT_LINES 25
|
|
#define VI_SCREEN_BORDER_ROOM 1
|
|
|
|
enum {
|
|
ARG_0,
|
|
ARG_VADJUSTMENT,
|
|
};
|
|
|
|
enum {
|
|
RESIZED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static void gtk_vi_screen_class_init (GtkViScreenClass *klass);
|
|
static void gtk_vi_screen_set_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
static void gtk_vi_screen_get_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id);
|
|
static void gtk_vi_screen_init (GtkViScreen *vi);
|
|
static void gtk_vi_screen_destroy (GtkObject *object);
|
|
static void gtk_vi_screen_realize (GtkWidget *widget);
|
|
/*
|
|
static void gtk_vi_screen_map (GtkWidget *widget);
|
|
static void gtk_vi_screen_unmap (GtkWidget *widget);
|
|
*/
|
|
static void gtk_vi_screen_size_request (GtkWidget *widget,
|
|
GtkRequisition *requisition);
|
|
static void gtk_vi_screen_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation);
|
|
/*
|
|
static void gtk_vi_screen_adjustment (GtkAdjustment *adjustment,
|
|
GtkViScreen *text);
|
|
*/
|
|
|
|
static gint gtk_vi_screen_expose (GtkWidget *widget,
|
|
GdkEventExpose *event);
|
|
|
|
static void recompute_geometry (GtkViScreen* vi);
|
|
static void expose_text (GtkViScreen* vi, GdkRectangle *area, gboolean cursor);
|
|
static void draw_lines(GtkViScreen *vi, gint y, gint x, gint ymax, gint xmax);
|
|
static void mark_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax);
|
|
|
|
static GtkWidgetClass *parent_class = NULL;
|
|
static guint vi_screen_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
static GdkFont *gb_font;
|
|
static GdkFont *tfn;
|
|
static GdkFont *tfw;
|
|
|
|
#define CharAt(scr,y,x) scr->chars + (y) * scr->cols + x
|
|
#define FlagAt(scr,y,x) (scr->reverse + (y) * scr->cols + x)
|
|
#define ColAt(scr,y,x) (scr->endcol + (y) * scr->cols + x)
|
|
|
|
#define COLOR_STANDARD 0x00
|
|
#define COLOR_STANDOUT 0x01
|
|
|
|
/* XXX */
|
|
enum { SA_ALTERNATE, SA_INVERSE };
|
|
|
|
void
|
|
gtk_vi_screen_attribute(GtkViScreen *vi, gint attribute, gint on)
|
|
{
|
|
switch (attribute) {
|
|
case SA_INVERSE:
|
|
vi->color = on ? COLOR_STANDOUT : COLOR_STANDARD;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* col is screen column */
|
|
void
|
|
gtk_vi_screen_move(GtkViScreen *vi, gint row, gint col)
|
|
{
|
|
gint x;
|
|
guchar *endcol;
|
|
|
|
endcol = vi->endcol + row*vi->cols;
|
|
for (x = 0; col > endcol[x]; ++x);
|
|
vi->curx = x;
|
|
vi->cury = row;
|
|
}
|
|
|
|
static void
|
|
cleartoel (GtkViScreen *vi, guint row, guint col)
|
|
{
|
|
CHAR_T *p, *e;
|
|
|
|
if (MEMCMP(p = CharAt(vi,row,col), e = CharAt(vi,vi->rows,0),
|
|
vi->cols - col)) {
|
|
MEMMOVE(p, e, vi->cols - col);
|
|
memset(FlagAt(vi,row,col), COLOR_STANDARD, vi->cols - col);
|
|
mark_lines(vi, row, col, row+1, vi->cols);
|
|
}
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_clrtoel (GtkViScreen *vi)
|
|
{
|
|
cleartoel(vi, vi->cury, vi->curx);
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_addstr(GtkViScreen *vi, const char *str, int len)
|
|
{
|
|
CHAR_T *p, *end;
|
|
CHAR_T *line;
|
|
guchar *endcol;
|
|
gint col, startcol;
|
|
gint x;
|
|
|
|
line = vi->chars + vi->cury*vi->cols;
|
|
endcol = vi->endcol + vi->cury*vi->cols;
|
|
x = vi->curx;
|
|
startcol = x ? endcol[x-1] : -1;
|
|
for (p = CharAt(vi,vi->cury,vi->curx), end = p + len, col = startcol;
|
|
p < end; ++x) {
|
|
*p++ = *str++;
|
|
endcol[x] = ++col;
|
|
}
|
|
memset(FlagAt(vi,vi->cury,vi->curx), vi->color, len);
|
|
|
|
mark_lines(vi, vi->cury, startcol+1, vi->cury+1, endcol[x-1]+1);
|
|
|
|
if (endcol[x-1] >= vi->cols) {
|
|
if (++vi->cury >= vi->rows) {
|
|
vi->cury = vi->rows-1;
|
|
vi->curx = x-1;
|
|
} else {
|
|
vi->curx = 0;
|
|
}
|
|
} else vi->curx += len;
|
|
if (x < vi->cols) endcol[x] = vi->cols;
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_waddstr(GtkViScreen *vi, const CHAR_T *str, int len)
|
|
{
|
|
CHAR_T *p, *end;
|
|
CHAR_T *line;
|
|
guchar *endcol;
|
|
gint col, startcol;
|
|
gint x;
|
|
|
|
MEMMOVE(CharAt(vi,vi->cury,vi->curx),str,len);
|
|
memset(FlagAt(vi,vi->cury,vi->curx), vi->color, len);
|
|
|
|
line = vi->chars + vi->cury*vi->cols;
|
|
endcol = vi->endcol + vi->cury*vi->cols;
|
|
x = vi->curx;
|
|
startcol = x ? endcol[x-1] : -1;
|
|
for (col = startcol; x < vi->curx + len; ++x)
|
|
endcol[x] = col += CHAR_WIDTH(NULL, *(line+x));
|
|
|
|
mark_lines(vi, vi->cury, startcol+1, vi->cury+1, endcol[x-1]+1);
|
|
|
|
if (endcol[x-1] >= vi->cols) {
|
|
if (++vi->cury >= vi->rows) {
|
|
vi->cury = vi->rows-1;
|
|
vi->curx = x-1;
|
|
} else {
|
|
vi->curx = 0;
|
|
}
|
|
} else vi->curx += len;
|
|
if (x < vi->cols) endcol[x] = vi->cols;
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_deleteln(GtkViScreen *vi)
|
|
{
|
|
gint y = vi->cury;
|
|
gint rows = vi->rows - (y+1);
|
|
|
|
MEMMOVE(CharAt(vi,y,0), CharAt(vi,y+1,0), rows * vi->cols);
|
|
cleartoel(vi,vi->rows-1,0);
|
|
memmove(FlagAt(vi,y,0), FlagAt(vi,y+1,0), rows * vi->cols);
|
|
memmove(ColAt(vi,y,0), ColAt(vi,y+1,0), rows * vi->cols);
|
|
mark_lines(vi, y, 0, vi->rows-1, vi->cols);
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_insertln(GtkViScreen *vi)
|
|
{
|
|
gint y = vi->cury;
|
|
gint rows = vi->rows - (y+1);
|
|
|
|
MEMMOVE(CharAt(vi,y+1,0), CharAt(vi,y,0), rows * vi->cols);
|
|
cleartoel(vi,y,0);
|
|
memmove(FlagAt(vi,y+1,0), FlagAt(vi,y,0), rows * vi->cols);
|
|
memmove(ColAt(vi,y+1,0), ColAt(vi,y,0), rows * vi->cols);
|
|
mark_lines(vi, y+1, 0, vi->rows, vi->cols);
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_refresh(GtkViScreen *vi)
|
|
{
|
|
if (vi->lastx != vi->curx || vi->lasty != vi-> cury) {
|
|
mark_lines(vi, vi->lasty,
|
|
vi->lastx ? *ColAt(vi,vi->lasty,vi->lastx-1) + 1 : 0,
|
|
vi->lasty+1, *ColAt(vi,vi->lasty,vi->lastx)+1);
|
|
mark_lines(vi, vi->cury,
|
|
vi->curx ? *ColAt(vi,vi->cury,vi->curx-1) + 1 : 0,
|
|
vi->cury+1, *ColAt(vi,vi->cury,vi->curx)+1);
|
|
}
|
|
if (vi->marked_maxy == 0)
|
|
return;
|
|
draw_lines(vi, vi->marked_y, vi->marked_x, vi->marked_maxy, vi->marked_maxx);
|
|
vi->marked_x = vi->cols;
|
|
vi->marked_y = vi->rows;
|
|
vi->marked_maxx = 0;
|
|
vi->marked_maxy = 0;
|
|
vi->lastx = vi->curx;
|
|
vi->lasty = vi->cury;
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_rewrite(GtkViScreen *vi, gint row)
|
|
{
|
|
memset(FlagAt(vi,row,0), COLOR_STANDARD, vi->cols);
|
|
mark_lines(vi, row, 0, row+1, vi->cols);
|
|
}
|
|
|
|
GtkType
|
|
gtk_vi_screen_get_type (void)
|
|
{
|
|
static GtkType vi_screen_type = 0;
|
|
|
|
if (!vi_screen_type)
|
|
{
|
|
static const GtkTypeInfo vi_screen_info =
|
|
{
|
|
"GtkViScreen",
|
|
sizeof (GtkViScreen),
|
|
sizeof (GtkViScreenClass),
|
|
(GtkClassInitFunc) gtk_vi_screen_class_init,
|
|
(GtkObjectInitFunc) gtk_vi_screen_init,
|
|
/* reserved_1 */ NULL,
|
|
/* reserved_2 */ NULL,
|
|
(GtkClassInitFunc) NULL,
|
|
};
|
|
|
|
vi_screen_type = gtk_type_unique (GTK_TYPE_WIDGET, &vi_screen_info);
|
|
}
|
|
|
|
return vi_screen_type;
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_class_init (GtkViScreenClass *class)
|
|
{
|
|
GtkObjectClass *object_class;
|
|
GtkWidgetClass *widget_class;
|
|
|
|
object_class = (GtkObjectClass*) class;
|
|
widget_class = (GtkWidgetClass*) class;
|
|
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
|
|
|
|
vi_screen_signals[RESIZED] =
|
|
gtk_signal_new ("resized",
|
|
GTK_RUN_FIRST,
|
|
GTK_CLASS_TYPE(object_class),
|
|
GTK_SIGNAL_OFFSET (GtkViScreenClass, resized),
|
|
gtk_marshal_NONE__INT_INT,
|
|
GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_INT, 0);
|
|
|
|
#ifndef HAVE_PANGO
|
|
gtk_object_class_add_signals(object_class, vi_screen_signals, LAST_SIGNAL);
|
|
#endif
|
|
|
|
gtk_object_add_arg_type ("GtkViScreen::vadjustment",
|
|
GTK_TYPE_ADJUSTMENT,
|
|
GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
|
|
ARG_VADJUSTMENT);
|
|
|
|
object_class->set_arg = gtk_vi_screen_set_arg;
|
|
object_class->get_arg = gtk_vi_screen_get_arg;
|
|
object_class->destroy = gtk_vi_screen_destroy;
|
|
|
|
widget_class->realize = gtk_vi_screen_realize;
|
|
/*
|
|
widget_class->map = gtk_vi_screen_map;
|
|
widget_class->unmap = gtk_vi_screen_unmap;
|
|
*/
|
|
widget_class->size_request = gtk_vi_screen_size_request;
|
|
widget_class->size_allocate = gtk_vi_screen_size_allocate;
|
|
widget_class->expose_event = gtk_vi_screen_expose;
|
|
|
|
class->rename = NULL;
|
|
class->resized = NULL;
|
|
|
|
gb_font = gdk_font_load ("-*-*-*-*-*-*-16-*-*-*-*-*-gb2312.1980-*");
|
|
/*
|
|
tf = gdk_font_load ("-misc-fixed-*-*-*-*-16-*-*-*-*-*-iso10646-*");
|
|
*/
|
|
tfn = gdk_font_load ("-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-iso10646");
|
|
tfw = gdk_font_load ("-Misc-Fixed-Medium-R-*-*-13-120-75-75-C-120-ISO10646-1");
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_set_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
GtkViScreen *vi_screen;
|
|
|
|
vi_screen = GTK_VI_SCREEN (object);
|
|
|
|
switch (arg_id)
|
|
{
|
|
case ARG_VADJUSTMENT:
|
|
gtk_vi_screen_set_adjustment (vi_screen, GTK_VALUE_POINTER (*arg));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_get_arg (GtkObject *object,
|
|
GtkArg *arg,
|
|
guint arg_id)
|
|
{
|
|
GtkViScreen *vi_screen;
|
|
|
|
vi_screen = GTK_VI_SCREEN (object);
|
|
|
|
switch (arg_id)
|
|
{
|
|
case ARG_VADJUSTMENT:
|
|
GTK_VALUE_POINTER (*arg) = vi_screen->vadj;
|
|
break;
|
|
default:
|
|
arg->type = GTK_TYPE_INVALID;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_init (GtkViScreen *vi)
|
|
{
|
|
GtkStyle *style;
|
|
|
|
GTK_WIDGET_SET_FLAGS (vi, GTK_CAN_FOCUS);
|
|
|
|
vi->text_area = NULL;
|
|
vi->chars = 0;
|
|
vi->reverse = 0;
|
|
vi->cols = 0;
|
|
vi->color = COLOR_STANDARD;
|
|
vi->cols = 0;
|
|
vi->rows = 0;
|
|
|
|
#ifdef HAVE_PANGO
|
|
vi->conx = NULL;
|
|
#endif
|
|
|
|
style = gtk_style_copy(GTK_WIDGET(vi)->style);
|
|
gdk_font_unref(style->font);
|
|
style->font = gdk_font_load("-*-fixed-*-*-*-*-16-*-*-*-*-*-iso8859-*");
|
|
GTK_WIDGET(vi)->style = style;
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_destroy (GtkObject *object)
|
|
{
|
|
GtkViScreen *vi_screen;
|
|
|
|
g_return_if_fail (object != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (object));
|
|
|
|
vi_screen = (GtkViScreen*) object;
|
|
|
|
/*
|
|
gtk_signal_disconnect_by_data (GTK_OBJECT (vi_screen->vadj), vi_screen);
|
|
*/
|
|
|
|
GTK_OBJECT_CLASS(parent_class)->destroy (object);
|
|
}
|
|
|
|
GtkWidget*
|
|
gtk_vi_screen_new (GtkAdjustment *vadj)
|
|
{
|
|
GtkWidget *vi;
|
|
|
|
vi = gtk_widget_new (GTK_TYPE_VI_SCREEN,
|
|
"vadjustment", vadj,
|
|
NULL);
|
|
|
|
|
|
return vi;
|
|
}
|
|
|
|
void
|
|
gtk_vi_screen_set_adjustment (GtkViScreen *vi_screen,
|
|
GtkAdjustment *vadj)
|
|
{
|
|
g_return_if_fail (vi_screen != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (vi_screen));
|
|
if (vadj)
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
|
|
else
|
|
vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 1.0, 0.0, 1.0, 0.0, 0.0));
|
|
|
|
if (vi_screen->vadj && (vi_screen->vadj != vadj))
|
|
{
|
|
gtk_signal_disconnect_by_data (GTK_OBJECT (vi_screen->vadj), vi_screen);
|
|
gtk_object_unref (GTK_OBJECT (vi_screen->vadj));
|
|
}
|
|
|
|
if (vi_screen->vadj != vadj)
|
|
{
|
|
vi_screen->vadj = vadj;
|
|
gtk_object_ref (GTK_OBJECT (vi_screen->vadj));
|
|
gtk_object_sink (GTK_OBJECT (vi_screen->vadj));
|
|
|
|
/*
|
|
gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "changed",
|
|
(GtkSignalFunc) gtk_vi_screen_adjustment,
|
|
vi_screen);
|
|
gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "value_changed",
|
|
(GtkSignalFunc) gtk_vi_screen_adjustment,
|
|
vi_screen);
|
|
gtk_signal_connect (GTK_OBJECT (vi_screen->vadj), "disconnect",
|
|
(GtkSignalFunc) gtk_vi_screen_disconnect,
|
|
vi_screen);
|
|
gtk_vi_screen_adjustment (vadj, vi_screen);
|
|
*/
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_realize (GtkWidget *widget)
|
|
{
|
|
GtkViScreen *vi;
|
|
GdkWindowAttr attributes;
|
|
gint attributes_mask;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (widget));
|
|
|
|
vi = GTK_VI_SCREEN (widget);
|
|
GTK_WIDGET_SET_FLAGS (vi, GTK_REALIZED);
|
|
|
|
attributes.window_type = GDK_WINDOW_CHILD;
|
|
attributes.x = widget->allocation.x;
|
|
attributes.y = widget->allocation.y;
|
|
attributes.width = widget->allocation.width;
|
|
attributes.height = widget->allocation.height;
|
|
attributes.wclass = GDK_INPUT_OUTPUT;
|
|
attributes.visual = gtk_widget_get_visual (widget);
|
|
attributes.colormap = gtk_widget_get_colormap (widget);
|
|
attributes.event_mask = gtk_widget_get_events (widget);
|
|
attributes.event_mask |= (GDK_EXPOSURE_MASK |
|
|
GDK_BUTTON_PRESS_MASK |
|
|
GDK_BUTTON_RELEASE_MASK |
|
|
GDK_BUTTON_MOTION_MASK |
|
|
GDK_ENTER_NOTIFY_MASK |
|
|
GDK_LEAVE_NOTIFY_MASK |
|
|
GDK_KEY_PRESS_MASK);
|
|
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
|
|
|
|
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
|
|
gdk_window_set_user_data (widget->window, vi);
|
|
|
|
attributes.x = (widget->style->xthickness + VI_SCREEN_BORDER_ROOM);
|
|
attributes.y = (widget->style->ythickness + VI_SCREEN_BORDER_ROOM);
|
|
attributes.width = MAX (1, (gint)widget->allocation.width - (gint)attributes.x * 2);
|
|
attributes.height = MAX (1, (gint)widget->allocation.height - (gint)attributes.y * 2);
|
|
|
|
vi->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
|
|
gdk_window_set_user_data (vi->text_area, vi);
|
|
|
|
widget->style = gtk_style_attach (widget->style, widget->window);
|
|
|
|
/* Can't call gtk_style_set_background here because it's handled specially */
|
|
gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
|
|
gdk_window_set_background (vi->text_area, &widget->style->base[GTK_STATE_NORMAL]);
|
|
|
|
vi->gc = gdk_gc_new (vi->text_area);
|
|
/* What's this ? */
|
|
gdk_gc_set_exposures (vi->gc, TRUE);
|
|
gdk_gc_set_foreground (vi->gc, &widget->style->text[GTK_STATE_NORMAL]);
|
|
|
|
vi->reverse_gc = gdk_gc_new (vi->text_area);
|
|
gdk_gc_set_foreground (vi->reverse_gc, &widget->style->base[GTK_STATE_NORMAL]);
|
|
|
|
gdk_window_show (vi->text_area);
|
|
|
|
recompute_geometry (vi);
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_size_request (GtkWidget *widget,
|
|
GtkRequisition *requisition)
|
|
{
|
|
gint xthick;
|
|
gint ythick;
|
|
gint char_height;
|
|
gint char_width;
|
|
GtkViScreen *vi;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (widget));
|
|
g_return_if_fail (requisition != NULL);
|
|
|
|
vi = GTK_VI_SCREEN (widget);
|
|
|
|
xthick = widget->style->xthickness + VI_SCREEN_BORDER_ROOM;
|
|
ythick = widget->style->ythickness + VI_SCREEN_BORDER_ROOM;
|
|
|
|
vi->ch_ascent = widget->style->font->ascent;
|
|
vi->ch_height = (widget->style->font->ascent + widget->style->font->descent) + 1;
|
|
vi->ch_width = gdk_text_width (widget->style->font, "A", 1);
|
|
char_height = DEFAULT_VI_SCREEN_HEIGHT_LINES * vi->ch_height;
|
|
char_width = DEFAULT_VI_SCREEN_WIDTH_CHARS * vi->ch_width;
|
|
|
|
requisition->width = char_width + xthick * 2;
|
|
requisition->height = char_height + ythick * 2;
|
|
}
|
|
|
|
static void
|
|
gtk_vi_screen_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation)
|
|
{
|
|
GtkViScreen *vi;
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (widget));
|
|
g_return_if_fail (allocation != NULL);
|
|
|
|
vi = GTK_VI_SCREEN (widget);
|
|
|
|
widget->allocation = *allocation;
|
|
if (GTK_WIDGET_REALIZED (widget))
|
|
{
|
|
gdk_window_move_resize (widget->window,
|
|
allocation->x, allocation->y,
|
|
allocation->width, allocation->height);
|
|
|
|
gdk_window_move_resize (vi->text_area,
|
|
widget->style->xthickness + VI_SCREEN_BORDER_ROOM,
|
|
widget->style->ythickness + VI_SCREEN_BORDER_ROOM,
|
|
MAX (1, (gint)widget->allocation.width - (gint)(widget->style->xthickness +
|
|
(gint)VI_SCREEN_BORDER_ROOM) * 2),
|
|
MAX (1, (gint)widget->allocation.height - (gint)(widget->style->ythickness +
|
|
(gint)VI_SCREEN_BORDER_ROOM) * 2));
|
|
|
|
recompute_geometry (vi);
|
|
}
|
|
}
|
|
|
|
/*
|
|
static void
|
|
gtk_vi_screen_adjustment (GtkAdjustment *adjustment,
|
|
GtkViScreen *vi_screen)
|
|
{
|
|
g_return_if_fail (adjustment != NULL);
|
|
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
|
|
g_return_if_fail (vi_screen != NULL);
|
|
g_return_if_fail (GTK_IS_VI_SCREEN (vi_screen));
|
|
|
|
}
|
|
*/
|
|
|
|
static gint
|
|
gtk_vi_screen_expose (GtkWidget *widget,
|
|
GdkEventExpose *event)
|
|
{
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_VI_SCREEN (widget), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
if (event->window == GTK_VI_SCREEN (widget)->text_area)
|
|
{
|
|
expose_text (GTK_VI_SCREEN (widget), &event->area, TRUE);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
recompute_geometry (GtkViScreen* vi)
|
|
{
|
|
//gint xthickness;
|
|
//gint ythickness;
|
|
gint height;
|
|
gint width;
|
|
gint rows, cols;
|
|
gint i;
|
|
|
|
//xthickness = widget->style->xthickness + VI_SCREEN_BORDER_ROOM;
|
|
//ythickness = widget->style->ythickness + VI_SCREEN_BORDER_ROOM;
|
|
|
|
gdk_window_get_size (vi->text_area, &width, &height);
|
|
|
|
rows = height / vi->ch_height;
|
|
cols = width / vi->ch_width;
|
|
|
|
if (rows == vi->rows && cols == vi->cols)
|
|
return;
|
|
|
|
vi->marked_x = vi->cols = cols;
|
|
vi->marked_y = vi->rows = rows;
|
|
vi->marked_maxx = 0;
|
|
vi->marked_maxy = 0;
|
|
|
|
g_free(vi->chars);
|
|
vi->chars = (CHAR_T*)g_new(gchar, (vi->rows+1)*vi->cols * sizeof(CHAR_T));
|
|
STRSET(vi->chars, L(' '), (vi->rows+1)*vi->cols);
|
|
g_free(vi->endcol);
|
|
vi->endcol = g_new(guchar, vi->rows*vi->cols);
|
|
g_free(vi->reverse);
|
|
vi->reverse = g_new(guchar, vi->rows*vi->cols);
|
|
memset(vi->reverse, 0, vi->rows*vi->cols);
|
|
|
|
gtk_signal_emit(GTK_OBJECT(vi), vi_screen_signals[RESIZED], vi->rows, vi->cols);
|
|
}
|
|
|
|
static void
|
|
expose_text (GtkViScreen* vi, GdkRectangle *area, gboolean cursor)
|
|
{
|
|
gint ymax;
|
|
gint xmax, xmin;
|
|
|
|
gdk_window_clear_area (vi->text_area, area->x, area->y,
|
|
area->width, area->height);
|
|
ymax = MIN((area->y + area->height + vi->ch_height - 1) / vi->ch_height,
|
|
vi->rows);
|
|
xmin = area->x / vi->ch_width;
|
|
xmax = MIN((area->x + area->width + vi->ch_width - 1) / vi->ch_width,
|
|
vi->cols);
|
|
draw_lines(vi, area->y / vi->ch_height, xmin, ymax, xmax);
|
|
}
|
|
|
|
#define Inverse(screen,y,x) \
|
|
((*FlagAt(screen,y,x) == COLOR_STANDOUT) ^ \
|
|
(screen->cury == y && screen->curx == x))
|
|
|
|
static void
|
|
draw_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax)
|
|
{
|
|
gint y, x, len, blen, xpos;
|
|
CHAR_T *line;
|
|
GdkGC *fg, *bg;
|
|
GdkFont *font;
|
|
gchar buf[2];
|
|
gchar *p;
|
|
gboolean pango;
|
|
|
|
for (y = ymin, line = vi->chars + y*vi->cols;
|
|
y < ymax; ++y, line += vi->cols) {
|
|
for (x = 0, xpos = 0; xpos <= xmin; ++x)
|
|
xpos += CHAR_WIDTH(NULL, *(line+x));
|
|
--x;
|
|
xpos -= CHAR_WIDTH(NULL, *(line+x));
|
|
for (; xpos < xmax; x+=len, xpos+= blen) {
|
|
gchar inverse;
|
|
inverse = Inverse(vi,y,x);
|
|
len = 1;
|
|
if (sizeof(CHAR_T) == sizeof(gchar))
|
|
for (; x+len < xmax &&
|
|
Inverse(vi,y,x+len) == inverse; ++len);
|
|
if (inverse) {
|
|
fg = vi->reverse_gc;
|
|
bg = vi->gc;
|
|
} else {
|
|
bg = vi->reverse_gc;
|
|
fg = vi->gc;
|
|
}
|
|
pango = 0;
|
|
#ifdef HAVE_PANGO
|
|
if (INTISUCS(*(line+x))) {
|
|
if (!vi->conx) {
|
|
PangoFontDescription font_description;
|
|
|
|
font_description.family_name = g_strdup ("monospace");
|
|
font_description.style = PANGO_STYLE_NORMAL;
|
|
font_description.variant = PANGO_VARIANT_NORMAL;
|
|
font_description.weight = 500;
|
|
font_description.stretch = PANGO_STRETCH_NORMAL;
|
|
font_description.size = 15000;
|
|
|
|
vi->conx = gdk_pango_context_get();
|
|
pango_context_set_font_description (vi->conx,
|
|
&font_description);
|
|
pango_context_set_lang(vi->conx, "en_US");
|
|
vi->alist = pango_attr_list_new();
|
|
}
|
|
blen = CHAR_WIDTH(NULL, *(line+x));
|
|
pango = 1;
|
|
} else
|
|
#endif
|
|
{
|
|
font = GTK_WIDGET(vi)->style->font;
|
|
if (sizeof(CHAR_T) == sizeof(gchar))
|
|
p = (gchar*)line+x;
|
|
else {
|
|
buf[0] = *(line+x);
|
|
p = buf;
|
|
}
|
|
blen = len;
|
|
}
|
|
gdk_draw_rectangle(vi->text_area, bg, 1, xpos * vi->ch_width,
|
|
y * vi->ch_height, blen * vi->ch_width,
|
|
vi->ch_height);
|
|
/* hack to not display half a wide character that wasn't
|
|
* removed.
|
|
*/
|
|
if (!pango)
|
|
gdk_draw_text (vi->text_area, font, fg,
|
|
xpos * vi->ch_width,
|
|
y * vi->ch_height + vi->ch_ascent,
|
|
p, blen);
|
|
#ifdef HAVE_PANGO
|
|
else {
|
|
PangoGlyphString *gs;
|
|
GList *list;
|
|
PangoItem *item;
|
|
char buf[3];
|
|
int len;
|
|
|
|
len = ucs2utf8(line+x, 1, buf);
|
|
list = pango_itemize(vi->conx, buf, 0, len, vi->alist, NULL);
|
|
item = list->data;
|
|
gs = pango_glyph_string_new ();
|
|
pango_shape(buf, len, &item->analysis, gs);
|
|
|
|
gdk_draw_glyphs (vi->text_area, fg, item->analysis.font,
|
|
xpos * vi->ch_width,
|
|
y * vi->ch_height + vi->ch_ascent, gs);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
mark_lines(GtkViScreen *vi, gint ymin, gint xmin, gint ymax, gint xmax)
|
|
{
|
|
if (ymin < vi->marked_y) vi->marked_y = ymin;
|
|
if (xmin < vi->marked_x) vi->marked_x = xmin;
|
|
if (ymax > vi->marked_maxy) vi->marked_maxy = ymax;
|
|
if (xmax > vi->marked_maxx) vi->marked_maxx = xmax;
|
|
}
|