« back to all changes in this revision
Viewing changes to source/libmatrix.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Thomas Bushnell, BSG
- Date: 2005-01-10 11:52:04 UTC
- mfrom: (2.1.2 hoary)
- Revision ID: james.westby@ubuntu.com-20050110115204-hpgncw5pb0m1t8i6
Tags: 6.13-5
debian/control (malaga-doc Recommends): Suggest gv as a
postscript-viewer instead of ghostview. (Closes: #289701).
postscript-viewer instead of ghostview. (Closes: #289701).
- files added:
- COPYING.txt
- files removed:
- LICENSE.txt
- bin
- doc
- lib
- man
- man/man1
- source
- tcl
- files modified:
- CHANGES.txt
added
removed
source/libmatrix.c
1
/* This file is part of Malaga, a system for Natural Language Analysis.
2
* Copyright (C) 1995-1999 Bjoern Beutel
3
*
4
* Bjoern Beutel
5
* Universitaet Erlangen-Nuernberg
6
* Abteilung fuer Computerlinguistik
7
* Bismarckstrasse 12
8
* D-91054 Erlangen
9
* e-mail: malaga@linguistik.uni-erlangen.de
10
*
11
* This program is free software; you can redistribute it and/or modify
12
* it under the terms of the GNU General Public License as published by
13
* the Free Software Foundation; either version 2 of the License, or
14
* (at your option) any later version.
15
*
16
* This program is distributed in the hope that it will be useful,
17
* but WITHOUT ANY WARRANTY; without even the implied warranty of
18
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
* GNU General Public License for more details.
20
*
21
* You should have received a copy of the GNU General Public License
22
* along with this program; if not, write to the Free Software
23
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
24
25
/* description ==============================================================*/
26
27
/* This is a TCL/TK package that implements feature/value matrixes for
28
* canvas widgets. */
29
30
/* includes =================================================================*/
31
32
#include <stdio.h>
33
#include <stdlib.h>
34
#include <stdarg.h>
35
#include <setjmp.h>
36
#include <ctype.h>
37
#include <assert.h>
38
#include <math.h>
39
#include <X11/Xlib.h>
40
#include <tcl.h>
41
#include <tk.h>
42
#include "basic.h"
43
#include "scanner.h"
44
45
#undef GLOBAL
46
#define GLOBAL
47
48
#define HANGUL
49
50
/* constants ================================================================*/
51
52
#define VALUE_ERROR_STRING_LENGTH 256
53
54
#define RECORD_TOP_BORDER 3
55
#define RECORD_BOTTOM_BORDER 3
56
#define RECORD_LEFT_BORDER 6
57
#define RECORD_RIGHT_BORDER 6
58
#define LIST_TOP_BORDER 3
59
#define LIST_BOTTOM_BORDER 3
60
#define ANGLE_BRACKET_RATIO 6 /* height:width ratio of angle brackets */
61
#define POINT_SIZE_LEN 20
62
#define MAX_POINTS 4
63
64
#ifdef HANGUL
65
#define HANGUL_FONT "-*-mincho-medium-r-normal--*-*-*-*-c-*-ksc5601.1987-0"
66
#define BUFFER_SIZE 500
67
#endif
68
69
/* types ====================================================================*/
70
71
typedef enum /* type of a node in "matrix_value_t" */
72
{
73
STRING_TYPE,
74
RECORD_TYPE,
75
LIST_TYPE
76
} value_type_t;
77
78
typedef struct MATRIX_VALUE_T /* a Malaga value in TK */
79
{
80
value_type_t value_type; /* type of this node */
81
struct MATRIX_VALUE_T *first; /* first element if record or list */
82
struct MATRIX_VALUE_T *next; /* next element for record and list elements */
83
string_t attribute; /* attribute name (if record element) */
84
string_t string; /* string (for STRING_TYPE) */
85
int_t attribute_width; /* width of attribute */
86
int_t width; /* width of value box */
87
int_t height; /* height of value box */
88
} matrix_value_t;
89
90
typedef struct MATRIX_ITEM /* The structure defines a canvas item. */
91
{
92
Tk_Item header; /* generic stuff - MUST BE FIRST IN STRUCTURE! */
93
double x, y; /* positioning point for matrix: upper left */
94
GC gc; /* graphics context for lines and text */
95
short line_width; /* width of a brace line */
96
XColor *color; /* color for line and text */
97
string_t char_set; /* latin1 and hangul (KSC5601) are supported. */
98
#if TK_MAJOR_VERSION > 4
99
Tk_Font font; /* font for drawing text */
100
#else
101
XFontStruct *font; /* font for drawing text */
102
#endif
103
short ascent; /* ascent of <font> */
104
short line_height; /* height of a line in <font> */
105
short space_width; /* with of a space in <font> */
106
short comma_width; /* with of a comma in <font> */
107
matrix_value_t *root_value; /* value tree for matrix object */
108
#ifdef HANGUL
109
XFontStruct *hangul_font; /* font for drawing hangul characters */
110
#endif
111
} matrix_t;
112
113
/* variables ================================================================*/
114
115
LOCAL char value_error_string[VALUE_ERROR_STRING_LENGTH];
116
/* buffer for parse errors */
117
118
LOCAL bool_t parse_value_error;
119
LOCAL jmp_buf *parse_value_error_jump_point;
120
/* the current point of return in case of an error */
121
122
LOCAL Tk_CustomOption tagsOption =
123
{Tk_CanvasTagsParseProc, Tk_CanvasTagsPrintProc, (ClientData) NULL};
124
125
LOCAL Tk_ConfigSpec config_specs[] =
126
/* Information used for parsing configuration specs. If you change any
127
* of the default strings, be sure to change the corresponding default
128
* values in CreateMatrix. */
129
{
130
{TK_CONFIG_COLOR, "-fill", NULL, NULL,
131
"black", Tk_Offset (matrix_t, color), TK_CONFIG_NULL_OK},
132
{TK_CONFIG_PIXELS, "-line_width", NULL, NULL,
133
"1", Tk_Offset (matrix_t, line_width), TK_CONFIG_DONT_SET_DEFAULT},
134
{TK_CONFIG_STRING, "-char_set", NULL, NULL,
135
"latin1", Tk_Offset (matrix_t, char_set), 0},
136
{TK_CONFIG_FONT, "-font", NULL, NULL,
137
"-*-helvetica-medium-r-normal--14-*-75-75-p-*-iso8859-1",
138
Tk_Offset (matrix_t, font), 0},
139
{TK_CONFIG_CUSTOM, "-tags", NULL, NULL,
140
NULL, 0, TK_CONFIG_NULL_OK, &tagsOption},
141
{TK_CONFIG_END, NULL, NULL, NULL,
142
NULL, 0, 0}
143
};
144
145
#ifdef HANGUL
146
LOCAL XChar2b string16[BUFFER_SIZE]; /* buffer for converted KSC string */
147
LOCAL XFontStruct *hangul_font;
148
LOCAL int_t hangul_font_refs; /* number of references to <hangul_font> */
149
#endif
150
151
/* forward declarations =====================================================*/
152
153
FORWARD matrix_value_t *local_parse_value (void);
154
155
/* functions ================================================================*/
156
157
LOCAL void error_handler (string_t format, ...) NO_RETURN;
158
LOCAL void error_handler (string_t format, ...)
159
/* Manage syntax errors during parsing of Malaga value structures. */
160
{
161
va_list arg;
162
163
va_start (arg, format);
164
165
if (parse_value_error_jump_point != NULL)
166
{
167
vsprintf (value_error_string, format, arg);
168
va_end (arg);
169
170
parse_value_error = 1;
171
longjmp (*parse_value_error_jump_point, 1);
172
}
173
else
174
{
175
fflush (stdout);
176
fprintf (stderr, "error: ");
177
178
vfprintf (stderr, format, arg);
179
fputc ('\n', stderr);
180
181
va_end (arg);
182
exit (1);
183
}
184
}
185
186
/* parsing Malaga values ====================================================*/
187
188
LOCAL void free_value (matrix_value_t **value_ptr)
189
/* Free memory used by the tree. */
190
{
191
matrix_value_t *value, *next_value;
192
193
for (value = *value_ptr; value != NULL; value = next_value)
194
{
195
next_value = value->next;
196
free_value (&value->first);
197
free_mem (&value->attribute);
198
free_mem (&value->string);
199
free_mem (&value);
200
}
201
*value_ptr = NULL;
202
}
203
204
/*---------------------------------------------------------------------------*/
205
206
LOCAL string_t parse_symbol (void)
207
/* Parse a symbol and return it. */
208
{
209
string_t symbol;
210
211
test_token (TOK_IDENT);
212
symbol = new_string (token_name, NULL);
213
read_next_token ();
214
return symbol;
215
}
216
217
/*---------------------------------------------------------------------------*/
218
219
LOCAL matrix_value_t *parse_attribute_value_pair (void)
220
/* Parse an attribute-value pair and return a pointer to it. */
221
{
222
string_t attribute;
223
matrix_value_t *new_value;
224
225
if (next_token == '(') /* Read a hidden attribute. */
226
{
227
read_next_token ();
228
attribute = parse_symbol ();
229
parse_token (')');
230
new_value = new_mem (sizeof (matrix_value_t));
231
new_value->value_type = STRING_TYPE;
232
new_value->attribute = concat_strings (attribute, ":", NULL);
233
new_value->string = new_string ("...", NULL);
234
free_mem (&attribute);
235
}
236
else
237
{
238
attribute = parse_symbol ();
239
parse_token (':');
240
new_value = local_parse_value ();
241
new_value->attribute = concat_strings (attribute, ":", NULL);
242
free_mem (&attribute);
243
}
244
return new_value;
245
}
246
247
/*---------------------------------------------------------------------------*/
248
249
LOCAL matrix_value_t *local_parse_value (void)
250
/* Parse a value and return it as a "matrix_value". */
251
{
252
matrix_value_t *new_value_ptr;
253
254
/* pointer to last list or record element */
255
matrix_value_t *element_ptr;
256
257
new_value_ptr = new_mem (sizeof (matrix_value_t));
258
259
switch (next_token)
260
{
261
case '<':
262
new_value_ptr->value_type = LIST_TYPE;
263
read_next_token ();
264
if (next_token != '>') /* Insert "new_value" as first list element. */
265
{
266
new_value_ptr->first = local_parse_value ();
267
element_ptr = new_value_ptr->first;
268
269
while (next_token == ',')
270
{
271
read_next_token ();
272
273
/* Insert "new_value" as successor element. */
274
element_ptr->next = local_parse_value ();
275
element_ptr = element_ptr->next;
276
}
277
}
278
parse_token ('>');
279
break;
280
281
case '[':
282
new_value_ptr->value_type = RECORD_TYPE;
283
read_next_token ();
284
if (next_token != ']')
285
{
286
new_value_ptr->first = parse_attribute_value_pair ();
287
element_ptr = new_value_ptr->first;
288
while (next_token == ',')
289
{
290
read_next_token ();
291
element_ptr->next = parse_attribute_value_pair ();
292
element_ptr = element_ptr->next;
293
}
294
}
295
parse_token (']');
296
break;
297
298
case TOK_IDENT:
299
new_value_ptr->value_type = STRING_TYPE;
300
new_value_ptr->string = parse_symbol ();
301
break;
302
303
case TOK_STRING:
304
new_value_ptr->value_type = STRING_TYPE;
305
new_value_ptr->string = concat_strings ("\"", token_string, "\"", NULL);
306
read_next_token ();
307
break;
308
309
case TOK_NUMBER:
310
new_value_ptr->value_type = STRING_TYPE;
311
new_value_ptr->string = double_to_string (token_number);
312
read_next_token ();
313
break;
314
315
default:
316
error ("value expected, not `%s'", token_as_text (next_token));
317
}
318
return new_value_ptr;
319
}
320
321
/*---------------------------------------------------------------------------*/
322
323
LOCAL matrix_value_t *build_value_tree (string_t string_value)
324
/* Parse Malaga value "*string_value" and return it as a "matrix_value". */
325
{
326
/* where to jump after an error */
327
static jmp_buf local_parse_error_jump_point;
328
matrix_value_t *first_value;
329
330
first_value = NULL;
331
setjmp (local_parse_error_jump_point);
332
parse_value_error_jump_point = &local_parse_error_jump_point;
333
334
if (parse_value_error)
335
{
336
free_value (&first_value);
337
parse_value_error_jump_point = NULL;
338
parse_value_error = FALSE;
339
return NULL;
340
}
341
342
set_scanner_input ((string_t) string_value);
343
if (next_token == '!') /* Enter a string without quotes. */
344
{
345
read_next_token ();
346
test_token (TOK_STRING);
347
first_value = new_mem (sizeof (matrix_value_t));
348
first_value->value_type = STRING_TYPE;
349
first_value->string = new_string (token_string, NULL);
350
read_next_token ();
351
}
352
else
353
first_value = local_parse_value ();
354
355
/* Allow an additional ';'. */
356
if (next_token == ';')
357
read_next_token ();
358
359
test_token (EOF);
360
parse_value_error_jump_point = NULL;
361
362
return first_value;
363
}
364
365
/* displaying Malaga values =================================================*/
366
367
#ifdef HANGUL
368
LOCAL int_t string_to_string16 (string_t string)
369
/* Convert <string> to <string16> and return its length. */
370
{
371
int_t n;
372
373
for (n = 0; n < BUFFER_SIZE; n++)
374
{
375
if (ORD (string[0]) < 0xa0 || ORD (string[1]) < 0xa0)
376
break;
377
378
/* Convert KSC5601 character. */
379
string16[n].byte1 = ORD (string[0]) & 0x7f;
380
string16[n].byte2 = ORD (string[1]) & 0x7f;
381
string += 2;
382
}
383
return n;
384
}
385
#endif
386
387
/*---------------------------------------------------------------------------*/
388
389
LOCAL int_t string_width (matrix_t *matrix, string_t string)
390
/* Return width of <string> in pixels when displayed as part of <matrix>. */
391
{
392
393
#ifdef HANGUL
394
if (matrix->hangul_font != NULL)
395
{
396
int_t n, width;
397
398
width = 0;
399
while (*string != EOS)
400
{ /* Add width of a Hangul segment. */
401
402
n = string_to_string16 (string);
403
string += 2 * n;
404
if (n > 0)
405
width += XTextWidth16 (matrix->hangul_font, string16, n);
406
407
/* Add width of an ASCII segment. */
408
n = 0;
409
while (*string != EOS
410
&& (ORD (string[0]) < 0xa0 || ORD (string[1]) < 0xa0))
411
{
412
string++;
413
n++;
414
}
415
if (n > 0)
416
{
417
#if TK_MAJOR_VERSION > 4
418
width += Tk_TextWidth (matrix->font, string - n, n);
419
#else
420
width += XTextWidth (matrix->font, string - n, n);
421
#endif
422
}
423
}
424
return width;
425
}
426
#endif
427
428
#if TK_MAJOR_VERSION > 4
429
return Tk_TextWidth (matrix->font, string, strlen (string));
430
#else
431
return XTextWidth (matrix->font, string, strlen (string));
432
#endif
433
}
434
435
/*---------------------------------------------------------------------------*/
436
437
LOCAL void draw_string (Display *display,
438
Drawable drawable,
439
matrix_t *matrix,
440
int_t origin_x,
441
int_t origin_y,
442
string_t string)
443
/* Draw a string as part of a value matrix. */
444
{
445
origin_y += matrix->ascent;
446
447
#ifdef HANGUL
448
if (matrix->hangul_font != NULL)
449
/* Hangul KSC5601 section - show hangul characters in Hangul font.
450
* All other characters are shown in normal font. */
451
{
452
int_t n;
453
454
while (*string != '\0')
455
{
456
/* Display a Hangul segment. */
457
n = string_to_string16 (string);
458
string += 2 * n;
459
if (n > 0)
460
{
461
XSetFont (display, matrix->gc, matrix->hangul_font->fid);
462
XDrawString16 (display, drawable, matrix->gc,
463
origin_x, origin_y, string16, n);
464
origin_x += XTextWidth16 (matrix->hangul_font, string16, n);
465
}
466
467
/* Print an ASCII segment. */
468
n = 0;
469
while (*string != EOS
470
&& (ORD (string[0]) < 0xa0 || ORD (string[1]) < 0xa0))
471
{
472
string++;
473
n++;
474
}
475
if (n > 0)
476
{
477
#if TK_MAJOR_VERSION > 4
478
XSetFont (display, matrix->gc, Tk_FontId (matrix->font));
479
Tk_DrawChars (display, drawable, matrix->gc, matrix->font,
480
string - n, n, origin_x, origin_y);
481
origin_x += Tk_TextWidth (matrix->font, string - n, n);
482
#else
483
XSetFont (display, matrix->gc, matrix->font->fid);
484
XDrawString (display, drawable, matrix->gc, origin_x, origin_y,
485
string - n, n);
486
origin_x += XTextWidth (matrix->font, string - n, n);
487
#endif
488
}
489
}
490
return;
491
}
492
#endif
493
494
/* Display Latin1 string. */
495
#if TK_MAJOR_VERSION > 4
496
Tk_DrawChars (display, drawable, matrix->gc, matrix->font,
497
string, strlen (string), origin_x, origin_y);
498
#else
499
XDrawString (display, drawable, matrix->gc, origin_x, origin_y,
500
string, strlen (string));
501
#endif
502
}
503
504
/*---------------------------------------------------------------------------*/
505
506
LOCAL int_t max_attribute_width (matrix_value_t *value)
507
/* Compute maximum attribute width of a record. */
508
{
509
matrix_value_t *element;
510
int_t max_length = 0;
511
512
for (element = value->first; element != NULL; element = element->next)
513
max_length = MAX (max_length, element->attribute_width);
514
return max_length;
515
}
516
517
/*---------------------------------------------------------------------------*/
518
519
LOCAL void compute_value_bounding_box (matrix_t *matrix,
520
matrix_value_t *value)
521
/* Compute the coordinates of matrix value <value> in <matrix> */
522
{
523
matrix_value_t *element;
524
525
if (value->attribute != NULL)
526
value->attribute_width = string_width (matrix, value->attribute);
527
528
switch (value->value_type)
529
{
530
case RECORD_TYPE:
531
{
532
int_t max_attrib_width, max_element_width;
533
534
value->height = 0;
535
max_attrib_width = 0;
536
max_element_width = 0;
537
for (element = value->first; element != NULL; element = element->next)
538
{
539
compute_value_bounding_box (matrix, element);
540
max_attrib_width = MAX (max_attrib_width, element->attribute_width);
541
max_element_width = MAX (max_element_width, element->width);
542
value->height += element->height;
543
}
544
545
value->height = (RECORD_TOP_BORDER
546
+ MAX (value->height, matrix->line_height)
547
+ RECORD_BOTTOM_BORDER);
548
value->width = (RECORD_LEFT_BORDER + max_attrib_width
549
+ matrix->space_width + max_element_width
550
+ RECORD_RIGHT_BORDER);
551
break;
552
}
553
554
case LIST_TYPE:
555
{
556
int_t max_element_height;
557
558
value->width = 2;
559
max_element_height = matrix->line_height;
560
for (element = value->first; element != NULL; element = element->next)
561
{
562
compute_value_bounding_box (matrix, element);
563
564
max_element_height = MAX (max_element_height, element->height);
565
value->width += element->width;
566
if (element->next != NULL)
567
value->width += (matrix->comma_width + matrix->space_width);
568
}
569
value->width += 2;
570
571
value->height = (LIST_TOP_BORDER + max_element_height
572
+ LIST_BOTTOM_BORDER);
573
value->width += 2 * (value->height / ANGLE_BRACKET_RATIO);
574
break;
575
}
576
577
case STRING_TYPE:
578
value->width = string_width (matrix, value->string);
579
value->height = matrix->line_height;
580
break;
581
582
default:
583
error ("unexpected node type");
584
}
585
}
586
587
/*---------------------------------------------------------------------------*/
588
589
LOCAL void compute_matrix_bounding_box (matrix_t *matrix)
590
/* Compute the bounding box of all the pixels that may be
591
* drawn as part of matrix <matrix>. */
592
{
593
compute_value_bounding_box (matrix, matrix->root_value);
594
matrix->header.x1 = (int) matrix->x ;
595
matrix->header.y1 = (int) matrix->y;
596
matrix->header.x2 = (int) (matrix->x + matrix->root_value->width);
597
matrix->header.y2 = (int) (matrix->y + matrix->root_value->height);
598
}
599
600
/*---------------------------------------------------------------------------*/
601
602
LOCAL int configure_matrix (Tcl_Interp *interp,
603
Tk_Canvas canvas,
604
Tk_Item *item,
605
int argc,
606
string_t argv[],
607
int flags)
608
/* Configure various aspects of matrix <item>. */
609
{
610
matrix_t *matrix = (matrix_t *) item;
611
XGCValues gc_values;
612
GC new_gc;
613
u_int_t mask;
614
Tk_Window tk_window = Tk_CanvasTkwin (canvas);
615
616
if (Tk_ConfigureWidget (interp, tk_window, config_specs,
617
argc, argv, (char *) matrix, flags) != TCL_OK)
618
return TCL_ERROR;
619
620
#ifdef HANGUL
621
if ((strcmp (matrix->char_set, "latin1") != 0) &&
622
(strcmp (matrix->char_set, "hangul") != 0))
623
{
624
Tcl_AppendResult (interp, "for matrix widget, option \"-char_set\" "
625
"should be \"latin1\" or \"hangul\"", NULL);
626
return TCL_ERROR;
627
}
628
629
if (strcmp (matrix->char_set, "hangul") == 0 && matrix->hangul_font == NULL)
630
{
631
if (hangul_font == NULL)
632
hangul_font = XLoadQueryFont (Tk_Display (tk_window), HANGUL_FONT);
633
if (hangul_font == NULL)
634
{
635
Tcl_AppendResult (interp, "can't load hangul font for matrix widget");
636
return TCL_ERROR;
637
}
638
639
matrix->hangul_font = hangul_font;
640
hangul_font_refs++;
641
}
642
else if (strcmp (matrix->char_set, "hangul") != 0
643
&& matrix->hangul_font != NULL)
644
{
645
matrix->hangul_font = NULL;
646
hangul_font_refs--;
647
}
648
#endif
649
650
new_gc = None;
651
if (matrix->color != NULL && matrix->font != NULL)
652
{
653
gc_values.foreground = matrix->color->pixel;
654
#if TK_MAJOR_VERSION > 4
655
gc_values.font = Tk_FontId (matrix->font);
656
#else
657
gc_values.font = matrix->font->fid;
658
#endif
659
mask = GCForeground|GCFont;
660
new_gc = Tk_GetGC (tk_window, mask, &gc_values);
661
662
#if TK_MAJOR_VERSION > 4
663
{
664
Tk_FontMetrics font_metrics;
665
666
Tk_GetFontMetrics (matrix->font, &font_metrics);
667
matrix->ascent = font_metrics.ascent;
668
matrix->line_height = (font_metrics.ascent + font_metrics.descent);
669
matrix->space_width = Tk_TextWidth (matrix->font, " ", 1);
670
matrix->comma_width = Tk_TextWidth (matrix->font, ",", 1);
671
}
672
#else
673
matrix->ascent = matrix->font->ascent;
674
matrix->line_height = (matrix->font->ascent + matrix->font->descent);
675
matrix->space_width = XTextWidth (matrix->font, " ", 1);
676
matrix->comma_width = XTextWidth (matrix->font, ",", 1);
677
#endif
678
}
679
680
if (matrix->gc != None)
681
Tk_FreeGC (Tk_Display (tk_window), matrix->gc);
682
683
matrix->gc = new_gc;
684
685
compute_matrix_bounding_box (matrix);
686
687
return TCL_OK;
688
}
689
690
/*---------------------------------------------------------------------------*/
691
692
LOCAL void delete_matrix (Tk_Canvas canvas, Tk_Item *item, Display *display)
693
/* Delete Matrix <item>. */
694
{
695
matrix_t *matrix = (matrix_t *) item;
696
697
if (matrix->root_value != NULL)
698
free_value (&matrix->root_value);
699
700
if (matrix->color != NULL)
701
Tk_FreeColor (matrix->color);
702
703
if (matrix->gc != None)
704
Tk_FreeGC (display, matrix->gc);
705
706
if (matrix->font != NULL)
707
#if TK_MAJOR_VERSION > 4
708
Tk_FreeFont (matrix->font);
709
#else
710
Tk_FreeFontStruct (matrix->font);
711
#endif
712
713
#ifdef HANGUL
714
if (matrix->hangul_font != NULL)
715
{
716
matrix->hangul_font = NULL;
717
hangul_font_refs--;
718
}
719
720
if (hangul_font != NULL && hangul_font_refs == 0)
721
{
722
XFreeFont (display, hangul_font);
723
hangul_font = NULL;
724
}
725
#endif
726
}
727
728
/*---------------------------------------------------------------------------*/
729
730
LOCAL int create_matrix (Tcl_Interp *interp,
731
Tk_Canvas canvas,
732
Tk_Item *item,
733
int argc,
734
string_t argv[])
735
/* Create a new matrix item in a canvas. */
736
{
737
matrix_t *matrix = (matrix_t *) item;
738
739
if (argc < 3)
740
{
741
Tcl_AppendResult (interp, "wrong # args: should be \"",
742
Tk_PathName (Tk_CanvasTkwin (canvas)), "\" create ",
743
item->typePtr->name, " x1 y1 value ?options?",
744
NULL);
745
return TCL_ERROR;
746
}
747
748
/* Carry out initialisation that is needed to set defaults and to
749
* allow proper cleanup after errors during the the remainder of
750
* this procedure. */
751
752
/* Process the arguments to fill in the item record. */
753
if (Tk_CanvasGetCoord (interp, canvas, argv[0], &matrix->x) != TCL_OK
754
|| Tk_CanvasGetCoord (interp, canvas, argv[1], &matrix->y) != TCL_OK)
755
return TCL_ERROR;
756
757
matrix->gc = None;
758
matrix->color = None;
759
matrix->line_width = 1;
760
matrix->font = NULL;
761
matrix->char_set = NULL;
762
matrix->line_height = 0;
763
matrix->space_width = 0;
764
matrix->comma_width = 0;
765
matrix->root_value = NULL;
766
parse_value_error_jump_point = NULL;
767
parse_value_error = 0;
768
#ifdef HANGUL
769
matrix->hangul_font = NULL;
770
#endif
771
772
matrix->root_value = build_value_tree (argv[2]);
773
if (matrix->root_value == NULL)
774
{
775
Tcl_AppendResult (interp, value_error_string, (char *) NULL);
776
return TCL_ERROR;
777
}
778
779
if (argc > 3)
780
{
781
if (configure_matrix (interp, canvas, item, argc-3, argv+3, 0) != TCL_OK)
782
{
783
/*delete_matrix (canvas, item, Tk_Display (Tk_CanvasTkwin (canvas))); */
784
return TCL_ERROR;
785
}
786
}
787
788
return TCL_OK;
789
}
790
791
/*---------------------------------------------------------------------------*/
792
793
LOCAL int matrix_coords (Tcl_Interp *interp,
794
Tk_Canvas canvas,
795
Tk_Item *item,
796
int argc,
797
string_t argv[])
798
/* Implement "coords" widget command on matrices. */
799
{
800
matrix_t *matrix = (matrix_t *) item;
801
char x[TCL_DOUBLE_SPACE], y[TCL_DOUBLE_SPACE];
802
803
if (argc == 0)
804
{
805
Tcl_PrintDouble (interp, matrix->x, x);
806
Tcl_PrintDouble (interp, matrix->y, y);
807
Tcl_AppendResult (interp, x, " ", y, (char *) NULL);
808
}
809
else if (argc == 2)
810
{
811
if (Tk_CanvasGetCoord (interp, canvas, argv[0], &matrix->x) != TCL_OK
812
|| Tk_CanvasGetCoord (interp, canvas, argv[1], &matrix->y) != TCL_OK)
813
return TCL_ERROR;
814
815
compute_matrix_bounding_box (matrix);
816
}
817
else
818
{
819
sprintf (interp->result,
820
"wrong # coordinates: expected 0 or 2, got %d", argc);
821
return TCL_ERROR;
822
}
823
return TCL_OK;
824
}
825
826
/*---------------------------------------------------------------------------*/
827
828
LOCAL void display_value (Display *display,
829
matrix_t *matrix,
830
Drawable drawable,
831
matrix_value_t *value,
832
int_t origin_x,
833
int_t origin_y,
834
int_t x,
835
int_t y,
836
int_t width,
837
int_t height)
838
/* Draw a matrix value in a given drawable. */
839
{
840
matrix_value_t *element;
841
XPoint points[MAX_POINTS];
842
int_t element_origin_x, element_origin_y, element_bottom;
843
844
/* If (sub)value is out of bounds, no need to draw it. */
845
if (origin_x >= x + width || origin_y >= y + height
846
|| origin_x + value->width <= x || origin_y + value->height <= y)
847
return;
848
849
switch (value->value_type)
850
{
851
case RECORD_TYPE:
852
points[0].x = origin_x + RECORD_LEFT_BORDER - 1;
853
points[0].y = origin_y + 1;
854
855
points[1].x = origin_x + 1;
856
points[1].y = origin_y + 1;
857
858
points[2].x = origin_x + 1;
859
points[2].y = origin_y + value->height - 2;
860
861
points[3].x = origin_x + RECORD_LEFT_BORDER - 1;
862
points[3].y = origin_y + value->height - 2;
863
864
XDrawLines (display, drawable, matrix->gc, points, 4, CoordModeOrigin);
865
866
points[0].x = origin_x + value->width - RECORD_RIGHT_BORDER;
867
points[0].y = origin_y + 1;
868
869
points[1].x = origin_x + value->width - 2;
870
points[1].y = origin_y + 1;
871
872
points[2].x = origin_x + value->width - 2;
873
points[2].y = origin_y + value->height - 2;
874
875
points[3].x = origin_x + value->width - RECORD_RIGHT_BORDER;
876
points[3].y = origin_y + value->height - 2;
877
878
XDrawLines (display, drawable, matrix->gc, points, 4, CoordModeOrigin);
879
880
element_origin_x = (origin_x + RECORD_LEFT_BORDER +
881
max_attribute_width (value) + matrix->space_width);
882
element_origin_y = origin_y + RECORD_TOP_BORDER;
883
884
for (element = value->first; element != NULL; element = element->next)
885
{
886
draw_string (display, drawable, matrix,
887
origin_x + RECORD_LEFT_BORDER,
888
element_origin_y
889
+ (element->height - matrix->line_height) / 2,
890
element->attribute);
891
892
display_value (display, matrix, drawable, element,
893
element_origin_x, element_origin_y, x, y, width, height);
894
element_origin_y += element->height;
895
}
896
break;
897
898
case LIST_TYPE:
899
{
900
int_t angle_bracket_width = value->height / ANGLE_BRACKET_RATIO;
901
902
points[0].x = origin_x + angle_bracket_width;
903
points[0].y = origin_y + 1;
904
905
points[1].x = origin_x + 1;
906
points[1].y = origin_y + value->height / 2;
907
908
points[2].x = origin_x + angle_bracket_width;
909
points[2].y = origin_y + value->height - 2;
910
911
XDrawLines (display, drawable, matrix->gc, points, 3, CoordModeOrigin);
912
913
points[0].x = origin_x + value->width - angle_bracket_width - 1;
914
points[0].y = origin_y + 1;
915
916
points[1].x = origin_x + value->width - 2;
917
points[1].y = origin_y + value->height / 2;
918
919
points[2].x = origin_x + value->width - angle_bracket_width - 1;
920
points[2].y = origin_y + value->height - 2;
921
922
XDrawLines (display, drawable, matrix->gc, points, 3, CoordModeOrigin);
923
924
element_origin_x = origin_x + angle_bracket_width + 2;
925
element_bottom = origin_y + value->height - LIST_BOTTOM_BORDER;
926
927
for (element = value->first; element != NULL; element = element->next)
928
{
929
display_value (display, matrix, drawable, element,
930
element_origin_x, element_bottom - element->height,
931
x, y, width, height);
932
element_origin_x += element->width;
933
934
if (element->next != NULL)
935
{
936
draw_string (display, drawable, matrix, element_origin_x,
937
element_bottom - matrix->line_height, ",");
938
element_origin_x += (matrix->comma_width + matrix->space_width);
939
}
940
}
941
break;
942
}
943
944
case STRING_TYPE:
945
draw_string (display, drawable, matrix, origin_x, origin_y, value->string);
946
break;
947
948
default:
949
error ("unexpected node type");
950
}
951
}
952
953
/*---------------------------------------------------------------------------*/
954
955
LOCAL void display_matrix (Tk_Canvas canvas,
956
Tk_Item *item,
957
Display *display,
958
Drawable drawable,
959
int x,
960
int y,
961
int width,
962
int height)
963
/* Draw a matrix in a given drawable. */
964
{
965
matrix_t *matrix = (matrix_t *) item;
966
short origin_x, origin_y;
967
968
Tk_CanvasDrawableCoords (canvas, matrix->x, matrix->y,
969
&origin_x, &origin_y);
970
display_value (display, matrix, drawable, matrix->root_value,
971
origin_x, origin_y,
972
x + origin_x - matrix->x, y + origin_y - matrix->y,
973
width, height);
974
}
975
976
/*---------------------------------------------------------------------------*/
977
978
LOCAL double matrix_to_point (Tk_Canvas canvas, Tk_Item *item, double point[])
979
/* Return the distance between the point (<point>[0], <point>[1])
980
* and the matrix <item>. If the point is inside, return 0. */
981
{
982
matrix_t *matrix = (matrix_t *) item;
983
double diff_x, diff_y;
984
985
if (point[0] < matrix->header.x1)
986
diff_x = matrix->header.x1 - point[0];
987
else if (point[0] > matrix->header.x2)
988
diff_x = point[0] - matrix->header.x1;
989
else
990
diff_x = 0;
991
992
if (point[1] < matrix->header.y1)
993
diff_y = matrix->header.y1 - point[1];
994
else if (point[1] > matrix->header.y2)
995
diff_y = point[1] - matrix->header.y1;
996
else
997
diff_y = 0;
998
999
1000
return sqrt (diff_x * diff_x + diff_y * diff_y);
1001
}
1002
1003
/*---------------------------------------------------------------------------*/
1004
1005
LOCAL int matrix_to_area (Tk_Canvas canvas, Tk_Item *item, double rect[])
1006
/* Return -1 if <item> lies entirely outside <rect>,
1007
* 0 if it overlaps, and 1 if it is entirely inside. */
1008
{
1009
matrix_t *matrix = (matrix_t *) item;
1010
1011
if (matrix->header.x2 < rect[0] ||
1012
matrix->header.x1 > rect[2] ||
1013
matrix->header.y2 < rect[1] ||
1014
matrix->header.y1 > rect[3])
1015
return -1;
1016
1017
if (matrix->header.x1 >= rect[0] &&
1018
matrix->header.x2 <= rect[2] &&
1019
matrix->header.y1 >= rect[1] &&
1020
matrix->header.y2 <= rect[3])
1021
return 1;
1022
1023
return 0;
1024
}
1025
1026
/*---------------------------------------------------------------------------*/
1027
1028
LOCAL void scale_matrix (Tk_Canvas canvas,
1029
Tk_Item *item,
1030
double origin_x,
1031
double origin_y,
1032
double scale_x,
1033
double scale_y)
1034
/* Rescale a matrix item. */
1035
{
1036
/* matrices can't be scaled */
1037
}
1038
1039
/*---------------------------------------------------------------------------*/
1040
1041
LOCAL void translate_matrix (Tk_Canvas canvas,
1042
Tk_Item *item,
1043
double delta_x,
1044
double delta_y)
1045
/* Move matrix <item> by <delta_x> and <delta_y>. */
1046
{
1047
matrix_t *matrix = (matrix_t *) item;
1048
1049
matrix->x += delta_x;
1050
matrix->y += delta_y;
1051
1052
matrix->header.x1 = (int) matrix->x;
1053
matrix->header.y1 = (int) matrix->y;
1054
matrix->header.x2 = (int) (matrix->x + matrix->root_value->width);
1055
matrix->header.y2 = (int) (matrix->y + matrix->root_value->height);
1056
}
1057
1058
/*---------------------------------------------------------------------------*/
1059
1060
LOCAL void line_to_ps (Tcl_Interp *interp,
1061
Tk_Canvas canvas,
1062
matrix_t *matrix,
1063
double *points,
1064
int_t num_of_points)
1065
/* Print line in postscript format. */
1066
{
1067
char buffer[30];
1068
1069
Tk_CanvasPsPath (interp, canvas, points, num_of_points);
1070
sprintf (buffer, "%d setlinewidth\n", matrix->line_width);
1071
Tcl_AppendResult (interp, buffer, NULL);
1072
Tcl_AppendResult (interp, "stroke\n", NULL);
1073
}
1074
1075
/*---------------------------------------------------------------------------*/
1076
1077
LOCAL void string_to_ps (Tcl_Interp *interp,
1078
Tk_Canvas canvas,
1079
matrix_t *matrix,
1080
string_t string,
1081
int_t origin_x,
1082
int_t origin_y)
1083
/* Print <string> in postscript format at <origin_x>/<origin_y>. */
1084
{
1085
char buffer[60];
1086
char *s;
1087
1088
sprintf (buffer, "%.15g %.15g moveto ",
1089
(double) origin_x,
1090
Tk_CanvasPsY (canvas, (double) origin_y + matrix->ascent));
1091
Tcl_AppendResult (interp, buffer, NULL);
1092
1093
sprintf (buffer, "(");
1094
for (s = string; *s != EOS; s++)
1095
{
1096
if (*s == '(' || *s == ')' || *s == '\\')
1097
sprintf (buffer, "\\%c", *s);
1098
else
1099
sprintf (buffer, "%c", *s);
1100
}
1101
1102
sprintf (buffer, "(%s) show\n", string);
1103
Tcl_AppendResult (interp, buffer, NULL);
1104
}
1105
1106
/*---------------------------------------------------------------------------*/
1107
1108
LOCAL void value_to_postscript (Tcl_Interp *interp,
1109
Tk_Canvas canvas,
1110
matrix_t *matrix,
1111
matrix_value_t *value,
1112
int_t origin_x,
1113
int_t origin_y)
1114
/* Generate Postscript code for a value. */
1115
{
1116
matrix_value_t *element;
1117
double points[2 * MAX_POINTS];
1118
int_t element_origin_x, element_origin_y, element_bottom;
1119
1120
switch (value->value_type)
1121
{
1122
case RECORD_TYPE:
1123
points[0] = origin_x + RECORD_LEFT_BORDER - 1;
1124
points[1] = origin_y + 1;
1125
1126
points[2] = origin_x + 1;
1127
points[3] = origin_y + 1;
1128
1129
points[4] = origin_x + 1;
1130
points[5] = origin_y + value->height - 2;
1131
1132
points[6] = origin_x + RECORD_LEFT_BORDER - 1;
1133
points[7] = origin_y + value->height - 2;
1134
1135
line_to_ps (interp, canvas, matrix, points, 4);
1136
1137
points[0] = origin_x + value->width - RECORD_RIGHT_BORDER;
1138
points[1] = origin_y + 1;
1139
1140
points[2] = origin_x + value->width - 2;
1141
points[3] = origin_y + 1;
1142
1143
points[4] = origin_x + value->width - 2;
1144
points[5] = origin_y + value->height - 2;
1145
1146
points[6] = origin_x + value->width - RECORD_RIGHT_BORDER;
1147
points[7] = origin_y + value->height - 2;
1148
1149
line_to_ps (interp, canvas, matrix, points, 4);
1150
1151
element_origin_x = (origin_x + RECORD_LEFT_BORDER
1152
+ max_attribute_width (value) + matrix->space_width);
1153
element_origin_y = origin_y + RECORD_TOP_BORDER;
1154
1155
for (element = value->first; element != NULL; element = element->next)
1156
{
1157
string_to_ps (interp, canvas, matrix,
1158
element->attribute,
1159
origin_x + RECORD_LEFT_BORDER,
1160
element_origin_y
1161
+ (element->height - matrix->line_height)/2);
1162
1163
value_to_postscript (interp, canvas, matrix, element,
1164
element_origin_x, element_origin_y);
1165
1166
element_origin_y += element->height;
1167
}
1168
break;
1169
1170
case LIST_TYPE:
1171
{
1172
int_t angle_bracket_width = value->height / ANGLE_BRACKET_RATIO;
1173
1174
points[0] = origin_x + angle_bracket_width;
1175
points[1] = origin_y + 1;
1176
1177
points[2] = origin_x + 1;
1178
points[3] = origin_y + value->height / 2;
1179
1180
points[4] = origin_x + angle_bracket_width;
1181
points[5] = origin_y + value->height - 2;
1182
1183
line_to_ps (interp, canvas, matrix, points, 3);
1184
1185
points[0] = origin_x + value->width - angle_bracket_width-1;
1186
points[1] = origin_y + 1;
1187
1188
points[2] = origin_x + value->width - 2;
1189
points[3] = origin_y + value->height / 2;
1190
1191
points[4] = origin_x + value->width - angle_bracket_width-1;
1192
points[5] = origin_y + value->height - 2;
1193
1194
line_to_ps (interp, canvas, matrix, points, 3);
1195
1196
element_origin_x = origin_x + angle_bracket_width + 2;
1197
element_bottom = origin_y + value->height - LIST_BOTTOM_BORDER;
1198
1199
for (element = value->first; element != NULL; element = element->next)
1200
{
1201
value_to_postscript (interp, canvas, matrix, element,
1202
element_origin_x, element_bottom - element->height);
1203
1204
element_origin_x += element->width;
1205
1206
if (element->next != NULL)
1207
{
1208
string_to_ps (interp, canvas, matrix, ",",
1209
element_origin_x, element_bottom - matrix->line_height);
1210
element_origin_x += (matrix->comma_width + matrix->space_width);
1211
}
1212
}
1213
break;
1214
}
1215
1216
case STRING_TYPE:
1217
string_to_ps (interp, canvas, matrix, value->string, origin_x, origin_y);
1218
break;
1219
1220
default:
1221
error ("unexpected node type");
1222
}
1223
}
1224
1225
/*---------------------------------------------------------------------------*/
1226
1227
LOCAL int matrix_to_postscript (Tcl_Interp *interp,
1228
Tk_Canvas canvas,
1229
Tk_Item *item,
1230
int prepass)
1231
/* Generate Postscript code for a matrix. */
1232
{
1233
matrix_t *matrix = (matrix_t *) item;
1234
1235
if (prepass)
1236
return TCL_OK;
1237
1238
if (matrix->color == NULL)
1239
return TCL_OK;
1240
1241
if (Tk_CanvasPsFont (interp, canvas, matrix->font) != TCL_OK)
1242
return TCL_ERROR;
1243
1244
if (Tk_CanvasPsColor (interp, canvas, matrix->color) != TCL_OK)
1245
return TCL_ERROR;
1246
1247
value_to_postscript (interp, canvas, matrix, matrix->root_value,
1248
matrix->header.x1, matrix->header.y1);
1249
1250
return TCL_OK;
1251
}
1252
1253
/*---------------------------------------------------------------------------*/
1254
1255
/* procedures of matrix item type that can be invoked by generic item code */
1256
Tk_ItemType matrix_type =
1257
{
1258
"matrix", /* name */
1259
sizeof (matrix_t), /* itemSize */
1260
create_matrix, /* createProc */
1261
config_specs, /* configSpecs */
1262
configure_matrix, /* configureProc */
1263
matrix_coords, /* coordProc */
1264
delete_matrix, /* deleteProc */
1265
display_matrix, /* displayProc */
1266
0, /* alwaysRedraw */
1267
matrix_to_point, /* pointProc */
1268
matrix_to_area, /* areaProc */
1269
matrix_to_postscript, /* postscriptProc */
1270
scale_matrix, /* scaleProc */
1271
translate_matrix, /* translateProc */
1272
(Tk_ItemIndexProc *) NULL, /* indexProc */
1273
(Tk_ItemCursorProc *) NULL, /* icursorProc */
1274
(Tk_ItemSelectionProc *) NULL, /* selectionProc */
1275
(Tk_ItemInsertProc *) NULL, /* insertProc */
1276
(Tk_ItemDCharsProc *) NULL, /* dTextProc */
1277
(Tk_ItemType *) NULL /* nextPtr */
1278
};
1279
1280
/*---------------------------------------------------------------------------*/
1281
1282
int Matrix_Init (Tcl_Interp *interp)
1283
/* Initialise the package. */
1284
{
1285
/* Install error handler. */
1286
error = error_handler;
1287
1288
/* Insert <matrix_type> into the type list. */
1289
Tk_CreateItemType (&matrix_type);
1290
1291
return TCL_OK;
1292
}
1293
1294
/* end of file ==============================================================*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.1