void
zune_font_replace (GdkFont **font, STRPTR fontname)
{
/* g_print("replacing preset %ld with font %s\n", preset, fontname); */
if (*font)
gdk_font_unref(*font);
if (fontname != NULL && strlen(fontname) > 0)
{
*font = gdk_font_load(fontname);
if (*font)
{
/* g_print("font loaded\n"); */
return;
}
/* g_print("cannot load font\n"); */
}
if (__zprefs.fonts[-MUIV_Font_Normal])
{
if (fontname != NULL && strlen(fontname) > 0)
g_warning("Cannot load font '%s', fallback to window font\n",
fontname);
*font = gdk_font_ref(__zprefs.fonts[-MUIV_Font_Normal]);
}
else
{
g_warning("Cannot load font '%s', trying 'fixed'\n", fontname);
*font = gdk_font_load("fixed");
}
}
GdkFont *
my_font_load (char *fontname)
{
GdkFont *font;
char temp[256];
if (!*fontname)
fontname = "fixed";
if (prefs.use_fontset)
font = gdk_fontset_load (fontname);
else
font = gdk_font_load (fontname);
if (!font)
{
snprintf (temp, sizeof (temp), _("Cannot open font:\n\n%s"), fontname);
gtkutil_simpledialog (temp);
font = gdk_font_load ("fixed");
if (!font)
{
g_error (_("gdk_font_load failed"));
gtk_exit (0);
}
}
return font;
}
static GdkFont *findfont(char *name, int size)
{
GdkFont *font;
int fi, n, i;
if (name[0] == '\000')
return Gfontp[0].font;
sprintf(&Gbufp[0], name, size);
for (fi = 0; fi < Gfontn; fi++)
if (Strcmp(&Gbufp[0], Gfontp[fi].name) == 0)
return Gfontp[fi].font;
if (!(font = gdk_font_load(&Gbufp[0]))) {
n = strlen(&Gbufp[0]) + 1;
for (i = 1; i < size; i++) {
sprintf(&Gbufp[n], name, size - i);
if ((font = gdk_font_load(&Gbufp[n])))
break;
sprintf(&Gbufp[n], name, size + i);
if ((font = gdk_font_load(&Gbufp[n])))
break;
}
}
if (!font)
font = Gfontp[0].font;
Gfontp = Marraygrow(Gfontp, (long) (Gfontn + 1) * FONTSIZE);
Gfontp[Gfontn].name = strdup(&Gbufp[0]);
Gfontp[Gfontn].font = font;
Gfontn++;
return font;
}
gint
wgra_configure(GtkWidget *widget,GdkEventConfigure *ee,gpointer data)
{
GdkGC *mygc;
int x,y,cx,xs;
int i,v;
long max;
float fac;
GdkFont *fn;
if (wcanvas!=NULL)
gdk_pixmap_unref(wcanvas);
mygc=gdk_gc_new(widget->window);
wcanvas=gdk_pixmap_new(widget->window,x=widget->allocation.width,
y=widget->allocation.height,-1);
gdk_draw_rectangle(wcanvas,widget->style->white_gc,TRUE,0,0,x,y);
gdk_draw_rectangle(wcanvas,widget->style->black_gc,FALSE,0,0,x-1,y-1);
max=0;
for(i=0;i<7;i++)
if (weekly[i]>max)
max=weekly[i];
if (!max) max=1;
fac=((float)(y-18-16))/((float)max);
cx=1;
xs=(x-2)/7;
fn=gdk_font_load("-*-helvetica-medium-r-*-*-8-*-*-*-*-*-*-*");
for (i=0;i<7;i++) {
v=(int)(((float)weekly[i])*fac);
gdk_rgb_gc_set_foreground(mygc,0xc0c0c0);
gdk_draw_line(wcanvas,mygc,cx,1,cx,y-2);
gdk_rgb_gc_set_foreground(mygc,0x004080);
gdk_draw_rectangle(wcanvas,mygc,TRUE,cx,y-18-v,xs,v);
gdk_rgb_gc_set_foreground(mygc,0x000000);
gdk_draw_string(wcanvas,fn,mygc,cx,y-6,wdays[i]);
cx+=xs;
}
gdk_draw_line(wcanvas,widget->style->black_gc,0,y-18,x-1,y-18);
gdk_rgb_gc_set_foreground(mygc,0xffffff);
gdk_draw_rectangle(wcanvas,mygc,TRUE,0,0,23*4,13);
gdk_rgb_gc_set_foreground(mygc,0x000000);
gdk_draw_rectangle(wcanvas,mygc,FALSE,0,0,23*4,13);
gdk_font_unref(fn);
fn=gdk_font_load("-*-helvetica-medium-r-*-*-10-*-*-*-*-*-*-*");
gdk_draw_string(wcanvas,fn,mygc,5,10,"weekday summary");
gdk_font_unref(fn);
gdk_gc_destroy(mygc);
return FALSE;
}
void gpk_graph_draw(GtkWidget *widget, /* plot on this widged */
int n, /* number of data points */
gdouble *xcord, gdouble *ycord, /* data */
gdouble xmn,gdouble ymn, /* coordinates of corners */
gdouble xmx,gdouble ymx,
int clear, /* clear old plot first */
char *title, /* add a title (only if clear=1) */
GdkColor *color)
{
GdkPixmap **ppixmap;
GdkPoint *points;
int i;
gint16 width,height;
GdkFont *fixed_font;
GdkGC *gc;
gc = gdk_gc_new(widget->window);
gdk_gc_set_foreground(gc, color);
if ((ppixmap=findpixmap(widget))) {
width = widget->allocation.width;
height = widget->allocation.height;
if (clear) {
/* white background */
gdk_draw_rectangle (*ppixmap,
widget->style->white_gc,
TRUE,0, 0,width,height);
/* title */
#ifdef _WIN32
fixed_font = gdk_font_load ("-misc-fixed-large-r-*-*-*-100-*-*-*-*-*-*");
#else
fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-iso8859-1");
#endif
gdk_draw_text (*ppixmap,fixed_font,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
0,10,title,strlen(title));
}
points = g_malloc(n*sizeof(GdkPoint));
for (i=0; i<n ; i++) {
points[i].x =.5+ ((xcord[i]-xmn)*(width-1)/(xmx-xmn));
points[i].y =.5+ ((ycord[i]-ymx)*(height-1)/(ymn-ymx));
}
gdk_draw_lines(*ppixmap,gc,points,n);
g_free(points);
gpk_redraw(*ppixmap,widget);
}
gdk_gc_destroy(gc);
}
/* drawCar
* Draws a car
*
* @return void
*/
void drawCar (int colorCarro, gint xant, gint yant, gint x, gint y, gint width, gint height) {
GdkRectangle car;
GdkColor color;
switch(colorCarro){
case 1:
gdk_color_parse("#FF0000", &color);
break;
case 2:
gdk_color_parse("#0000FF", &color);
break;
case 3:
gdk_color_parse("#00FF00", &color);
break;
case 4:
gdk_color_parse("#000000", &color);
break;
case 5:
gdk_color_parse("#FFFFFF", &color);
break;
case 6:
gdk_color_parse("#FFFF00", &color);
break;
case 7:
gdk_color_parse("#FF6600", &color);
break;
case 8:
gdk_color_parse("#FF33CC", &color);
break;
case 9:
gdk_color_parse("#6699FF", &color);
break;
case 10:
gdk_color_parse("#777777", &color);
break;
}
GdkGC* gcont;
gcont = gdk_gc_new(this.pixMap);
gdk_gc_set_rgb_fg_color (gcont, &color);
gtk_widget_queue_draw_area(this.drawingArea, xant, yant, width, height);
car.x = x;
car.y = y;
car.width = width;
car.height = height;
gdk_draw_rectangle(this.pixMap, gcont, TRUE, car.x, car.y, car.width, car.height);
if (colorCarro==4)
gdk_draw_string(this.pixMap, gdk_font_load("-*-*-bold-r-normal--*-50-*-*-*-*-iso8859-1"), this.drawingArea->style->white_gc, (car.x+2), (car.y+10), "A1/5");
else
gdk_draw_string(this.pixMap, gdk_font_load("-*-*-bold-r-normal--*-50-*-*-*-*-iso8859-1"), this.drawingArea->style->black_gc, (car.x+2), (car.y+10), "A1/5");
gtk_widget_queue_draw_area(this.drawingArea, car.x, car.y, car.width, car.height);
}
/*
* Change font used to display log text, NULL means reset to default
*/
void
GTK_change_log_font(gchar *fontname)
{
#if 0 // old GTK
GtkRcStyle *rcstyle = gtk_rc_style_new();
#else
GtkStyle *rcstyle = gtk_style_new();
#endif
// if (GTK_OBJECT(v9t9_command_log)->flags & GTK_DESTROYED) {//2.0
if (!v9t9_command_log) {
g_free(rcstyle);
return;
}
if (fontname && *fontname) {
#if 0 // old GTK
rcstyle->font_name = fontname;
gtk_widget_modify_style(v9t9_command_log, rcstyle);
#else
gtk_style_set_font(rcstyle, gdk_font_load(fontname));
gtk_widget_set_style(v9t9_command_log, rcstyle);
#endif
} else {
// this is probably too harsh for a cancel
gtk_widget_restore_default_style(v9t9_command_log);
}
// g_free(rcstyle);
}
JNIEXPORT jintArray JNICALL Java_gnu_java_awt_peer_gtk_GdkFontMetrics_initState
(JNIEnv *env, jobject obj, jstring fname, jint size)
{
jintArray array;
jint *metrics;
const char *cfname;
char *xlfd;
GdkFont *font;
XFontStruct *xfont;
cfname = (*env)->GetStringUTFChars (env, fname, NULL);
xlfd = g_strdup_printf (cfname, (size * 10));
(*env)->ReleaseStringUTFChars (env, fname, cfname);
array = (*env)->NewIntArray (env, NUM_METRICS);
metrics = (*env)->GetIntArrayElements (env, array, NULL);
gdk_threads_enter ();
font = gdk_font_load (xlfd);
xfont = GDK_FONT_XFONT (font);
metrics[ASCENT] = font->ascent;
metrics[MAX_ASCENT] = xfont->max_bounds.ascent;
metrics[DESCENT] = font->descent;
metrics[MAX_DESCENT] = xfont->max_bounds.descent;
metrics[MAX_ADVANCE] = xfont->max_bounds.width;
gdk_threads_leave ();
g_free (xlfd);
(*env)->ReleaseIntArrayElements (env, array, metrics, 0);
NSA_SET_PTR (env, obj, font);
return array;
}
/* Loads a font.
*
* Currently, this function will always return a new font, however, in the future,
* it may be changed to look up the font in a cache. You should make no assumptions
* about the initial reference count. */
int
clip_GDK_FONTLOAD(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm,1);
const gchar *font_name = _clip_parc(cm,2);
GdkFont *font;
C_object *cfont;
CHECKOPT(1,MAP_t); CHECKARG(2,CHARACTER_t);
font = gdk_font_load(font_name);
if (font)
{
// gdk_font_ref(font);
cfont = _register_object(cm,font,GDK_OBJECT_FONT,cv,
(coDestructor)gdk_object_font_destructor);
if (cfont)
{
cfont->ref_count = 1;
_clip_mclone(cm,RETPTR(cm),&cfont->obj);
}
else
gdk_font_unref(font);
}
return 0;
err:
return 1;
}
void on_iol_window_show(GtkWidget *widget, gpointer user_data)
{
char *hdir;
char string[] = { "input red green blue alpha;\n\n#put your program here\n\noutput red green blue alpha;\n" };
script_text = GTK_TEXT(user_data);
script_font = gdk_font_load("-*-courier-medium-r-normal-*-12-*-*-*-*-*-*-*");
gtk_text_freeze(script_text);
gtk_text_insert(script_text,script_font,NULL,NULL,string,strlen(string));
gtk_text_thaw(script_text);
stay_open = 0;
hdir = getenv("IOL_SCRIPTS");
if(hdir == NULL) {
fprintf(stderr,"IOL: $IOL_SCRIPTS environment variable not set, checking $HOME...\n");
hdir = getenv("HOME");
if(hdir == NULL) {
fprintf(stderr,"IOL: $HOME environment variable not set\n");
strcpy(default_dir,"/usr");
} else {
strncpy(default_dir,hdir,256);
strncat(default_dir,"/.cinepaint/iol/",256);
fprintf(stderr,"IOL: using %s as the default directory for scripts\n",default_dir);
}
} else {
strncpy(default_dir,hdir,256);
strncat(default_dir,"/",256); /* the file selection dialog needs
it to end with a "/" so that it
will know it's a directory we
want */
}
}
gint init(GtkWidget *widget)
{
if (gtk_gl_area_make_current(GTK_GL_AREA(widget))) {
GdkFont *font;
/* set viewport */
glViewport(0,0, widget->allocation.width, widget->allocation.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,widget->allocation.width, 0,widget->allocation.height, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* generate font display lists */
fontbase = glGenLists( 128 );
font = gdk_font_load(fontname);
if (!font) {
g_print("Can't load font '%s'\n", fontname);
gtk_exit(1);
}
gdk_gl_use_gdk_font(font, 0, 128, fontbase);
fontheight = font->ascent+font->descent;
gdk_font_unref(font);
}
return TRUE;
}
static gint SetBaseFont(gtkDesc *gtkd)
{
gtkd->fontface = 1;
gtkd->fontsize = 12;
gtkd->usefixed = 0;
if(font_htab == NULL) {
font_htab = g_hash_table_new (g_str_hash, g_str_equal);
}
gtkd->font = RGTKLoadFont (gtkd->fontface, gtkd->fontsize);
if(gtkd->wgc == NULL)
return(1);
if(gtkd->font != NULL) {
gdk_gc_set_font(gtkd->wgc, gtkd->font);
return 1;
}
gtkd->usefixed = 1;
gtkd->font = gdk_font_load ("fixed");
if(gtkd->font != NULL) {
gdk_gc_set_font(gtkd->wgc, gtkd->font);
return 1;
}
return 0;
}
// Méthode de choix de fonte de caractères
// La syntaxe pour une fonte est : "-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1"
// Chaque champ peut être remplacé par * si on ne veut pas de valeur particulière
// Les champs sont les suivants :
// - Créateur de la fonte
// - Nom de la famille
// - Graisse : 'bold' ou 'medium' ...
// - Aspect : 'R' pour Roman, 'I' pour italique, 'O' pour oblique ...
// - Largeur : 'normal' ou 'condensed'
// - le chanp suivant est omis => on a -- entre la largeur et la taille
// - Taille : taille en pixels
// - Points : taille en points
// - Résolution en X
// - Résolution en y
// - Espacement : 'p' pour proportionel, 'm' pour monospaced ou 'c' pour matrice de caractère
// - Taille moyenne d'un caractère de la fonte
// - Norme de codage
// - Codage du jeu de caractères
// Cette méthode permet de créer des noms de la forme :
// "-*-famille-graisse-italique-*--taille-*-*-*-*-*-*-*"
// où graisse peut être 'bold' ou '*'
// et italique peut être ; 'i' ou '*'
// et taille est la valeur passée en paramètre
void Fenetre::choixFonte(const char *famille, int taille, bool grasBool, bool italiqueBool) {
if (existe) {
char nom[80];
gboolean gras = (grasBool ? TRUE : FALSE);
gboolean italique = (italiqueBool ? TRUE : FALSE);
strcpy (nom,"-*-"); strcat(nom,famille);
if (gras) strcat(nom,"-bold"); else strcat(nom,"-*");
if (italique) strcat(nom,"-i"); else strcat(nom,"-r");
strcat(nom,"-*--");
char t[3]; sprintf(t,"%d",taille); strcat(nom,t);
strcat(nom,"-*-*-*-*-*-*-*");
GdkFont* essai; essai=gdk_font_load(nom);
if (essai==NULL) {
g_print("La fonte %s de taille %d ",famille, taille);
if (gras) g_print(" gras ");
if (italique) g_print(" italiques ");
g_print("n'existe pas : on garde la fonte precedente\n");
}
else fonte=essai;
traiteEvenements();
// Ce qui suit est la version utilisant Pango
/* strcpy (nom,famille);
strcat(nom," ");
if (gras) strcat(nom,"bold ");
if (italique) strcat(nom,"italic");
strcat(nom," ");
char t[3]; sprintf(t,"%d",taille); strcat(nom,t);
PangoFontDescription* descripteur=pango_font_description_from_string(nom);
fonte=gdk_font_from_description(descripteur);
traiteEvenements();*/
}
}
static void
set_font_str(GtkWidget *w, gchar *fontstr)
{
GdkFont *font;
gchar *msg;
if (determine_use_fontset())
{
font = gdk_fontset_load(fontstr);
}
else
{
font = gdk_font_load(fontstr);
}
if (font != NULL)
{
set_font(w, font);
}
else
{
msg = g_strdup_printf(_("Can't load font %s"), fontstr);
set_status_text(msg);
g_free(msg);
}
}
/* Sets the font for a graphics context.
* (Note that all text-drawing functions in GDK take a font argument;
* the value set here is used when that argument is NULL.) */
int
clip_GDK_GCSETFONT(ClipMachine * cm)
{
C_object *cgc = _fetch_co_arg(cm);
ClipVar *c;
GdkFont *font = 0; C_object *cfont;
CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKARG3(2,CHARACTER_t,MAP_t,NUMERIC_t);
switch ( _clip_parinfo(cm,2) )
{
case CHARACTER_t:
c = _clip_spar(cm,2);
font = gdk_font_load(c->s.str.buf);
break;
case MAP_t:
case NUMERIC_t:
cfont = _fetch_cobject(cm,_clip_spar(cm,2));
if (cfont)
{
font = (GdkFont*)cfont->object;
cfont->ref_count++;
}
break;
default:
break;
}
if (font)
{
gdk_gc_set_font(GDK_GC(cgc->object), font);
gdk_font_ref (font);
}
return 0;
err:
return 1;
}
static void
gtk_ui_graphics_init(void) {
offscreen = gdk_pixmap_new(field->window, screensize, screensize, -1);
stdgc = gdk_gc_new(offscreen);
gdk_gc_set_exposures(stdgc, FALSE);
gdk_gc_set_line_attributes(stdgc, 2, GDK_LINE_SOLID, GDK_CAP_ROUND,
GDK_JOIN_MITER);
font = gdk_font_load("fixed");
}
wxNativeFont wxLoadFont(const wxString& fontSpec)
{
// VZ: we should use gdk_fontset_load() instead of gdk_font_load()
// here to be able to display Japanese fonts correctly (at least
// this is what people report) but unfortunately doing it results
// in tons of warnings when using GTK with "normal" European
// languages and so we can't always do it and I don't know enough
// to determine when should this be done... (FIXME)
return gdk_font_load( wxConvertWX2MB(fontSpec) );
}
static void
draw_top_speed (C2NetworkTraffic *nt)
{
gint x1, x2, y1, y2;
gint text_width, text_height;
gint top_speed_kb;
gint i;
gfloat pixels_per_byte;
GdkFont *font;
gchar *string;
GtkWidget *widget = GTK_WIDGET (nt);
/* Allocate the font */
font = gdk_font_load ("-monotype-arial-bold-r-normal-*-*-110-*-*-p-*-iso8859-1");
/* Allocate the value that are static */
x1 = 1;
/* Calculate which is the top_speed in Kb */
top_speed_kb = nt->top_speed/1024;
/* Calculate how many pixels should be drown per byte */
pixels_per_byte = get_pixels_per_byte (nt);
for (i = top_speed_kb; i > 0; i--)
{
string = g_strdup_printf ("(%d Kb/s)", i);
if (i == top_speed_kb)
{
/* Calculate the dimensions of the text */
text_height = gdk_string_height (font, string);
text_width = gdk_string_width (font, string);
} else
{
text_height = gdk_string_height (font, string);;
text_width = 0;
}
/* Allocate the dynamic value that we calculated */
x2 = widget->allocation.width - text_width - 20;
y1 = y2 = (text_height/2)+TOP_MARGIN + (pixels_per_byte * ((top_speed_kb-i)*1024));
gdk_draw_line (nt->pixmap, widget->style->black_gc,
x1, y1, x2, y2);
if (i == top_speed_kb)
gdk_draw_string (nt->pixmap, font, widget->style->black_gc,
x2+10, y1+(text_height/2), string);
g_free (string);
}
}
FontInfo *addFontInfo (char *name)
{
FontInfo *r;
r = NULL;
r = XkNew (FontInfo);
r->name = XkNewString (name);
r->next = fontCache;
r->references = 1;
r->font = gdk_font_load (r->name);
if (r->font == NULL)
{
/* if the font does not exist replace it with a standard font */
r->font = gdk_font_load ("fixed"); /*** FIXME -> cache this! ***/
}
assert (r->font != NULL);
fontCache = r;
return r;
}
static struct font_engine_font_t *font_engine_gdk_font_load(const char *string)
{
GdkFont *f = gdk_font_load(string);
if(f)
{
struct font_engine_font_t *fef = calloc_2(1, sizeof(struct font_engine_font_t));
fef->gdkfont = f;
fef->ascent = f->ascent;
fef->descent = f->descent;
return(fef);
}
else
{
return(NULL);
}
}
/**
* Allocate memory for list status view structure and initialize it with
* correct values.
*
* \todo: All of the values are hardcoded now, but it should be possible to make
* them used settable through configuration storage. It would mean to refactor
* the configuration storage though (flag option list won't be sufficient
* anymore, especially for colors).
*
* \return pointer to image display specific data
*/
ViewListStatus* view_lsv_create(ViewGeneric *parent) {
const ConfigStorage* conf;
ViewListStatus *result = NULL;
GdkFont* font = NULL;
ASSERT( NULL != parent );
font = gdk_font_load(DEFAULT_FONT_NAME);
if ( NULL == font ) {
ERROR_SET(ERROR.INVALID_PARAM);
ERROR_NOTE("Font %s does not load", DEFAULT_FONT_NAME);
return result;
}
if ( NULL == ( result = (ViewListStatus*) g_try_malloc0(sizeof(ViewListStatus))) ) {
ERROR_SET(ERROR.MEMORY_FAILURE);
return result;
}
result->border_size.x = 5;
result->border_size.y = 2;
/// \todo for now, we assume that the font is monospace and does not contain
// wide characters
result->text_size.x = gdk_char_width(font, 'A');
result->text_size.y = gdk_char_height(font, 'A');
result->color.fg.red = 65535;
result->color.fg.green = 65535;
result->color.fg.blue = 65535;
result->color.bg.red = 0;
result->color.bg.green = 0;
result->color.bg.blue = 0;
result->font = font;
parent->region_hint.y = result->text_size.y + 2 * result->border_size.y;
return result;
}
static void
gtk_hex_entry_init (GtkHexEntry *hex_entry)
{
GTK_WIDGET_SET_FLAGS (hex_entry, GTK_CAN_FOCUS);
/* */
hex_entry->digits = 8;
hex_entry->buffer = NULL;
hex_entry->gc = NULL;
hex_entry->pixmap = NULL;
hex_entry->editable = TRUE;
hex_entry->cursor_position = -1;
hex_entry->modified = FALSE;
gdk_color_parse ("red",&hex_entry->cursor_color);
// hex_entry->font = gdk_font_load ("fixed");
hex_entry->font = gdk_font_load ("9x15");
}
static void fp_gtk_ui_create()
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *btnQuit;
GdkFont *font;
font = gdk_font_load("-misc-New-medium-r-normal--0-0-0-0-p-0-iso8859-1");
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_border_width(GTK_CONTAINER(window), 10);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(window_delete_event), NULL);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(window_destroy), NULL);
vbox = gtk_vbox_new(FALSE, 10);
build_control_ui(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_window_set_title(GTK_WINDOW(window), "XMUX FP");
/* show all */
gtk_widget_show_all(window);
}
GdkFont *GetFontForSize (int fontsize)
{
if (fontsize > 40)
fontsize = 40;
int increment = +1;
if (fontsize < 2)
return NULL;
again:
if (gdkfont[fontsize] == NULL)
{
if (fontsize != 13)
{
char *fontname = g_strdup_printf ("*-helvetica-bold-r-normal-*-*-%d0-*", fontsize);
// char *fontname = g_strdup_printf ("-adobe-helvetica-bold-r-normal--%d-120-75-75-p-70-iso8859-1", fontsize);
gdkfont[fontsize] = gdk_font_load (fontname);
g_free (fontname);
}
if (gdkfont[fontsize] == NULL)
gdkfont[fontsize] = (GdkFont *) - 1;
}
if (gdkfont[fontsize] == (GdkFont *) - 1)
{
fontsize += increment;
if (fontsize > 40)
{
fontsize = 39;
increment = -1;
}
if (fontsize == 0)
return gdkfont[fontsize];
goto again;
}
return gdkfont[fontsize];
}
gint init(GtkWidget *widget)
{
/* OpenGL functions can be called only if makecurrent returns true */
if (gtk_gl_area_make_current(GTK_GL_AREA(widget))) {
#if !defined(WIN32)
GdkFont *font;
#endif
/* set viewport */
glViewport(0,0, widget->allocation.width, widget->allocation.height);
#if !defined(WIN32)
/* generate font display lists */
font = gdk_font_load("-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*");
if (font) {
fontbase = glGenLists( 128 );
gdk_gl_use_gdk_font(font, 0, 128, fontbase);
gdk_font_unref(font);
}
#endif
}
return TRUE;
}
void
apply_cb (GtkWidget * crap, gpointer * nothing)
{
int x;
if (this_panel_cb)
this_panel_cb ();
/*
* pack the new font
*/
if (fntname != NULL)
{
/* if(mud->disp_font_name)
g_free(mud->disp_font_name);
*/
mud->disp_font_name = g_strdup (fntname);
}
/* g_free(mud->disp_font); */
mud->disp_font = gdk_font_load (mud->disp_font_name);
/*
* pack the colors
*/
for (x = 0; x < 9; ++x)
{ /* unrolled. 2 isn't 'nuff for a loop. */
memcpy (&color[x][0], &ccol[x][0], sizeof (GdkColor));
memcpy (&color[x][1], &ccol[x][1], sizeof (GdkColor));
}
color_save ();
session_save ();
return;
}
static wxFont* RwxLoadFont (wxDesc *gtkd, int face, int size)
{
wxString fontname;
wxFont *tmp_font;
int pixelsize;
if (face < 1 || face > 5)
face = 1;
if (size < SMALLEST) size = SMALLEST;
/* Here's a 1st class fudge: make sure that the Adobe design sizes
8, 10, 11, 12, 14, 17, 18, 20, 24, 25, 34 can be obtained via
an integer "size" at 100 dpi, namely 6, 7, 8, 9, 10, 12, 13,
14, 17, 18, 24 points. It's almost y = x * 100/72, but not
quite. The constants were found using lm(). --pd */
if (IS_100DPI) size = (int) R_rint (size * 1.43 - 0.4);
/* 'size' is the requested size, 'pixelsize' the size of the
actually allocated font*/
pixelsize = size;
tmp_font = new wxFont(pixelsize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
#if 0
if(face == 5)
fontname = wxString::Format(symbolname, pixelsize);
else
fontname = wxString::Format(fontname_R6,
weight[(face-1)%2],
slant[((face-1)/2)%2],
pixelsize);
tmp_font = gdk_font_load(fontname);
if (!tmp_font) {
static int near[]=
{14,14,14,17,17,18,20,20,20,20,24,24,24,25,25,25,25};
/* 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 */
/* If ADOBE_SIZE(pixelsize) is true at this point then
the user's system does not have the standard ADOBE font set
so we just have to use a "fixed" font.
If we can't find a "fixed" font then something is seriously
wrong */
if (ADOBE_SIZE (pixelsize)) {
tmp_font = gdk_font_load ("fixed");
if (!tmp_font)
error("Could not find any X11 fonts\nCheck that the Font Path is correct.");
}
if (pixelsize < 8)
pixelsize = 8;
else if (pixelsize == 9)
pixelsize = 8;
else if (pixelsize >= 13 && pixelsize < 30)
pixelsize = near[size-13];
else
pixelsize = 34;
g_free(fontname);
if(face == 5)
fontname = g_strdup_printf(symbolname, pixelsize);
else
fontname = g_strdup_printf(fontname_R6,
weight[(face-1)%2],
slant[((face-1)/2)%2],
pixelsize);
tmp_font = gdk_font_load (fontname);
}
if(tmp_font) {
#ifdef HASH_FONTS
font_htab[fontname] = tmp_font;
#endif
if (fabs( (pixelsize - size)/(double)size ) > 0.2)
warning("wxWidgets used font size %d when %d was requested",
pixelsize, size);
}
#endif
return tmp_font;
}
GtkWidget *
create_file_view(FileView *view)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *menu_bar;
GtkWidget *button;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkFont *font;
GtkWidget *sw;
gint i;
/* Top Pane */
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
menu_bar = create_filelist_menu_bar(view);
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
/* Show/Hide Button */
if (view == &app.right_view)
button = gtk_button_new_with_label("<");
else
button = gtk_button_new_with_label(">");
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(show_hide_file_view_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Maximize/Minimize File View\n"
"Right Click: Sync Dirs"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* Hidden files toggle button */
view->hidden_toggle = gtk_toggle_button_new_with_label("H");
GTK_WIDGET_UNSET_FLAGS(view->hidden_toggle, GTK_CAN_FOCUS);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(view->hidden_toggle),
view->show_hidden);
gtk_signal_connect(GTK_OBJECT(view->hidden_toggle), "toggled",
GTK_SIGNAL_FUNC(toggle_show_hidden_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), view->hidden_toggle,
_("Show/Hide hidden files"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), view->hidden_toggle, FALSE, FALSE, 0);
gtk_widget_show(view->hidden_toggle);
/* Dir Entry Combo */
view->dir_entry = gtk_combo_new();
gtk_combo_disable_activate(GTK_COMBO(view->dir_entry));
gtk_combo_set_use_arrows_always(GTK_COMBO(view->dir_entry), TRUE);
gtk_combo_set_case_sensitive(GTK_COMBO(view->dir_entry), TRUE);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->entry),
"activate", GTK_SIGNAL_FUNC(dir_entry_cb), view);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->popwin),
"hide", GTK_SIGNAL_FUNC(dir_popwin_cb), view);
gtk_box_pack_start(GTK_BOX(hbox), view->dir_entry, TRUE, TRUE, 0);
gtk_widget_show(view->dir_entry);
/* Up Dir Button */
button = gtk_button_new();
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(updir_click_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Up Dir Right Click: Home"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
style = gtk_widget_get_style(app.main_window);
pixmap = gdk_pixmap_create_from_xpm_d(app.main_window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
icon_dirparent_xpm);
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_container_add(GTK_CONTAINER(button), pixmapwid);
gtk_widget_show(pixmapwid);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(sw), cfg.scrollbar_pos);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* File List */
view->clist = gtk_clist_new(MAX_COLUMNS);
for (i = 0; i < MAX_COLUMNS; i++)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *label = gtk_label_new(all_columns[i].title);
view->sort_arrows[i] = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), view->sort_arrows[i], FALSE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(hbox);
gtk_clist_set_column_widget(GTK_CLIST(view->clist), i, hbox);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(view->clist)->column[i].button,
GTK_CAN_FOCUS);
}
gtk_clist_column_titles_show(GTK_CLIST(view->clist));
gtk_clist_set_shadow_type(GTK_CLIST(view->clist), GTK_SHADOW_ETCHED_IN);
gtk_clist_set_selection_mode(GTK_CLIST(view->clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_use_drag_icons(GTK_CLIST(view->clist), TRUE);
gtk_clist_set_row_height(GTK_CLIST(view->clist), 0);
font = gdk_font_load(cfg.list_font);
if (font != NULL)
{
style = gtk_style_copy(gtk_widget_get_style(view->clist));
style->font = font;
gtk_widget_set_style(view->clist, style);
}
for (i = 0; i < MAX_COLUMNS; i++)
{
gtk_clist_set_column_width(GTK_CLIST(view->clist), i, all_columns[i].size);
gtk_clist_set_column_visibility(GTK_CLIST(view->clist), i,
all_columns[i].is_visible);
}
gtk_signal_connect(GTK_OBJECT(view->clist), "select_row",
GTK_SIGNAL_FUNC(select_row_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "button_press_event",
GTK_SIGNAL_FUNC(mouse_click_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "key_press_event",
GTK_SIGNAL_FUNC(file_list_key_press_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "click_column",
GTK_SIGNAL_FUNC(column_button_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_get",
GTK_SIGNAL_FUNC(clist_drag_data_get), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_motion",
GTK_SIGNAL_FUNC(clist_drag_motion), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_leave",
GTK_SIGNAL_FUNC(clist_drag_leave), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_received",
GTK_SIGNAL_FUNC(clist_drag_data_received), view);
gtk_drag_dest_set(view->clist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_table,
n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK |
GDK_ACTION_ASK);
gtk_container_add(GTK_CONTAINER(sw), view->clist);
gtk_widget_show(view->clist);
/* Set the CLIST_COLOR for resetting from the DRAG_HILIGHT color */
{
GtkStyle *style = gtk_widget_get_style(view->clist);
CLIST_COLOR.red = style->base[GTK_STATE_NORMAL].red;
CLIST_COLOR.green = style->base[GTK_STATE_NORMAL].green;
CLIST_COLOR.blue = style->base[GTK_STATE_NORMAL].blue;
}
return vbox;
}
void dessiner(file_opener *donnees)
{
GdkDrawable* cartew=donnees->carte->window;
donnees->gc = gdk_gc_new (cartew);
// On initialise la police et la couleur
donnees->font=gdk_font_load("6x9");//6x9 - 10x20
int j;
char text[5];
couleur(donnees->gc,donnees->c,-2);
// On trace les parallèles
for(j=35;j<=60;j+=5)
{
sprintf(text,"%d",j);
gdk_draw_line(cartew,donnees->gc,0,conversion_lat(j,donnees)*donnees->ycarte,donnees->xcarte*3,conversion_lat(j,donnees)*donnees->ycarte);
gdk_draw_string(cartew,donnees->font,donnees->gc,3,conversion_lat(j,donnees)*donnees->ycarte-5,text);
}
// Puis les méridiens
for(j=-15;j<=20;j+=5)
{
sprintf(text,"%d",j);
gdk_draw_line(cartew,donnees->gc,conversion_longitude(j,donnees)*donnees->xcarte,0,conversion_longitude(j,donnees)*donnees->xcarte,donnees->ycarte*3);
gdk_draw_string(cartew,donnees->font,donnees->gc,conversion_longitude(j,donnees)*donnees->xcarte+5,8,text);
}
couleur(donnees->gc,donnees->c,10);
/* ---------------------------------- CONTOUR FRANCE -------------------------------------- */
{
double x1,x2,y1,y2;
// On ouvre le fichier contenant les points
FILE *f = fopen("contour_france.csv", "rb");
//printf("f=%p\n", f);
if(f)
{
char buffer[1024];
while(fgets(buffer, sizeof(buffer), f))
{
// On charge et on converti les points.
sscanf(buffer, "%lf;%lf", &x1, &y1);
x1 = conversion_longitude(x1, donnees);
y1 = conversion_lat(y1, donnees);
while(fgets(buffer, sizeof(buffer), f))
{
// Si la ligne est "BREAK" on empeche de tracer la ligne afin de retirer les traits entre les iles
if(!strcmp(buffer, "BREAK\n"))
{
break;
}
sscanf(buffer, "%lf;%lf", &x2, &y2);
x2=conversion_longitude(x2, donnees);
y2=conversion_lat(y2, donnees);
gdk_draw_line(cartew, donnees->gc, x1*donnees->xcarte,y1*donnees->ycarte,x2*donnees->xcarte,y2*donnees->ycarte);
x1=x2;
y1=y2;
}
}
fclose(f);
}
}
// ---------------------------------- AERODROMES --------------------------------------
// Si des aérodromes sont chargé on commence l'affichage
if(donnees->debutaero!=NULL)
{
aerodrome* pt_aero=donnees->debutaero;
// Boucle pour parcourir tous les aérodromes
while(pt_aero->ptsuiv!=NULL)
{
dessiner_aerodromes(pt_aero,donnees);
pt_aero = pt_aero->ptsuiv;
}
}
// ---------------------------------- BALISES --------------------------------------
// La structure est semblable à celle des aérodromes
if(donnees->debutbalises!=NULL)
{
balise* pt_balise=donnees->debutbalises;
while(pt_balise->ptsuiv!=NULL)
{
dessiner_balise(pt_balise,donnees);
pt_balise = pt_balise->ptsuiv;
}
}
// ---------------------------------- PLAN DE VOL --------------------------------------
// On initialise la couleur à 0 pour donner une couleur à chaque plan de vol
donnees->couleur_avion=0;
if(donnees->debutpdv!=NULL) // Rentre si un plan de vol est chargé
{
pdv * pt_pdv_current=donnees->debutpdv;
while(pt_pdv_current!=NULL) // Parcours tous les plans de vol
{
dessiner_pdv(pt_pdv_current,donnees);
pt_pdv_current=pt_pdv_current->ptsuiv;
donnees->couleur_avion+=1;
}
}
/* ------------------------------------ CONFLITS ---------------------------------------- */
// Si il y a des conflits
if(donnees->deb_conflits!=NULL)
{
// On passe en couleur rouge
couleur(donnees->gc,donnees->c,-3);
conflit* conflit_current = donnees->deb_conflits;
// Variable d'affichage si reste nul à la fin de la boucle pas de conflit
int conflit_affiche = 0;
// On parcours les conflits
while(conflit_current->ptsuiv != NULL)
{
pdv* avion1 = conflit_current->pdv1;
pdv* avion2 = conflit_current->pdv2;
// On se situe entre le temps de début et de fin de conflit
if(donnees->temps > conflit_current->temps_deb && donnees->temps < conflit_current->temps_fin)
{
position c0; // position au temps t
if(avion1->affichage && avion2->affichage) // Les deux avions sont affichés
{
// Conflits affiché conflit_affiche est différent de 0
conflit_affiche++;
// On met un gros carré rouge sur la position de l'avion
get_position_avion(&c0,avion1,donnees->temps);
gdk_draw_rectangle(cartew,donnees->gc,TRUE,conversion_longitude(c0.x,donnees)*donnees->xcarte-3,conversion_lat(c0.y,donnees)*donnees->ycarte-3,7,7);
get_position_avion(&c0,avion2,donnees->temps);
gdk_draw_rectangle(cartew,donnees->gc,TRUE,conversion_longitude(c0.x,donnees)*donnees->xcarte-3,conversion_lat(c0.y,donnees)*donnees->ycarte-3,7,7);
// On change le label de conflit
char *markup;
markup = g_markup_printf_escaped ("<span foreground=\"#A00000\">%s</span>", "Conflit.");
gtk_label_set_markup (GTK_LABEL (donnees->Msg_conflit), markup);
g_free (markup);
}
}
conflit_current = conflit_current->ptsuiv;
}
// Si aucun conflit n'est affiché on passe au label pas de conflit
if(conflit_affiche==0)
{
char *markup;
markup = g_markup_printf_escaped ("<span foreground=\"#00A000\">%s</span>", "Pas de conflit\n actuellement.");
gtk_label_set_markup (GTK_LABEL (donnees->Msg_conflit), markup);
g_free (markup);
}
// On remet en noir
couleur(donnees->gc,donnees->c,10);
}
gdk_font_unref(donnees->font);
g_object_unref (donnees->gc);
}
GtkWidget *
ghack_init_status_window()
{
GtkWidget *horizSep0, *horizSep1, *horizSep2, *horizSep3;
GtkWidget *statsHBox, *strVBox, *dexVBox, *intVBox, *statHBox;
GtkWidget *wisVBox, *conVBox, *chaVBox;
GtkWidget *alignVBox, *hungerVBox, *sickVBox, *blindVBox;
GtkWidget *stunVBox, *halluVBox, *confuVBox, *encumbVBox;
/* Set up a (ridiculous) initial state */
lastDepth = 9999;
lastStr = 9999;
lastInt = 9999;
lastWis = 9999;
lastDex = 9999;
lastCon = 9999;
lastCha = 9999;
lastAu = 9999;
lastHP = 9999;
lastMHP = 9999;
lastLevel = 9999;
lastPOW = 9999;
lastMPOW = 9999;
lastAC = 9999;
lastExp = 9999;
lastAlignment = A_NEUTRAL; /* start off guessing neutral */
lastHungr = 9999;
lastConf = 9999;
lastBlind = 9999;
lastStun = 9999;
lastHalu = 9999;
lastSick = 9999;
lastEncumb = 9999;
statTable = gtk_table_new(10, 8, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(statTable), 1);
gtk_table_set_col_spacings(GTK_TABLE(statTable), 1);
/* Begin the first row of the table -- the title */
titleLabel = gtk_label_new(_("GnomeHack!"));
gtk_table_attach(GTK_TABLE(statTable), titleLabel, 0, 8, 0, 1, GTK_FILL,
0, 0, 0);
if (!normalStyle)
normalStyle =
gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(titleLabel)));
/* Set up some styles to draw stuff with */
if (!redStyle) {
g_assert(greenStyle == NULL);
g_assert(bigStyle == NULL);
g_assert(bigRedStyle == NULL);
g_assert(bigGreenStyle == NULL);
greenStyle = gtk_style_copy(normalStyle);
redStyle = gtk_style_copy(normalStyle);
bigRedStyle = gtk_style_copy(normalStyle);
bigGreenStyle = gtk_style_copy(normalStyle);
bigStyle = gtk_style_copy(normalStyle);
greenStyle->fg[GTK_STATE_NORMAL] = color_green;
redStyle->fg[GTK_STATE_NORMAL] = color_red;
bigRedStyle->fg[GTK_STATE_NORMAL] = color_red;
bigGreenStyle->fg[GTK_STATE_NORMAL] = color_green;
gdk_font_unref(bigRedStyle->font);
gdk_font_unref(bigGreenStyle->font);
bigRedStyle->font =
gdk_font_load("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*");
bigGreenStyle->font =
gdk_font_load("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*");
gdk_font_unref(bigStyle->font);
bigStyle->font =
gdk_font_load("-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*");
}
gtk_widget_set_style(GTK_WIDGET(titleLabel), bigStyle);
/* Begin the second row */
dgnLevelLabel = gtk_label_new(_("Nethack for Gnome"));
gtk_table_attach(GTK_TABLE(statTable), dgnLevelLabel, 0, 8, 1, 2,
GTK_FILL, 0, 0, 0);
gtk_widget_set_style(GTK_WIDGET(dgnLevelLabel), bigStyle);
/* Begin the third row */
horizSep0 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(statTable), horizSep0, 0, 8, 2, 3, GTK_FILL,
GTK_FILL, 0, 0);
/* Begin the fourth row */
statsHBox = gtk_hbox_new(TRUE, 0);
strVBox = gtk_vbox_new(FALSE, 0);
strPix = gnome_pixmap_new_from_xpm_d(str_xpm);
strLabel = gtk_label_new("STR: ");
gtk_box_pack_start(GTK_BOX(strVBox), strPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(strVBox), strLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(strVBox), TRUE, TRUE,
2);
dexVBox = gtk_vbox_new(FALSE, 0);
dexPix = gnome_pixmap_new_from_xpm_d(dex_xpm);
dexLabel = gtk_label_new("DEX: ");
gtk_box_pack_start(GTK_BOX(dexVBox), dexPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(dexVBox), dexLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(dexVBox), TRUE, TRUE,
2);
conVBox = gtk_vbox_new(FALSE, 0);
conPix = gnome_pixmap_new_from_xpm_d(cns_xpm);
conLabel = gtk_label_new("CON: ");
gtk_box_pack_start(GTK_BOX(conVBox), conPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(conVBox), conLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(conVBox), TRUE, TRUE,
2);
intVBox = gtk_vbox_new(FALSE, 0);
intPix = gnome_pixmap_new_from_xpm_d(int_xpm);
intLabel = gtk_label_new("INT: ");
gtk_box_pack_start(GTK_BOX(intVBox), intPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(intVBox), intLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(intVBox), TRUE, TRUE,
2);
wisVBox = gtk_vbox_new(FALSE, 0);
wisPix = gnome_pixmap_new_from_xpm_d(wis_xpm);
wisLabel = gtk_label_new("WIS: ");
gtk_box_pack_start(GTK_BOX(wisVBox), wisPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(wisVBox), wisLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(wisVBox), TRUE, TRUE,
2);
chaVBox = gtk_vbox_new(FALSE, 0);
chaPix = gnome_pixmap_new_from_xpm_d(cha_xpm);
chaLabel = gtk_label_new("CHA: ");
gtk_box_pack_start(GTK_BOX(chaVBox), chaPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(chaVBox), chaLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statsHBox), GTK_WIDGET(chaVBox), TRUE, TRUE,
2);
gtk_table_attach(GTK_TABLE(statTable), GTK_WIDGET(statsHBox), 0, 8, 3, 4,
GTK_FILL, 0, 0, 0);
/* Begin the fifth row */
horizSep1 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(statTable), horizSep1, 0, 8, 4, 5, GTK_FILL,
GTK_FILL, 0, 0);
/* Begin the sixth row */
hpLabel = gtk_label_new("HP: ");
gtk_table_attach(GTK_TABLE(statTable), hpLabel, 0, 1, 5, 6, GTK_FILL, 0,
0, 0);
acLabel = gtk_label_new("AC: ");
gtk_table_attach(GTK_TABLE(statTable), acLabel, 2, 3, 5, 6, GTK_FILL, 0,
0, 0);
powLabel = gtk_label_new("Power: ");
gtk_table_attach(GTK_TABLE(statTable), powLabel, 4, 5, 5, 6, GTK_FILL, 0,
0, 0);
goldLabel = gtk_label_new("Au: ");
gtk_table_attach(GTK_TABLE(statTable), goldLabel, 6, 7, 5, 6, GTK_FILL, 0,
0, 0);
/* Begin the seventh row */
horizSep2 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(statTable), horizSep2, 0, 8, 6, 7, GTK_FILL,
GTK_FILL, 0, 0);
/* Begin the eigth row */
levlLabel = gtk_label_new("Level: ");
gtk_table_attach(GTK_TABLE(statTable), levlLabel, 0, 1, 7, 8, GTK_FILL, 0,
0, 0);
expLabel = gtk_label_new("Exp: ");
gtk_table_attach(GTK_TABLE(statTable), expLabel, 2, 3, 7, 8, GTK_FILL, 0,
0, 0);
timeLabel = gtk_label_new("Time: ");
gtk_table_attach(GTK_TABLE(statTable), timeLabel, 4, 5, 7, 8, GTK_FILL, 0,
0, 0);
scoreLabel = gtk_label_new("Score: ");
gtk_table_attach(GTK_TABLE(statTable), scoreLabel, 6, 7, 7, 8, GTK_FILL,
0, 0, 0);
/* Begin the ninth row */
horizSep3 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(statTable), horizSep3, 0, 8, 8, 9, GTK_FILL,
GTK_FILL, 0, 0);
/* Begin the tenth and last row */
statHBox = gtk_hbox_new(FALSE, 0);
alignVBox = gtk_vbox_new(FALSE, 0);
alignPix = gnome_pixmap_new_from_xpm_d(neutral_xpm);
alignLabel = gtk_label_new("Neutral");
gtk_box_pack_start(GTK_BOX(alignVBox), alignPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(alignVBox), alignLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(alignVBox), TRUE, FALSE,
2);
hungerVBox = gtk_vbox_new(FALSE, 0);
hungerPix = gnome_pixmap_new_from_xpm_d(hungry_xpm);
hungerLabel = gtk_label_new("Hungry");
gtk_box_pack_start(GTK_BOX(hungerVBox), hungerPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(hungerVBox), hungerLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(hungerVBox), TRUE, FALSE,
2);
sickVBox = gtk_vbox_new(FALSE, 0);
sickPix = gnome_pixmap_new_from_xpm_d(sick_fp_xpm);
sickLabel = gtk_label_new("FoodPois");
gtk_box_pack_start(GTK_BOX(sickVBox), sickPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(sickVBox), sickLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(sickVBox), TRUE, FALSE,
2);
blindVBox = gtk_vbox_new(FALSE, 0);
blindPix = gnome_pixmap_new_from_xpm_d(blind_xpm);
blindLabel = gtk_label_new("Blind");
gtk_box_pack_start(GTK_BOX(blindVBox), blindPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(blindVBox), blindLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(blindVBox), TRUE, FALSE,
2);
stunVBox = gtk_vbox_new(FALSE, 0);
stunPix = gnome_pixmap_new_from_xpm_d(stunned_xpm);
stunLabel = gtk_label_new("Stun");
gtk_box_pack_start(GTK_BOX(stunVBox), stunPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(stunVBox), stunLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(stunVBox), TRUE, FALSE,
2);
confuVBox = gtk_vbox_new(FALSE, 0);
confuPix = gnome_pixmap_new_from_xpm_d(confused_xpm);
confuLabel = gtk_label_new("Confused");
gtk_box_pack_start(GTK_BOX(confuVBox), confuPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(confuVBox), confuLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(confuVBox), TRUE, FALSE,
2);
halluVBox = gtk_vbox_new(FALSE, 0);
halluPix = gnome_pixmap_new_from_xpm_d(hallu_xpm);
halluLabel = gtk_label_new("Hallu");
gtk_box_pack_start(GTK_BOX(halluVBox), halluPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(halluVBox), halluLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(halluVBox), TRUE, FALSE,
2);
encumbVBox = gtk_vbox_new(FALSE, 0);
encumbPix = gnome_pixmap_new_from_xpm_d(slt_enc_xpm);
encumbLabel = gtk_label_new("Burdened");
gtk_box_pack_start(GTK_BOX(encumbVBox), encumbPix, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(encumbVBox), encumbLabel, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(statHBox), GTK_WIDGET(encumbVBox), TRUE, FALSE,
2);
gtk_table_attach(GTK_TABLE(statTable), GTK_WIDGET(statHBox), 0, 8, 9, 10,
GTK_FILL, GTK_FILL, 0, 0);
/* Set up the necessary signals */
gtk_signal_connect(GTK_OBJECT(statTable), "ghack_fade_highlight",
GTK_SIGNAL_FUNC(ghack_fade_highlighting), NULL);
gtk_signal_connect(GTK_OBJECT(statTable), "ghack_putstr",
GTK_SIGNAL_FUNC(ghack_status_window_put_string), NULL);
gtk_signal_connect(GTK_OBJECT(statTable), "ghack_clear",
GTK_SIGNAL_FUNC(ghack_status_window_clear), NULL);
gtk_signal_connect(GTK_OBJECT(statTable), "ghack_curs",
GTK_SIGNAL_FUNC(ghack_status_window_cursor_to), NULL);
gtk_signal_connect(GTK_OBJECT(statTable), "gnome_delay_output",
GTK_SIGNAL_FUNC(ghack_delay), NULL);
/* Lastly, show the status window and everything in it */
gtk_widget_show_all(statTable);
return GTK_WIDGET(statTable);
}
