Context Navigation

source: branches/r9/packages/DiffView/RpDiffview.c @ 4841

Last change on this file since 4841 was 4841, checked in by gah, 9 years ago

File size: 97.0 KB

Line
1	/*
2	* ----------------------------------------------------------------------
3	* RpDiffview - like a textbox, but for showing diffs
4	*
5	* Loads two strings, performs a diff, and shows the results. Use
6	* it as follows:
7	*
8	* Rappture::Diffview .dv \
9	* -addedbackground blue -addedforeground white \
10	* -deletedbackground red -deletedforeground white -overstrike true \
11	* -changedbackground black -changedforeground yellow \
12	* -xscrollcommand {.x set} -yscrollcommand {.y set}
13	*
14	* scrollbar .x -orient horizontal -command {.dv xview}
15	* scrollbar .y -orient vertical -command {.dv yview}
16	*
17	* .dv text 1 [exec cat /tmp/file1]
18	* .dv text 2 [exec cat /tmp/file2]
19	* .dv configure -diff 2->1 -layout sidebyside
20	*
21	* puts "DIFF OUTPUT:"
22	* puts [.dv diffs -std]
23	*
24	* ======================================================================
25	* AUTHOR: Michael McLennan, Purdue University
26	* Copyright (c) 2004-2012 HUBzero Foundation, LLC
27	*
28	* See the file "license.terms" for information on usage and
29	* redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
30	* ======================================================================
31	*/
32	#include "tk.h"
33	#include <string.h>
34	#include <stdlib.h>
35
36	/*
37	* Special options for controlling diffs.
38	*/
39	enum diffdir {
40	DIFF_1TO2, DIFF_2TO1
41	};
42	static char *diffdirStrings[] = {
43	"1->2", "2->1", (char*)NULL
44	};
45
46	enum layoutStyle {
47	LAYOUT_INLINE, LAYOUT_SIDEBYSIDE
48	};
49	static char *layoutStyleStrings[] = {
50	"inline", "sidebyside", (char*)NULL
51	};
52
53	enum scancommand {
54	SCAN_MARK, SCAN_DRAGTO
55	};
56	static CONST char *scanCommandNames[] = {
57	"mark", "dragto", (char *) NULL
58	};
59
60
61	/*
62	* Data structure for line start/end for all lines in a buffer.
63	*/
64	typedef struct {
65	int numLines; /* number of lines */
66	int maxLines; /* max size of storage in startPtr/endPtr */
67	char *startPtr; / array of start pointers for each line */
68	int lenPtr; / array of lengths for each line */
69	} DiffviewLines;
70
71	/*
72	* Data structure for text buffers within the widget:
73	*/
74	typedef struct {
75	Tcl_Obj textObj; / actual text within this buffer */
76	DiffviewLines lineLimits; / breakdown of textObj into line starts/ends */
77	} DiffviewBuffer;
78
79	/*
80	* Data structure used internally by diff routine:
81	*/
82	typedef struct subseq {
83	int index1; /* index in buffer #1 */
84	int index2; /* index in buffer #2 */
85	int next; /* next candidate match in the chain */
86	} DiffviewSubseq;
87
88	/*
89	* Data structure returned by diff routine:
90	*/
91	typedef struct {
92	int op; /* operation: 'a'=add 'd'=del 'c'=change */
93	int fromIndex1; /* starts at this line in buffer 1 */
94	int toIndex1; /* ends at this line in buffer 1 */
95	int fromIndex2; /* starts at this line in buffer 2 */
96	int toIndex2; /* ends at this line in buffer 2 */
97	int fromWorld; /* starts at this line in world view */
98	int toWorld; /* ends at this line in world view */
99	} DiffviewDiffOp;
100
101	typedef struct {
102	int maxDiffs; /* maximum storage space for diffs */
103	int numDiffs; /* number of diffs stored in ops */
104	DiffviewDiffOp ops; / list of diffs */
105	} DiffviewDiffs;
106
107	/*
108	* Data structure used for each line of the final layout:
109	*/
110	typedef struct {
111	char style; /* layout style: 'a'=add, 'd'=del, etc. */
112	char bnum; /* show line from this buffer */
113	int bline; /* line number in buffer bnum */
114	int diffNum; /* line is part of this diff */
115	} DiffviewLayoutLine;
116
117	typedef struct {
118	int maxLines; /* maximum number of lines allocated */
119	int numLines; /* current number of lines in layout */
120	DiffviewLayoutLine lines; / info for all lines in world view */
121	} DiffviewLayout;
122
123	/*
124	* Data structure for the widget:
125	*/
126	typedef struct {
127	Tk_Window tkwin; /* tk window for the widget */
128	Display display; / display containing the widget */
129	Tcl_Interp interp; / interpreter containing the widget command */
130	Tcl_Command widgetCmd; /* token for the widget command */
131	Tk_OptionTable optionTable; /* configuration options */
132
133	/*
134	* Used to display the widget:
135	*/
136	Tk_Cursor cursor; /* cursor for the widget */
137	Tk_3DBorder normalBorder; /* border around the widget */
138	int borderWidth; /* width of the border in pixels */
139	int relief; /* relief: raised, sunken, etc. */
140	int highlightWidth; /* width of border showing focus highlight */
141	XColor highlightBgColor; / color for focus highlight bg */
142	XColor highlightColor; / color for focus highlight */
143	int inset; /* width of all borders--offset to ul corner */
144
145	DiffviewBuffer buffer[2]; /* text to diff -- buffers #1 and #2 */
146	DiffviewDiffs diffsPtr; / diff: longest common subseq btwn buffers */
147	DiffviewLayout worldview; /* array mapping each real line in world
148	* coordinates to the corresponding line
149	* in buffer #1/#2, along with its style */
150
151	enum diffdir diffdir; /* diff between these buffers */
152	enum layoutStyle layout; /* layout style (side-by-side or inline) */
153	int maxWidth; /* maximum width of world view in pixels */
154	int maxHeight; /* maximum height of world view in pixels */
155	int lineHeight; /* height of a line with current font */
156	int lineAscent; /* ascent of a line with current font */
157	int topLine; /* index of topmost line in view */
158	int btmLine; /* index of bottommost line in view */
159	int fullLines; /* number of full lines that fit in view */
160
161	int xOffset; /* offset in pixels to left edge of view */
162	int xScrollUnit; /* num pixels for one unit of horizontal
163	* scrolling (one average character) */
164	int yOffset; /* offset in pixels to top edge of view */
165	int yScrollUnit; /* num pixels for one unit of vertical
166	* scrolling (one average line) */
167	char takeFocus; / value of -takefocus option */
168	char yScrollCmd; / command prefix for scrolling */
169	char xScrollCmd; / command prefix for scrolling */
170
171	int scanMarkX; /* x-coord for "scan mark" */
172	int scanMarkY; /* y-coord for "scan mark" */
173	int scanMarkXStart; /* xOffset at start of scan */
174	int scanMarkYStart; /* yOffset at start of scan */
175
176
177	Tk_Font tkfont; /* text font for content of widget */
178	Tk_Font tklastfont; /* previous text font (so we detect changes) */
179	XColor fgColorPtr; / normal foreground color */
180	XColor addBgColorPtr; / background for "added" text in diff */
181	XColor addFgColorPtr; / foreground for "added" text in diff */
182	XColor delBgColorPtr; / background for "deleted" text in diff */
183	XColor delFgColorPtr; / foreground for "deleted" text in diff */
184	XColor chgBgColorPtr; / background for "changed" text in diff */
185	XColor chgFgColorPtr; / foreground for "changed" text in diff */
186	int overStrDel; /* non-zero => overstrike deleted text */
187	GC normGC; /* GC for drawing normal text */
188	GC addFgGC; /* GC for drawing "added" text in diff */
189	GC delFgGC; /* GC for drawing "deleted" text in diff */
190	GC chgFgGC; /* GC for drawing "changed" text in diff */
191	int width; /* overall width of widget, in pixels */
192	int height; /* overall height of widget, in pixels */
193
194	int flags; /* flag bits for redraw, etc. */
195	} Diffview;
196
197	/*
198	* Tk widget flag bits:
199	*
200	* REDRAW_PENDING: DoWhenIdle handler has been queued to redraw
201	* UPDATE_V_SCROLLBAR: non-zero => vertical scrollbar needs updating
202	* UPDATE_H_SCROLLBAR: non-zero => horizontal scrollbar needs updating
203	* GOT_FOCUS: non-zero => widget has input focus
204	* FONT_CHANGED: font changed, so layout needs to be recomputed
205	* WIDGET_DELETED: widget has been destroyed, so don't update
206	*/
207
208	#define REDRAW_PENDING 1
209	#define UPDATE_V_SCROLLBAR 2
210	#define UPDATE_H_SCROLLBAR 4
211	#define GOT_FOCUS 8
212	#define FONT_CHANGED 16
213	#define WIDGET_DELETED 32
214
215
216	/*
217	* Default option values.
218	*/
219	#define BLACK "#000000"
220	#define WHITE "#ffffff"
221	#define NORMAL_BG "#d9d9d9"
222
223	#define DEF_DIFFVIEW_ADDBG "#ccffcc"
224	#define DEF_DIFFVIEW_ADDFG BLACK
225	#define DEF_DIFFVIEW_BG_COLOR NORMAL_BG
226	#define DEF_DIFFVIEW_BG_MONO WHITE
227	#define DEF_DIFFVIEW_BORDERWIDTH "2"
228	#define DEF_DIFFVIEW_CHGBG "#ffffcc"
229	#define DEF_DIFFVIEW_CHGFG BLACK
230	#define DEF_DIFFVIEW_CURSOR ""
231	#define DEF_DIFFVIEW_DELBG "#ffcccc"
232	#define DEF_DIFFVIEW_DELFG "#666666"
233	#define DEF_DIFFVIEW_DIFF "1->2"
234	#define DEF_DIFFVIEW_FG BLACK
235	#define DEF_DIFFVIEW_FONT "Courier -12"
236	#define DEF_DIFFVIEW_HEIGHT "2i"
237	#define DEF_DIFFVIEW_HIGHLIGHT_BG NORMAL_BG
238	#define DEF_DIFFVIEW_HIGHLIGHT BLACK
239	#define DEF_DIFFVIEW_HIGHLIGHT_WIDTH "1"
240	#define DEF_DIFFVIEW_LAYOUT "inline"
241	#define DEF_DIFFVIEW_OVERSTRDEL "true"
242	#define DEF_DIFFVIEW_RELIEF "sunken"
243	#define DEF_DIFFVIEW_TAKE_FOCUS (char*)NULL
244	#define DEF_DIFFVIEW_WIDTH "2i"
245	#define DEF_DIFFVIEW_SCROLL_CMD ""
246
247	/*
248	* Configuration options for this widget.
249	* (must be in alphabetical order)
250	*/
251	static Tk_OptionSpec optionSpecs[] = {
252	{TK_OPTION_COLOR, "-addedbackground", "addedBackground", "Background",
253	DEF_DIFFVIEW_ADDBG, -1, Tk_Offset(Diffview, addBgColorPtr),
254	TK_OPTION_NULL_OK, 0, 0},
255	{TK_OPTION_COLOR, "-addedforeground", "addedForeground", "Foreground",
256	DEF_DIFFVIEW_ADDFG, -1, Tk_Offset(Diffview, addFgColorPtr),
257	TK_OPTION_NULL_OK, 0, 0},
258	{TK_OPTION_BORDER, "-background", "background", "Background",
259	DEF_DIFFVIEW_BG_COLOR, -1, Tk_Offset(Diffview, normalBorder),
260	0, (ClientData) DEF_DIFFVIEW_BG_MONO, 0},
261	{TK_OPTION_SYNONYM, "-bd", (char)NULL, (char)NULL,
262	(char*)NULL, 0, -1, 0, (ClientData) "-borderwidth", 0},
263	{TK_OPTION_SYNONYM, "-bg", (char)NULL, (char)NULL,
264	(char*)NULL, 0, -1, 0, (ClientData) "-background", 0},
265	{TK_OPTION_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
266	DEF_DIFFVIEW_BORDERWIDTH, -1, Tk_Offset(Diffview, borderWidth),
267	0, 0, 0},
268	{TK_OPTION_COLOR, "-changedbackground", "changedBackground", "Background",
269	DEF_DIFFVIEW_CHGBG, -1, Tk_Offset(Diffview, chgBgColorPtr),
270	TK_OPTION_NULL_OK, 0, 0},
271	{TK_OPTION_COLOR, "-changedforeground", "changedForeground", "Foreground",
272	DEF_DIFFVIEW_CHGFG, -1, Tk_Offset(Diffview, chgFgColorPtr),
273	TK_OPTION_NULL_OK, 0, 0},
274	{TK_OPTION_CURSOR, "-cursor", "cursor", "Cursor",
275	DEF_DIFFVIEW_CURSOR, -1, Tk_Offset(Diffview, cursor),
276	TK_OPTION_NULL_OK, 0, 0},
277	{TK_OPTION_COLOR, "-deletedbackground", "deletedBackground", "Background",
278	DEF_DIFFVIEW_DELBG, -1, Tk_Offset(Diffview, delBgColorPtr),
279	TK_OPTION_NULL_OK, 0, 0},
280	{TK_OPTION_COLOR, "-deletedforeground", "deletedForeground", "Foreground",
281	DEF_DIFFVIEW_DELFG, -1, Tk_Offset(Diffview, delFgColorPtr),
282	TK_OPTION_NULL_OK, 0, 0},
283	{TK_OPTION_STRING_TABLE, "-diff", "diff", "Diff",
284	DEF_DIFFVIEW_DIFF, -1, Tk_Offset(Diffview, diffdir),
285	0, (ClientData)diffdirStrings, 0},
286	{TK_OPTION_SYNONYM, "-fg", "foreground", (char*)NULL,
287	(char*)NULL, 0, -1, 0, (ClientData) "-foreground", 0},
288	{TK_OPTION_FONT, "-font", "font", "Font",
289	DEF_DIFFVIEW_FONT, -1, Tk_Offset(Diffview, tkfont), 0, 0, 0},
290	{TK_OPTION_COLOR, "-foreground", "foreground", "Foreground",
291	DEF_DIFFVIEW_FG, -1, Tk_Offset(Diffview, fgColorPtr), 0, 0, 0},
292	{TK_OPTION_PIXELS, "-height", "height", "Height",
293	DEF_DIFFVIEW_HEIGHT, -1, Tk_Offset(Diffview, height), 0, 0, 0},
294	{TK_OPTION_COLOR, "-highlightbackground", "highlightBackground",
295	"HighlightBackground", DEF_DIFFVIEW_HIGHLIGHT_BG, -1,
296	Tk_Offset(Diffview, highlightBgColor), 0, 0, 0},
297	{TK_OPTION_COLOR, "-highlightcolor", "highlightColor", "HighlightColor",
298	DEF_DIFFVIEW_HIGHLIGHT, -1, Tk_Offset(Diffview, highlightColor),
299	0, 0, 0},
300	{TK_OPTION_PIXELS, "-highlightthickness", "highlightThickness",
301	"HighlightThickness", DEF_DIFFVIEW_HIGHLIGHT_WIDTH, -1,
302	Tk_Offset(Diffview, highlightWidth), 0, 0, 0},
303	{TK_OPTION_STRING_TABLE, "-layout", "layout", "Layout",
304	DEF_DIFFVIEW_LAYOUT, -1, Tk_Offset(Diffview, layout),
305	0, (ClientData)layoutStyleStrings, 0},
306	{TK_OPTION_BOOLEAN, "-overstrike", "overstrike", "Overstrike",
307	DEF_DIFFVIEW_OVERSTRDEL, -1, Tk_Offset(Diffview, overStrDel), 0, 0, 0},
308	{TK_OPTION_RELIEF, "-relief", "relief", "Relief",
309	DEF_DIFFVIEW_RELIEF, -1, Tk_Offset(Diffview, relief), 0, 0, 0},
310	{TK_OPTION_STRING, "-takefocus", "takeFocus", "TakeFocus",
311	DEF_DIFFVIEW_TAKE_FOCUS, -1, Tk_Offset(Diffview, takeFocus),
312	TK_OPTION_NULL_OK, 0, 0},
313	{TK_OPTION_PIXELS, "-width", "width", "Width",
314	DEF_DIFFVIEW_WIDTH, -1, Tk_Offset(Diffview, width), 0, 0, 0},
315	{TK_OPTION_STRING, "-xscrollcommand", "xScrollCommand", "ScrollCommand",
316	DEF_DIFFVIEW_SCROLL_CMD, -1, Tk_Offset(Diffview, xScrollCmd),
317	TK_OPTION_NULL_OK, 0, 0},
318	{TK_OPTION_STRING, "-yscrollcommand", "yScrollCommand", "ScrollCommand",
319	DEF_DIFFVIEW_SCROLL_CMD, -1, Tk_Offset(Diffview, yScrollCmd),
320	TK_OPTION_NULL_OK, 0, 0},
321	{TK_OPTION_END, (char)NULL, (char)NULL, (char*)NULL,
322	(char*)NULL, 0, -1, 0, 0, 0}
323	};
324
325	/*
326	* Widget commands:
327	*/
328	static CONST char *commandNames[] = {
329	"bbox", "cget", "configure",
330	"diffs", "scan", "see",
331	"text", "xview", "yview",
332	(char*)NULL
333	};
334
335	enum command {
336	COMMAND_BBOX, COMMAND_CGET, COMMAND_CONFIGURE,
337	COMMAND_DIFFS, COMMAND_SCAN, COMMAND_SEE,
338	COMMAND_TEXT, COMMAND_XVIEW, COMMAND_YVIEW
339	};
340
341	/*
342	* Forward declarations for remaining procedures.
343	*/
344	static int DiffviewObjCmd _ANSI_ARGS_((ClientData clientData,
345	Tcl_Interp *interp, int objc,
346	Tcl_Obj *CONST objv[]));
347	static int DiffviewWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
348	Tcl_Interp *interp, int objc,
349	Tcl_Obj *CONST objv[]));
350	static int DiffviewBboxSubCmd _ANSI_ARGS_ ((Tcl_Interp *interp,
351	Diffview dvPtr, int objc, Tcl_Obj CONST objv[]));
352	static int DiffviewDiffsSubCmd _ANSI_ARGS_ ((Tcl_Interp *interp,
353	Diffview dvPtr, int objc, Tcl_Obj CONST objv[]));
354	static int DiffviewTextSubCmd _ANSI_ARGS_ ((Tcl_Interp *interp,
355	Diffview dvPtr, int objc, Tcl_Obj CONST objv[]));
356	static int DiffviewXviewSubCmd _ANSI_ARGS_ ((Tcl_Interp *interp,
357	Diffview dvPtr, int objc, Tcl_Obj CONST objv[]));
358	static int DiffviewYviewSubCmd _ANSI_ARGS_ ((Tcl_Interp *interp,
359	Diffview dvPtr, int objc, Tcl_Obj CONST objv[]));
360	static int DiffviewGetIndex _ANSI_ARGS_ ((Tcl_Interp *interp,
361	Diffview dvPtr, Tcl_Obj objPtr, int *linePtr,
362	DiffviewDiffOp **diffOpPtrPtr));
363
364	static void DestroyDiffview _ANSI_ARGS_((char *memPtr));
365	static int ConfigureDiffview _ANSI_ARGS_((Tcl_Interp *interp,
366	Diffview dvPtr, int objc, Tcl_Obj CONST objv[],
367	int flags));
368	static void DiffviewWorldChanged _ANSI_ARGS_((
369	ClientData instanceData));
370	static void EventuallyRedraw _ANSI_ARGS_((Diffview *dvPtr));
371	static void DisplayDiffview _ANSI_ARGS_((ClientData clientData));
372	static void DiffviewComputeGeometry _ANSI_ARGS_((Diffview *dvPtr));
373	static void DiffviewEventProc _ANSI_ARGS_((ClientData clientData,
374	XEvent *eventPtr));
375	static void DiffviewCmdDeletedProc _ANSI_ARGS_((
376	ClientData clientData));
377	static void ChangeDiffviewView _ANSI_ARGS_((Diffview *dvPtr,
378	int lnum));
379	static void DiffviewScanTo _ANSI_ARGS_((Diffview *dvPtr,
380	int x, int y));
381	static void DiffviewUpdateLayout _ANSI_ARGS_((
382	Diffview *dvPtr));
383	static void DiffviewUpdateVScrollbar _ANSI_ARGS_((
384	Diffview *dvPtr));
385	static void DiffviewUpdateHScrollbar _ANSI_ARGS_((
386	Diffview *dvPtr));
387	static DiffviewLines* DiffviewLinesCreate _ANSI_ARGS_((char *textPtr,
388	int textLen));
389	static void DiffviewLinesFree _ANSI_ARGS_((
390	DiffviewLines *lineLimitsPtr));
391	static DiffviewDiffs* DiffviewDiffsCreate _ANSI_ARGS_((
392	char textPtr1, DiffviewLines limsPtr1,
393	char textPtr2, DiffviewLines limsPtr2));
394	static void DiffviewDiffsAppend _ANSI_ARGS_((
395	DiffviewDiffs *diffsPtr, int op,
396	int fromIndex1, int toIndex1,
397	int fromIndex2, int toIndex2));
398	static void DiffviewDiffsFree _ANSI_ARGS_((
399	DiffviewDiffs *diffsPtr));
400	static void DiffviewLayoutAdd _ANSI_ARGS_((
401	DiffviewLayout *layoutPtr,
402	DiffviewLayoutLine *linePtr));
403	static void DiffviewLayoutClear _ANSI_ARGS_((
404	DiffviewLayout *layoutPtr));
405	static void DiffviewLayoutFree _ANSI_ARGS_((
406	DiffviewLayout *layoutPtr));
407
408	/*
409	* Standard Tk procs invoked from generic window code.
410	*/
411	static Tk_ClassProcs diffviewClass = {
412	sizeof(Tk_ClassProcs), /* size */
413	DiffviewWorldChanged, /* worldChangedProc */
414	};
415
416	/*
417	* ------------------------------------------------------------------------
418	* RpDiffview_Init --
419	*
420	* Invoked when the Rappture GUI library is being initialized
421	* to install the "diffview" widget into the interpreter.
422	*
423	* Returns TCL_OK if successful, or TCL_ERROR (along with an error
424	* message in the interp) if anything goes wrong.
425	* ------------------------------------------------------------------------
426	*/
427	int
428	RpDiffview_Init(interp)
429	Tcl_Interp interp; / interpreter being initialized */
430	{
431	static char *script = "source [file join $RapptureGUI::library scripts diffview.tcl]";
432
433	/* install the widget command */
434	Tcl_CreateObjCommand(interp, "Rappture::Diffview", DiffviewObjCmd,
435	NULL, NULL);
436
437	/* load the default bindings */
438	if (Tcl_Eval(interp, script) != TCL_OK) {
439	return TCL_ERROR;
440	}
441
442	return TCL_OK;
443	}
444
445	/*
446	* ----------------------------------------------------------------------
447	* DiffviewObjCmd()
448	*
449	* Called whenever a Diffview object is created to create the widget
450	* and install the Tcl access command.
451	* ----------------------------------------------------------------------
452	*/
453	static int
454	DiffviewObjCmd(clientData, interp, objc, objv)
455	ClientData clientData; /* not used */
456	Tcl_Interp interp; / current interpreter */
457	int objc; /* number of command arguments */
458	Tcl_Obj CONST objv[]; / command argument objects */
459	{
460	Diffview *dvPtr;
461	Tk_Window tkwin;
462
463	if (objc < 2) {
464	Tcl_WrongNumArgs(interp, 1, objv, "pathName ?options?");
465	return TCL_ERROR;
466	}
467
468	tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp),
469	Tcl_GetString(objv[1]), (char*)NULL);
470
471	if (tkwin == NULL) {
472	return TCL_ERROR;
473	}
474
475	/*
476	* Create a data structure for the widget objects and set good
477	* initial values.
478	*/
479	dvPtr = (Diffview*)ckalloc(sizeof(Diffview));
480	memset((void*)dvPtr, 0, (sizeof(Diffview)));
481
482	dvPtr->tkwin = tkwin;
483	dvPtr->display = Tk_Display(tkwin);
484	dvPtr->interp = interp;
485	dvPtr->widgetCmd = Tcl_CreateObjCommand(interp,
486	Tk_PathName(dvPtr->tkwin), DiffviewWidgetObjCmd,
487	(ClientData)dvPtr, DiffviewCmdDeletedProc);
488	dvPtr->optionTable = Tk_CreateOptionTable(interp, optionSpecs);
489
490	dvPtr->buffer[0].textObj = NULL;
491	dvPtr->buffer[0].lineLimits = NULL;
492	dvPtr->buffer[1].textObj = NULL;
493	dvPtr->buffer[1].lineLimits = NULL;
494	dvPtr->diffdir = DIFF_1TO2;
495
496	dvPtr->cursor = None;
497	dvPtr->relief = TK_RELIEF_SUNKEN;
498	dvPtr->normGC = None;
499	dvPtr->addFgGC = None;
500	dvPtr->delFgGC = None;
501	dvPtr->chgFgGC = None;
502	dvPtr->xScrollUnit = 1;
503	dvPtr->yScrollUnit = 1;
504
505	/*
506	* Use reference counting to decide when this data should be
507	* cleaned up.
508	*/
509	Tcl_Preserve((ClientData) dvPtr->tkwin);
510
511	Tk_SetClass(dvPtr->tkwin, "Diffview");
512	Tk_SetClassProcs(dvPtr->tkwin, &diffviewClass, (ClientData)dvPtr);
513
514	Tk_CreateEventHandler(dvPtr->tkwin,
515	ExposureMask\|StructureNotifyMask\|FocusChangeMask,
516	DiffviewEventProc, (ClientData)dvPtr);
517
518	if (Tk_InitOptions(interp, (char*)dvPtr, dvPtr->optionTable, tkwin)
519	!= TCL_OK) {
520	Tk_DestroyWindow(dvPtr->tkwin);
521	return TCL_ERROR;
522	}
523
524	if (ConfigureDiffview(interp, dvPtr, objc-2, objv+2, 0) != TCL_OK) {
525	Tk_DestroyWindow(dvPtr->tkwin);
526	return TCL_ERROR;
527	}
528
529	Tcl_SetResult(interp, Tk_PathName(dvPtr->tkwin), TCL_STATIC);
530	return TCL_OK;
531	}
532
533	/*
534	* ----------------------------------------------------------------------
535	* DiffviewWidgetObjCmd()
536	*
537	* Called to process the operations associated with the widget. Handles
538	* the widget access command, using the operations defined in the
539	* commandNames[] array.
540	* ----------------------------------------------------------------------
541	*/
542	static int
543	DiffviewWidgetObjCmd(clientData, interp, objc, objv)
544	ClientData clientData; /* widget data */
545	Tcl_Interp interp; / interp handling this command */
546	int objc; /* number of command arguments */
547	Tcl_Obj CONST objv[]; / command arguments */
548	{
549	Diffview dvPtr = (Diffview)clientData;
550	int result = TCL_OK;
551	int cmdToken;
552
553	if (objc < 2) {
554	Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
555	return TCL_ERROR;
556	}
557
558	/*
559	* Look up the command option and map it to an enumerated value.
560	*/
561	result = Tcl_GetIndexFromObj(interp, objv[1], commandNames,
562	"option", 0, &cmdToken);
563
564	if (result != TCL_OK) {
565	return result;
566	}
567
568	/* hang on to the widget data until we exit... */
569	Tcl_Preserve((ClientData)dvPtr);
570
571	switch (cmdToken) {
572	case COMMAND_BBOX: {
573	result = DiffviewBboxSubCmd(interp, dvPtr, objc, objv);
574	break;
575	}
576
577	case COMMAND_CGET: {
578	Tcl_Obj *objPtr;
579	if (objc != 3) {
580	Tcl_WrongNumArgs(interp, 2, objv, "option");
581	result = TCL_ERROR;
582	break;
583	}
584
585	objPtr = Tk_GetOptionValue(interp, (char*)dvPtr,
586	dvPtr->optionTable, objv[2], dvPtr->tkwin);
587	if (objPtr == NULL) {
588	result = TCL_ERROR;
589	break;
590	}
591	Tcl_SetObjResult(interp, objPtr);
592	result = TCL_OK;
593	break;
594	}
595
596	case COMMAND_CONFIGURE: {
597	Tcl_Obj *objPtr;
598	if (objc <= 3) {
599	/* query the value of an option */
600	objPtr = Tk_GetOptionInfo(interp, (char*)dvPtr,
601	dvPtr->optionTable,
602	(objc == 3) ? objv[2] : (Tcl_Obj*)NULL,
603	dvPtr->tkwin);
604	if (objPtr == NULL) {
605	result = TCL_ERROR;
606	break;
607	} else {
608	Tcl_SetObjResult(interp, objPtr);
609	result = TCL_OK;
610	}
611	} else {
612	/* set one or more configuration options */
613	result = ConfigureDiffview(interp, dvPtr, objc-2, objv+2, 0);
614	}
615	break;
616	}
617
618	case COMMAND_DIFFS: {
619	result = DiffviewDiffsSubCmd(interp, dvPtr, objc, objv);
620	break;
621	}
622
623	case COMMAND_SCAN: {
624	int x, y, scanCmdIndex;
625
626	if (objc != 5) {
627	Tcl_WrongNumArgs(interp, 2, objv, "mark\|dragto x y");
628	result = TCL_ERROR;
629	break;
630	}
631
632	if (Tcl_GetIntFromObj(interp, objv[3], &x) != TCL_OK
633	\|\| Tcl_GetIntFromObj(interp, objv[4], &y) != TCL_OK) {
634	result = TCL_ERROR;
635	break;
636	}
637
638	result = Tcl_GetIndexFromObj(interp, objv[2], scanCommandNames,
639	"option", 0, &scanCmdIndex);
640	if (result != TCL_OK) {
641	break;
642	}
643	switch (scanCmdIndex) {
644	case SCAN_MARK: {
645	dvPtr->scanMarkX = x;
646	dvPtr->scanMarkY = y;
647	dvPtr->scanMarkXStart = dvPtr->xOffset;
648	dvPtr->scanMarkYStart = dvPtr->yOffset;
649	break;
650	}
651	case SCAN_DRAGTO: {
652	DiffviewScanTo(dvPtr, x, y);
653	break;
654	}
655	}
656	result = TCL_OK;
657	break;
658	}
659
660	case COMMAND_SEE: {
661	DiffviewDiffOp *diffOpPtr;
662	int line1, line2, topline;
663
664	if (objc != 3) {
665	Tcl_WrongNumArgs(interp, 2, objv, "index");
666	result = TCL_ERROR;
667	break;
668	}
669	result = DiffviewGetIndex(interp, dvPtr, objv[2],
670	&line1, &diffOpPtr);
671	if (result != TCL_OK) {
672	break;
673	}
674
675	if (line1 < 0 && diffOpPtr != NULL) {
676	line1 = diffOpPtr->fromWorld;
677	line2 = diffOpPtr->toWorld;
678	} else {
679	line2 = line1;
680	}
681
682	if (line1 >= dvPtr->worldview.numLines) {
683	line1 = line2 = dvPtr->worldview.numLines-1;
684	}
685	if (line1 < 0) {
686	line1 = line2 = 0;
687	}
688
689	if (line1 < dvPtr->topLine \|\| line1 > dvPtr->btmLine) {
690	/* location off screen? then center it in y-view */
691	if (line2-line1 >= dvPtr->fullLines) {
692	topline = line1;
693	} else {
694	topline = (line1+line2)/2 - dvPtr->fullLines/2;
695	if (topline < 0) topline = 0;
696	}
697	ChangeDiffviewView(dvPtr, topline);
698	}
699	result = TCL_OK;
700	break;
701	}
702
703	case COMMAND_TEXT: {
704	result = DiffviewTextSubCmd(interp, dvPtr, objc, objv);
705	break;
706	}
707
708	case COMMAND_XVIEW: {
709	result = DiffviewXviewSubCmd(interp, dvPtr, objc, objv);
710	break;
711	}
712
713	case COMMAND_YVIEW: {
714	result = DiffviewYviewSubCmd(interp, dvPtr, objc, objv);
715	break;
716	}
717	}
718
719	/* okay, release the widget data and return */
720	Tcl_Release((ClientData)dvPtr);
721	return result;
722	}
723
724	/*
725	* ----------------------------------------------------------------------
726	* DiffviewBboxSubCmd()
727	*
728	* Handles the "bbox" operation on the widget. Returns a bounding
729	* box for the specified part of the widget.
730	* ----------------------------------------------------------------------
731	*/
732	static int
733	DiffviewBboxSubCmd(interp, dvPtr, objc, objv)
734	Tcl_Interp interp; / interp handling this command */
735	Diffview dvPtr; / widget data */
736	int objc; /* number of command arguments */
737	Tcl_Obj CONST objv[]; / command arguments */
738	{
739	char *opt, buf[256];
740	DiffviewDiffOp *diffOpPtr;
741	int line, bnum, bline, x1, y0, y1, wd;
742	char *textPtr; int textLen;
743
744	if (objc != 3) {
745	Tcl_WrongNumArgs(interp, 2, objv, "index");
746	return TCL_ERROR;
747	}
748
749	/* make sure that our layout info is up to date for queries below */
750	DiffviewUpdateLayout(dvPtr);
751
752	opt = Tcl_GetString(objv[2]);
753	if (*opt == 'a' && strcmp(opt,"all") == 0) {
754	sprintf(buf, "0 0 %d %d", dvPtr->maxWidth, dvPtr->maxHeight);
755	Tcl_SetResult(interp, buf, TCL_VOLATILE);
756	return TCL_OK;
757	}
758
759	if (DiffviewGetIndex(interp, dvPtr, objv[2], &line, &diffOpPtr) != TCL_OK) {
760	Tcl_AppendResult(interp, " or all", (char*)NULL);
761	return TCL_ERROR;
762	}
763
764	/* return the bounding box for a line in world coords */
765	if (line >= 0) {
766	y0 = line*dvPtr->lineHeight;
767	y1 = (line+1)*dvPtr->lineHeight;
768	x1 = 0;
769	if (line < dvPtr->worldview.numLines) {
770	bnum = dvPtr->worldview.lines[line].bnum;
771	bline = dvPtr->worldview.lines[line].bline;
772	if (bline >= 0) {
773	textPtr = dvPtr->buffer[bnum].lineLimits->startPtr[bline];
774	textLen = dvPtr->buffer[bnum].lineLimits->lenPtr[bline];
775	x1 = Tk_TextWidth(dvPtr->tkfont, textPtr, textLen);
776	}
777	}
778	sprintf(buf, "0 %d %d %d", y0, x1, y1);
779	Tcl_SetResult(interp, buf, TCL_VOLATILE);
780	return TCL_OK;
781	}
782
783	/* return the bounding box for a diff in world coords */
784	if (diffOpPtr) {
785	y0 = diffOpPtr->fromWorld*dvPtr->lineHeight;
786	y1 = (diffOpPtr->toWorld+1)*dvPtr->lineHeight;
787	x1 = 0;
788
789	for (line=diffOpPtr->fromWorld; line <= diffOpPtr->toWorld; line++) {
790	if (line < dvPtr->worldview.numLines) {
791	bnum = dvPtr->worldview.lines[line].bnum;
792	bline = dvPtr->worldview.lines[line].bline;
793	if (bline >= 0) {
794	textPtr = dvPtr->buffer[bnum].lineLimits->startPtr[bline];
795	textLen = dvPtr->buffer[bnum].lineLimits->lenPtr[bline];
796	wd = Tk_TextWidth(dvPtr->tkfont, textPtr, textLen);
797	if (wd > x1) {
798	x1 = wd;
799	}
800	}
801	}
802	}
803	sprintf(buf, "0 %d %d %d", y0, x1, y1);
804	Tcl_SetResult(interp, buf, TCL_VOLATILE);
805	}
806	return TCL_OK;
807	}
808
809	/*
810	* ----------------------------------------------------------------------
811	* DiffviewDiffsSubCmd()
812	*
813	* Handles the "diffs" operation on the widget with the following
814	* syntax:
815	*
816	* widget diffs ?-std\|-debug\|-number?
817	*
818	* The default is "diffs -std", which returns the usual output from
819	* the Unix "diff" command. The -debug option returns a more detailed
820	* output that is useful for testing/debugging. The -number option
821	* returns the total number of diffs. This is useful for commands
822	* such as "see #2", where you can bring a particular diff into view.
823	* ----------------------------------------------------------------------
824	*/
825	static int
826	DiffviewDiffsSubCmd(interp, dvPtr, objc, objv)
827	Tcl_Interp interp; / interp handling this command */
828	Diffview dvPtr; / widget data */
829	int objc; /* number of command arguments */
830	Tcl_Obj CONST objv[]; / command arguments */
831	{
832	Tcl_Obj *resultPtr;
833	char range1[128], range2[128];
834	int i, n;
835
836	static CONST char *options[] = {
837	"-std", "-debug", "-number", (char*)NULL
838	};
839	enum options {
840	DIFFS_STD, DIFFS_DEBUG, DIFFS_NUMBER
841	};
842	int op = DIFFS_STD;
843
844
845	if (objc > 3) {
846	Tcl_WrongNumArgs(interp, 2, objv, "?-std? ?-debug? ?-number?");
847	return TCL_ERROR;
848	}
849
850	/* decode the option that controls the return result */
851	if (objc > 2) {
852	if (Tcl_GetIndexFromObj(interp, objv[2], options, "option", 0,
853	&op) != TCL_OK) {
854	return TCL_ERROR;
855	}
856	}
857
858	/* make sure that our layout info is up to date for queries below */
859	DiffviewUpdateLayout(dvPtr);
860
861	switch ((enum options)op) {
862	case DIFFS_STD: {
863	DiffviewDiffOp curr, *currOpPtr;
864	DiffviewLines lines1, lines2;
865
866	if (dvPtr->diffsPtr) {
867	resultPtr = Tcl_GetObjResult(interp);
868	for (i=0; i < dvPtr->diffsPtr->numDiffs; i++) {
869	currOpPtr = &dvPtr->diffsPtr->ops[i];
870
871	/* if we're diff'ing the other way, reverse the diff */
872	if (dvPtr->diffdir == DIFF_1TO2) {
873	memcpy((VOID)&curr, (VOID)currOpPtr,
874	sizeof(DiffviewDiffOp));
875	lines1 = dvPtr->buffer[0].lineLimits;
876	lines2 = dvPtr->buffer[1].lineLimits;
877	} else {
878	switch (currOpPtr->op) {
879	case 'a': curr.op = 'd'; break;
880	case 'd': curr.op = 'a'; break;
881	default: curr.op = currOpPtr->op; break;
882	}
883	curr.fromIndex1 = currOpPtr->fromIndex2;
884	curr.toIndex1 = currOpPtr->toIndex2;
885	curr.fromIndex2 = currOpPtr->fromIndex1;
886	curr.toIndex2 = currOpPtr->toIndex1;
887	lines1 = dvPtr->buffer[1].lineLimits;
888	lines2 = dvPtr->buffer[0].lineLimits;
889	}
890
891	/* append the diff info onto the output */
892	if (curr.fromIndex1 == curr.toIndex1) {
893	if (curr.op == 'a') {
894	/* for append, use first index at raw value */
895	sprintf(range1, "%d", curr.fromIndex1);
896	} else {
897	sprintf(range1, "%d", curr.fromIndex1+1);
898	}
899	} else {
900	sprintf(range1, "%d,%d", curr.fromIndex1+1,
901	curr.toIndex1+1);
902	}
903
904	if (curr.fromIndex2 == curr.toIndex2) {
905	if (curr.op == 'd') {
906	/* for delete, use second index at raw value */
907	sprintf(range2, "%d", curr.fromIndex2);
908	} else {
909	sprintf(range2, "%d", curr.fromIndex2+1);
910	}
911	} else {
912	sprintf(range2, "%d,%d", curr.fromIndex2+1,
913	curr.toIndex2+1);
914	}
915
916	switch (curr.op) {
917	case 'a': {
918	Tcl_AppendToObj(resultPtr, range1, -1);
919	Tcl_AppendToObj(resultPtr, "a", 1);
920	Tcl_AppendToObj(resultPtr, range2, -1);
921	Tcl_AppendToObj(resultPtr, "\n", 1);
922	for (n=curr.fromIndex2; n <= curr.toIndex2; n++) {
923	Tcl_AppendToObj(resultPtr, "> ", 2);
924	Tcl_AppendToObj(resultPtr, lines2->startPtr[n],
925	lines2->lenPtr[n]);
926	Tcl_AppendToObj(resultPtr, "\n", 1);
927	}
928	break;
929	}
930	case 'd': {
931	Tcl_AppendToObj(resultPtr, range1, -1);
932	Tcl_AppendToObj(resultPtr, "d", 1);
933	Tcl_AppendToObj(resultPtr, range2, -1);
934	Tcl_AppendToObj(resultPtr, "\n", 1);
935	for (n=curr.fromIndex1; n <= curr.toIndex1; n++) {
936	Tcl_AppendToObj(resultPtr, "< ", 2);
937	Tcl_AppendToObj(resultPtr, lines1->startPtr[n],
938	lines1->lenPtr[n]);
939	Tcl_AppendToObj(resultPtr, "\n", 1);
940	}
941	break;
942	}
943	case 'c': {
944	Tcl_AppendToObj(resultPtr, range1, -1);
945	Tcl_AppendToObj(resultPtr, "c", 1);
946	Tcl_AppendToObj(resultPtr, range2, -1);
947	Tcl_AppendToObj(resultPtr, "\n", 1);
948	for (n=curr.fromIndex1; n <= curr.toIndex1; n++) {
949	Tcl_AppendToObj(resultPtr, "< ", 2);
950	Tcl_AppendToObj(resultPtr, lines1->startPtr[n],
951	lines1->lenPtr[n]);
952	Tcl_AppendToObj(resultPtr, "\n", 1);
953	}
954	Tcl_AppendToObj(resultPtr, "---\n", 4);
955	for (n=curr.fromIndex2; n <= curr.toIndex2; n++) {
956	Tcl_AppendToObj(resultPtr, "> ", 2);
957	Tcl_AppendToObj(resultPtr, lines2->startPtr[n],
958	lines2->lenPtr[n]);
959	Tcl_AppendToObj(resultPtr, "\n", 1);
960	}
961	break;
962	}
963	}
964	}
965	}
966	break;
967	}
968	case DIFFS_DEBUG: {
969	DiffviewDiffOp *c;
970	char elem[256];
971
972	if (dvPtr->diffsPtr) {
973	for (i=0; i < dvPtr->diffsPtr->numDiffs; i++) {
974	c = &dvPtr->diffsPtr->ops[i];
975
976	/* append the diff info onto the output */
977	if (c->fromIndex1 == c->toIndex1) {
978	sprintf(range1, "%d", c->fromIndex1);
979	} else {
980	sprintf(range1, "%d,%d", c->fromIndex1, c->toIndex1);
981	}
982
983	if (c->fromIndex2 == c->toIndex2) {
984	sprintf(range2, "%d", c->fromIndex2);
985	} else {
986	sprintf(range2, "%d,%d", c->fromIndex2, c->toIndex2);
987	}
988
989	sprintf(elem, "%c %s %s", c->op, range1, range2);
990	Tcl_AppendElement(interp, elem);
991	}
992	}
993	break;
994	}
995	case DIFFS_NUMBER: {
996	int num = 0;
997	if (dvPtr->diffsPtr) {
998	num = dvPtr->diffsPtr->numDiffs;
999	}
1000	resultPtr = Tcl_NewIntObj(num);
1001	Tcl_SetObjResult(interp, resultPtr);
1002	break;
1003	}
1004	}
1005	return TCL_OK;
1006	}
1007
1008	/*
1009	* ----------------------------------------------------------------------
1010	* DiffviewTextSubCmd()
1011	*
1012	* Handles the "text" operation on the widget with the following
1013	* syntax:
1014	*
1015	* widget text 1 ?string?
1016	* widget text 2 ?string?
1017	*
1018	* Used to get/set the text being diff'd and displayed in the widget.
1019	* ----------------------------------------------------------------------
1020	*/
1021	static int
1022	DiffviewTextSubCmd(interp, dvPtr, objc, objv)
1023	Tcl_Interp interp; / interp handling this command */
1024	Diffview dvPtr; / widget data */
1025	int objc; /* number of command arguments */
1026	Tcl_Obj CONST objv[]; / command arguments */
1027	{
1028	int bufferNum;
1029	DiffviewBuffer *slotPtr;
1030
1031	if (objc < 2 \|\| objc > 4) {
1032	Tcl_WrongNumArgs(interp, 2, objv, "bufferNum ?string?");
1033	return TCL_ERROR;
1034	}
1035
1036	/* decode the buffer number -- right now only buffers 1 & 2 */
1037	if (Tcl_GetIntFromObj(interp, objv[2], &bufferNum) != TCL_OK) {
1038	return TCL_ERROR;
1039	}
1040	if (bufferNum < 1 \|\| bufferNum > 2) {
1041	Tcl_AppendResult(interp, "bad buffer number \"",
1042	Tcl_GetString(objv[2]), "\": should be 1 or 2",
1043	(char*)NULL);
1044	return TCL_ERROR;
1045	}
1046	slotPtr = &dvPtr->buffer[bufferNum-1];
1047
1048	if (objc == 3) {
1049	/* return current contents of the buffer */
1050	if (slotPtr->textObj != NULL) {
1051	Tcl_SetObjResult(interp, slotPtr->textObj);
1052	} else {
1053	Tcl_ResetResult(interp);
1054	}
1055	return TCL_OK;
1056	}
1057
1058	/* set and return the new contents of the buffer */
1059	if (slotPtr->textObj != NULL) {
1060	Tcl_DecrRefCount(slotPtr->textObj);
1061	DiffviewLinesFree(slotPtr->lineLimits);
1062	slotPtr->lineLimits = NULL;
1063	}
1064	slotPtr->textObj = objv[3];
1065	Tcl_IncrRefCount(slotPtr->textObj);
1066
1067	EventuallyRedraw(dvPtr);
1068
1069	Tcl_SetObjResult(interp, slotPtr->textObj);
1070	return TCL_OK;
1071	}
1072
1073	/*
1074	* ----------------------------------------------------------------------
1075	* DiffviewXviewSubCmd()
1076	*
1077	* Handles the "xview" operation on the widget. Adjusts the x-axis view
1078	* according to some request, which usually comes from a scrollbar.
1079	* Supports the standard Tk operations for "xview".
1080	* ----------------------------------------------------------------------
1081	*/
1082	static int
1083	DiffviewXviewSubCmd(interp, dvPtr, objc, objv)
1084	Tcl_Interp interp; / interp handling this command */
1085	Diffview dvPtr; / widget data */
1086	int objc; /* number of command arguments */
1087	Tcl_Obj CONST objv[]; / command arguments */
1088	{
1089
1090	int offset = 0;
1091	int index, count, type, viewWidth, windowUnits, maxOffset;
1092	double fraction, fraction2;
1093
1094	viewWidth = Tk_Width(dvPtr->tkwin) - 2*dvPtr->inset;
1095
1096	if (objc == 2) {
1097	/*
1098	* COMMAND: widget xview
1099	* return current limits as fractions 0-1
1100	*/
1101	if (dvPtr->maxWidth == 0) {
1102	Tcl_SetResult(interp, "0 1", TCL_STATIC);
1103	} else {
1104	char buf[TCL_DOUBLE_SPACE*2+2];
1105
1106	fraction = dvPtr->xOffset/((double)dvPtr->maxWidth);
1107	fraction2 = (dvPtr->xOffset + viewWidth)
1108	/((double)dvPtr->maxWidth);
1109	if (fraction2 > 1.0) {
1110	fraction2 = 1.0;
1111	}
1112	sprintf(buf, "%g %g", fraction, fraction2);
1113	Tcl_SetResult(interp, buf, TCL_VOLATILE);
1114	}
1115	} else {
1116	if (objc == 3) {
1117	/*
1118	* COMMAND: widget xview index
1119	* set left edge to character at index
1120	*/
1121	if (Tcl_GetIntFromObj(interp, objv[2], &index) != TCL_OK) {
1122	return TCL_ERROR;
1123	}
1124	offset = index*dvPtr->xScrollUnit;
1125	} else {
1126	/*
1127	* COMMAND: widget xview moveto fraction
1128	* COMMAND: widget xview scroll number what
1129	* handles more complex scrolling movements
1130	*/
1131	type = Tk_GetScrollInfoObj(interp, objc, objv, &fraction, &count);
1132	switch (type) {
1133	case TK_SCROLL_ERROR:
1134	return TCL_ERROR;
1135	case TK_SCROLL_MOVETO:
1136	offset = (int)(fraction*dvPtr->maxWidth + 0.5);
1137	break;
1138	case TK_SCROLL_PAGES:
1139	windowUnits = viewWidth/dvPtr->xScrollUnit;
1140	if (windowUnits > 2) {
1141	offset = dvPtr->xOffset
1142	+ countdvPtr->xScrollUnit(windowUnits-2);
1143	} else {
1144	offset = dvPtr->xOffset + count*dvPtr->xScrollUnit;
1145	}
1146	break;
1147	case TK_SCROLL_UNITS:
1148	offset = dvPtr->xOffset + count*dvPtr->xScrollUnit;
1149	break;
1150	}
1151	}
1152	maxOffset = dvPtr->maxWidth
1153	- (Tk_Width(dvPtr->tkwin) - 2*dvPtr->inset)
1154	+ (dvPtr->xScrollUnit - 1);
1155	if (offset > maxOffset) { offset = maxOffset; }
1156	if (offset < 0) { offset = 0; }
1157
1158	/* nudge back to an even boundary */
1159	offset -= offset % dvPtr->xScrollUnit;
1160
1161	if (offset != dvPtr->xOffset) {
1162	dvPtr->xOffset = offset;
1163	dvPtr->flags \|= UPDATE_H_SCROLLBAR;
1164	EventuallyRedraw(dvPtr);
1165	}
1166	}
1167	return TCL_OK;
1168	}
1169
1170	/*
1171	* ----------------------------------------------------------------------
1172	* DiffviewYviewSubCmd()
1173	*
1174	* Handles the "yview" operation on the widget. Adjusts the y-axis view
1175	* according to some request, which usually comes from a scrollbar.
1176	* Supports the standard Tk operations for "yview".
1177	* ----------------------------------------------------------------------
1178	*/
1179	static int
1180	DiffviewYviewSubCmd(interp, dvPtr, objc, objv)
1181	Tcl_Interp interp; / interp handling this command */
1182	Diffview dvPtr; / widget data */
1183	int objc; /* number of command arguments */
1184	Tcl_Obj CONST objv[]; / command arguments */
1185	{
1186	int index, yLines, count, type;
1187	double fraction, fraction2;
1188
1189	/* make sure that our layout info is up to date */
1190	DiffviewUpdateLayout(dvPtr);
1191
1192	if (objc == 2) {
1193	/*
1194	* COMMAND: widget yview
1195	* return current limits as fractions 0-1
1196	*/
1197	if (dvPtr->maxHeight == 0) {
1198	Tcl_SetResult(interp, "0 1", TCL_STATIC);
1199	} else {
1200	char buf[TCL_DOUBLE_SPACE * 2+2];
1201
1202	yLines = dvPtr->maxHeight/dvPtr->lineHeight;
1203	fraction = dvPtr->topLine/((double)yLines);
1204	fraction2 = (dvPtr->topLine+dvPtr->fullLines)/((double)yLines);
1205	if (fraction2 > 1.0) {
1206	fraction2 = 1.0;
1207	}
1208	sprintf(buf, "%g %g", fraction, fraction2);
1209	Tcl_SetResult(interp, buf, TCL_VOLATILE);
1210	}
1211	} else if (objc == 3) {
1212	/*
1213	* COMMAND: widget yview index
1214	* set top edge to line at index
1215	*/
1216	if (Tcl_GetIntFromObj(interp, objv[2], &index) != TCL_OK) {
1217	return TCL_ERROR;
1218	}
1219	ChangeDiffviewView(dvPtr, index);
1220	} else {
1221	/*
1222	* COMMAND: widget yview moveto fraction
1223	* COMMAND: widget yview scroll number what
1224	* handles more complex scrolling movements
1225	*/
1226	type = Tk_GetScrollInfoObj(interp, objc, objv, &fraction, &count);
1227	switch (type) {
1228	case TK_SCROLL_ERROR:
1229	return TCL_ERROR;
1230	case TK_SCROLL_MOVETO:
1231	yLines = dvPtr->maxHeight/dvPtr->lineHeight;
1232	index = (int)(yLines*fraction + 0.5);
1233	break;
1234	case TK_SCROLL_PAGES:
1235	yLines = dvPtr->maxHeight/dvPtr->lineHeight;
1236	if (dvPtr->fullLines > 2) {
1237	index = dvPtr->topLine + count*(dvPtr->fullLines-2);
1238	} else {
1239	index = dvPtr->topLine + count;
1240	}
1241	break;
1242	case TK_SCROLL_UNITS:
1243	index = dvPtr->topLine + count;
1244	break;
1245	}
1246	ChangeDiffviewView(dvPtr, index);
1247	}
1248	return TCL_OK;
1249	}
1250
1251	/*
1252	* ----------------------------------------------------------------------
1253	* DiffviewGetIndex()
1254	*
1255	* Used by many of the widget operations to parse an index into the
1256	* widget view. Handles the following syntax:
1257	* #NN ...... particular diff number, starting from 1
1258	* NN ....... particular line number in world view, starting from 0
1259	*
1260	* Returns TCL_OK if successful, and TCL_ERROR (along with an error
1261	* message) if anything goes wrong.
1262	* ----------------------------------------------------------------------
1263	*/
1264	static int
1265	DiffviewGetIndex(interp, dvPtr, objPtr, linePtr, diffOpPtrPtr)
1266	Tcl_Interp interp; / interp handling this command */
1267	Diffview dvPtr; / widget data */
1268	Tcl_Obj objPtr; / argument being parsed */
1269	int linePtr; / returns: line number or -1 */
1270	DiffviewDiffOp *diffOpPtrPtr; / returns: specific diff or NULL */
1271	{
1272	int result = TCL_OK;
1273	char *opt = Tcl_GetString(objPtr);
1274	char *tail;
1275	int dnum;
1276
1277	/* clear the return values */
1278	if (linePtr) *linePtr = -1;
1279	if (diffOpPtrPtr) *diffOpPtrPtr = NULL;
1280
1281	if (*opt == '#') {
1282	dnum = strtol(opt+1, &tail, 10);
1283	if (*tail != '\0' \|\| dnum <= 0) {
1284	result = TCL_ERROR;
1285	}
1286	else if (dvPtr->diffsPtr == NULL
1287	\|\| dnum > dvPtr->diffsPtr->numDiffs) {
1288	Tcl_AppendResult(interp, "diff \"", opt, "\" doesn't exist",
1289	(char*)NULL);
1290	return TCL_ERROR;
1291	}
1292	*diffOpPtrPtr = &dvPtr->diffsPtr->ops[dnum-1];
1293	} else {
1294	result = Tcl_GetIntFromObj(interp, objPtr, linePtr);
1295	}
1296
1297	if (result != TCL_OK) {
1298	Tcl_ResetResult(interp);
1299	Tcl_AppendResult(interp, "bad index \"", opt, "\": should be "
1300	"\"#n\" for diff, or an integer value for line number",
1301	(char*)NULL);
1302	}
1303	return result;
1304	}
1305
1306	/*
1307	* ----------------------------------------------------------------------
1308	* DestroyDiffview()
1309	*
1310	* Used by Tcl_Release/Tcl_EventuallyFree to clean up the data associated
1311	* with a widget when it is no longer being used. This happens at the
1312	* end of a widget destruction sequence.
1313	* ----------------------------------------------------------------------
1314	*/
1315	static void
1316	DestroyDiffview(memPtr)
1317	char memPtr; / widget data */
1318	{
1319	Diffview dvPtr = (Diffview)memPtr;
1320	int bnum;
1321
1322	/*
1323	* Clean up text associated with the diffs.
1324	*/
1325	for (bnum=0; bnum < 2; bnum++) {
1326	if (dvPtr->buffer[bnum].textObj != NULL) {
1327	Tcl_DecrRefCount(dvPtr->buffer[bnum].textObj);
1328	}
1329	if (dvPtr->buffer[bnum].lineLimits != NULL) {
1330	DiffviewLinesFree(dvPtr->buffer[bnum].lineLimits);
1331	}
1332	}
1333
1334	if (dvPtr->diffsPtr) {
1335	DiffviewDiffsFree(dvPtr->diffsPtr);
1336	}
1337	DiffviewLayoutFree(&dvPtr->worldview);
1338
1339	/*
1340	* Free up GCs and configuration options.
1341	*/
1342	if (dvPtr->normGC != None) {
1343	Tk_FreeGC(dvPtr->display, dvPtr->normGC);
1344	}
1345	if (dvPtr->addFgGC != None) {
1346	Tk_FreeGC(dvPtr->display, dvPtr->addFgGC);
1347	}
1348	if (dvPtr->delFgGC != None) {
1349	Tk_FreeGC(dvPtr->display, dvPtr->delFgGC);
1350	}
1351	if (dvPtr->chgFgGC != None) {
1352	Tk_FreeGC(dvPtr->display, dvPtr->chgFgGC);
1353	}
1354
1355	Tk_FreeConfigOptions((char*)dvPtr, dvPtr->optionTable, dvPtr->tkwin);
1356	Tcl_Release((ClientData) dvPtr->tkwin);
1357	dvPtr->tkwin = NULL;
1358	ckfree((char*)dvPtr);
1359	}
1360
1361	/*
1362	* ----------------------------------------------------------------------
1363	* ConfigureDiffview()
1364	*
1365	* Takes a list of configuration options in objc/objv format and applies
1366	* the settings to the widget. This is the underlying "configure"
1367	* operation for the widget.
1368	* ----------------------------------------------------------------------
1369	*/
1370	static int
1371	ConfigureDiffview(interp, dvPtr, objc, objv, flags)
1372	Tcl_Interp interp; / interp handling this command */
1373	Diffview dvPtr; / widget data */
1374	int objc; /* number of configuration option words */
1375	Tcl_Obj CONST objv[]; / configuration option words */
1376	int flags; /* flags for Tk_ConfigureWidget */
1377	{
1378	Tcl_Obj *errorResult = NULL;
1379	int status;
1380	Tk_SavedOptions savedOptions;
1381
1382	status = Tk_SetOptions(interp, (char*)dvPtr, dvPtr->optionTable,
1383	objc, objv, dvPtr->tkwin, &savedOptions, (int*)NULL);
1384
1385	if (status != TCL_OK) {
1386	errorResult = Tcl_GetObjResult(interp);
1387	Tcl_IncrRefCount(errorResult);
1388	Tk_RestoreSavedOptions(&savedOptions);
1389
1390	Tcl_SetObjResult(interp, errorResult);
1391	Tcl_DecrRefCount(errorResult);
1392	return TCL_ERROR;
1393	}
1394
1395	/*
1396	* Fix up the widget to react to any new configuration values.
1397	*/
1398	Tk_SetBackgroundFromBorder(dvPtr->tkwin, dvPtr->normalBorder);
1399
1400	if (dvPtr->highlightWidth < 0) {
1401	dvPtr->highlightWidth = 0;
1402	}
1403	dvPtr->inset = dvPtr->highlightWidth + dvPtr->borderWidth;
1404
1405	if (dvPtr->tklastfont != dvPtr->tkfont) {
1406	/* the font changed, so re-measure everything */
1407	dvPtr->flags \|= FONT_CHANGED;
1408	dvPtr->tklastfont = dvPtr->tkfont;
1409	}
1410
1411	Tk_FreeSavedOptions(&savedOptions);
1412
1413	DiffviewWorldChanged((ClientData)dvPtr);
1414	return TCL_OK;
1415	}
1416
1417	/*
1418	* ----------------------------------------------------------------------
1419	* DiffviewWorldChanged()
1420	*
1421	* Called by Tk when the world has changed in some way that causes
1422	* all GCs and other things to be recomputed. Reinitializes the
1423	* widget and gets it ready to draw.
1424	* ----------------------------------------------------------------------
1425	*/
1426	static void
1427	DiffviewWorldChanged(cdata)
1428	ClientData cdata; /* widget data */
1429	{
1430	Diffview dvPtr = (Diffview)cdata;
1431	GC gc; XGCValues gcValues;
1432	unsigned long mask;
1433
1434	/* GC for normal widget text */
1435	gcValues.foreground = dvPtr->fgColorPtr->pixel;
1436	gcValues.graphics_exposures = False;
1437	gcValues.font = Tk_FontId(dvPtr->tkfont);
1438	mask = GCForeground \| GCFont \| GCGraphicsExposures;
1439
1440	gc = Tk_GetGC(dvPtr->tkwin, mask, &gcValues);
1441	if (dvPtr->normGC != None) {
1442	Tk_FreeGC(dvPtr->display, dvPtr->normGC);
1443	}
1444	dvPtr->normGC = gc;
1445
1446	/* GC for added diff text */
1447	gcValues.foreground = dvPtr->addFgColorPtr->pixel;
1448	gcValues.graphics_exposures = False;
1449	gcValues.font = Tk_FontId(dvPtr->tkfont);
1450	mask = GCForeground \| GCFont \| GCGraphicsExposures;
1451
1452	gc = Tk_GetGC(dvPtr->tkwin, mask, &gcValues);
1453	if (dvPtr->addFgGC != None) {
1454	Tk_FreeGC(dvPtr->display, dvPtr->addFgGC);
1455	}
1456	dvPtr->addFgGC = gc;
1457
1458	/* GC for deleted diff text */
1459	gcValues.foreground = dvPtr->delFgColorPtr->pixel;
1460	gcValues.graphics_exposures = False;
1461	gcValues.font = Tk_FontId(dvPtr->tkfont);
1462	mask = GCForeground \| GCFont \| GCGraphicsExposures;
1463
1464	gc = Tk_GetGC(dvPtr->tkwin, mask, &gcValues);
1465	if (dvPtr->delFgGC != None) {
1466	Tk_FreeGC(dvPtr->display, dvPtr->delFgGC);
1467	}
1468	dvPtr->delFgGC = gc;
1469
1470	/* GC for changed diff text */
1471	gcValues.foreground = dvPtr->chgFgColorPtr->pixel;
1472	gcValues.graphics_exposures = False;
1473	gcValues.font = Tk_FontId(dvPtr->tkfont);
1474	mask = GCForeground \| GCFont \| GCGraphicsExposures;
1475
1476	gc = Tk_GetGC(dvPtr->tkwin, mask, &gcValues);
1477	if (dvPtr->chgFgGC != None) {
1478	Tk_FreeGC(dvPtr->display, dvPtr->chgFgGC);
1479	}
1480	dvPtr->chgFgGC = gc;
1481
1482	/* this call comes when the font changes -- fix the layout */
1483	dvPtr->flags \|= FONT_CHANGED;
1484
1485	/* get ready to redraw */
1486	DiffviewComputeGeometry(dvPtr);
1487	dvPtr->flags \|= UPDATE_V_SCROLLBAR\|UPDATE_H_SCROLLBAR;
1488	EventuallyRedraw(dvPtr);
1489	}
1490
1491	/*
1492	* ----------------------------------------------------------------------
1493	* EventuallyRedraw()
1494	*
1495	* Arranges for the widget to redraw itself at the next idle point.
1496	* ----------------------------------------------------------------------
1497	*/
1498	static void
1499	EventuallyRedraw(dvPtr)
1500	Diffview dvPtr; / widget data */
1501	{
1502	if ((dvPtr->flags & REDRAW_PENDING) \|\| (dvPtr->flags & WIDGET_DELETED)
1503	\|\| !Tk_IsMapped(dvPtr->tkwin)) {
1504	return; /* no need to redraw */
1505	}
1506
1507	dvPtr->flags \|= REDRAW_PENDING;
1508	Tcl_DoWhenIdle(DisplayDiffview, (ClientData)dvPtr);
1509	}
1510
1511	/*
1512	* ----------------------------------------------------------------------
1513	* DisplayDiffview()
1514	*
1515	* Redraws the widget based on the current view and all data.
1516	* ----------------------------------------------------------------------
1517	*/
1518	static void
1519	DisplayDiffview(cdata)
1520	ClientData cdata; /* widget data */
1521	{
1522	Diffview dvPtr = (Diffview)cdata;
1523	Tk_Window tkwin = dvPtr->tkwin;
1524
1525	int i, bnum, bline, x, xw, y, ymid, width;
1526	char *textPtr; int textLen;
1527	Pixmap pixmap;
1528	GC bg, fg;
1529
1530	/* handling redraw now -- no longer pending */
1531	dvPtr->flags &= ~REDRAW_PENDING;
1532
1533	if (dvPtr->flags & WIDGET_DELETED) {
1534	/* widget is being torn down -- bail out! */
1535	return;
1536	}
1537
1538	/* handle any pending layout changes */
1539	DiffviewUpdateLayout(dvPtr);
1540
1541	/*
1542	* Hang onto the widget data until we're done updating scrollbars.
1543	* The -xscrollcommand and -yscrollcommand options may take us into
1544	* code that deletes the widget.
1545	*/
1546	Tcl_Preserve((ClientData)dvPtr);
1547
1548	if (dvPtr->flags & UPDATE_V_SCROLLBAR) {
1549	DiffviewUpdateVScrollbar(dvPtr);
1550	if ((dvPtr->flags & WIDGET_DELETED) \|\| !Tk_IsMapped(tkwin)) {
1551	Tcl_Release((ClientData)dvPtr);
1552	return;
1553	}
1554	}
1555	if (dvPtr->flags & UPDATE_H_SCROLLBAR) {
1556	DiffviewUpdateHScrollbar(dvPtr);
1557	if ((dvPtr->flags & WIDGET_DELETED) \|\| !Tk_IsMapped(tkwin)) {
1558	Tcl_Release((ClientData)dvPtr);
1559	return;
1560	}
1561	}
1562	dvPtr->flags &= ~(REDRAW_PENDING\|UPDATE_V_SCROLLBAR\|UPDATE_H_SCROLLBAR);
1563	Tcl_Release((ClientData)dvPtr);
1564
1565	#ifndef TK_NO_DOUBLE_BUFFERING
1566	/*
1567	* Best solution is to draw everything into a temporary pixmap
1568	* and copy that to the screen in one shot. That avoids flashing.
1569	*/
1570	pixmap = Tk_GetPixmap(dvPtr->display, Tk_WindowId(tkwin),
1571	Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
1572	#else
1573	pixmap = Tk_WindowId(tkwin);
1574	#endif
1575
1576	Tk_Fill3DRectangle(tkwin, pixmap, dvPtr->normalBorder, 0, 0,
1577	Tk_Width(tkwin), Tk_Height(tkwin), 0, TK_RELIEF_FLAT);
1578
1579	/*
1580	* Find the top line in the view in each buffer
1581	*/
1582	y = dvPtr->inset + dvPtr->topLine*dvPtr->lineHeight + dvPtr->lineAscent
1583	- dvPtr->yOffset;
1584	x = dvPtr->inset - dvPtr->xOffset;
1585
1586	if (Tk_Width(tkwin) > dvPtr->maxWidth) {
1587	width = Tk_Width(tkwin)+10;
1588	} else {
1589	width = dvPtr->maxWidth+10;
1590	}
1591
1592	for (i=dvPtr->topLine;
1593	i <= dvPtr->btmLine && i < dvPtr->worldview.numLines;
1594	i++) {
1595
1596	/* draw any diff rectangle for this line */
1597	fg = dvPtr->normGC;
1598	bg = None;
1599
1600	switch (dvPtr->worldview.lines[i].style) {
1601	case 'a': {
1602	fg = dvPtr->addFgGC;
1603	bg = Tk_GCForColor(dvPtr->addBgColorPtr, pixmap);
1604	break;
1605	}
1606	case 'd': {
1607	fg = dvPtr->delFgGC;
1608	bg = Tk_GCForColor(dvPtr->delBgColorPtr, pixmap);
1609	break;
1610	}
1611	case 'c': {
1612	fg = dvPtr->chgFgGC;
1613	bg = Tk_GCForColor(dvPtr->chgBgColorPtr, pixmap);
1614	break;
1615	}
1616	}
1617
1618	if (bg != None) {
1619	XFillRectangle(Tk_Display(tkwin), pixmap, bg,
1620	x, y - dvPtr->lineAscent,
1621	(unsigned int)width, (unsigned int)dvPtr->lineHeight);
1622	}
1623
1624	bnum = dvPtr->worldview.lines[i].bnum;
1625	bline = dvPtr->worldview.lines[i].bline;
1626
1627	/* a negative number means "leave the line blank" */
1628	if (bline >= 0) {
1629	textPtr = dvPtr->buffer[bnum].lineLimits->startPtr[bline];
1630	textLen = dvPtr->buffer[bnum].lineLimits->lenPtr[bline];
1631
1632	/* Draw the actual text of this item */
1633	Tk_DrawChars(dvPtr->display, pixmap, fg, dvPtr->tkfont,
1634	textPtr, textLen, x, y);
1635
1636	/* Draw an overstrike on deleted text */
1637	if (dvPtr->worldview.lines[i].style == 'd' && dvPtr->overStrDel) {
1638	xw = Tk_TextWidth(dvPtr->tkfont, textPtr, textLen) + 5;
1639	ymid = y - dvPtr->lineAscent/2;
1640	XDrawLine(Tk_Display(tkwin), pixmap, fg, 0, ymid, xw, ymid);
1641	}
1642	}
1643
1644	y += dvPtr->lineHeight;
1645	}
1646
1647	/*
1648	* Draw the border on top so that it covers any characters that
1649	* have scrolled off screen.
1650	*/
1651	Tk_Draw3DRectangle(tkwin, pixmap, dvPtr->normalBorder,
1652	dvPtr->highlightWidth, dvPtr->highlightWidth,
1653	Tk_Width(tkwin) - 2*dvPtr->highlightWidth,
1654	Tk_Height(tkwin) - 2*dvPtr->highlightWidth,
1655	dvPtr->borderWidth, dvPtr->relief);
1656
1657	if (dvPtr->highlightWidth > 0) {
1658	XColor *color; GC gc;
1659
1660	color = (dvPtr->flags & GOT_FOCUS)
1661	? dvPtr->highlightColor : dvPtr->highlightBgColor;
1662	gc = Tk_GCForColor(color, pixmap);
1663	Tk_DrawFocusHighlight(dvPtr->tkwin, gc, dvPtr->highlightWidth, pixmap);
1664	}
1665
1666	#ifndef TK_NO_DOUBLE_BUFFERING
1667	XCopyArea(dvPtr->display, pixmap, Tk_WindowId(tkwin),
1668	dvPtr->normGC, 0, 0, (unsigned) Tk_Width(tkwin),
1669	(unsigned) Tk_Height(tkwin), 0, 0);
1670	Tk_FreePixmap(dvPtr->display, pixmap);
1671	#endif
1672	}
1673
1674	/*
1675	* ----------------------------------------------------------------------
1676	* DiffviewComputeGeometry()
1677	*
1678	* Recomputes the overall dimensions of the widget when the overall
1679	* size or the borderwidth is changed. Registers a new size for the
1680	* widget.
1681	* ----------------------------------------------------------------------
1682	*/
1683	static void
1684	DiffviewComputeGeometry(dvPtr)
1685	Diffview dvPtr; / widget data */
1686	{
1687	int pixelWidth, pixelHeight;
1688
1689	dvPtr->xScrollUnit = Tk_TextWidth(dvPtr->tkfont, "0", 1);
1690	if (dvPtr->xScrollUnit == 0) {
1691	dvPtr->xScrollUnit = 1;
1692	}
1693
1694	pixelWidth = dvPtr->width + 2*dvPtr->inset;
1695	pixelHeight = dvPtr->height + 2*dvPtr->inset;
1696	Tk_GeometryRequest(dvPtr->tkwin, pixelWidth, pixelHeight);
1697	Tk_SetInternalBorder(dvPtr->tkwin, dvPtr->inset);
1698	}
1699
1700	/*
1701	* ----------------------------------------------------------------------
1702	* DiffviewEventProc()
1703	*
1704	* Catches important events on the widget and causes it to redraw
1705	* itself and react to focus changes.
1706	* ----------------------------------------------------------------------
1707	*/
1708	static void
1709	DiffviewEventProc(cdata, eventPtr)
1710	ClientData cdata; /* widget data */
1711	XEvent eventPtr; / event information coming from X11 */
1712	{
1713	Diffview dvPtr = (Diffview)cdata;
1714
1715	if (eventPtr->type == Expose) {
1716	EventuallyRedraw(dvPtr);
1717	}
1718	else if (eventPtr->type == DestroyNotify) {
1719	if (!(dvPtr->flags & WIDGET_DELETED)) {
1720	dvPtr->flags \|= WIDGET_DELETED;
1721	Tcl_DeleteCommandFromToken(dvPtr->interp, dvPtr->widgetCmd);
1722	if (dvPtr->flags & REDRAW_PENDING) {
1723	Tcl_CancelIdleCall(DisplayDiffview, cdata);
1724	}
1725	Tcl_EventuallyFree(cdata, DestroyDiffview);
1726	}
1727	}
1728	else if (eventPtr->type == ConfigureNotify) {
1729	dvPtr->flags \|= UPDATE_V_SCROLLBAR\|UPDATE_H_SCROLLBAR;
1730	ChangeDiffviewView(dvPtr, dvPtr->topLine);
1731	EventuallyRedraw(dvPtr);
1732	}
1733	else if (eventPtr->type == FocusIn) {
1734	if (eventPtr->xfocus.detail != NotifyInferior) {
1735	dvPtr->flags \|= GOT_FOCUS;
1736	EventuallyRedraw(dvPtr);
1737	}
1738	}
1739	else if (eventPtr->type == FocusOut) {
1740	if (eventPtr->xfocus.detail != NotifyInferior) {
1741	dvPtr->flags &= ~GOT_FOCUS;
1742	EventuallyRedraw(dvPtr);
1743	}
1744	}
1745	}
1746
1747	/*
1748	* ----------------------------------------------------------------------
1749	* DiffviewCmdDeletedProc --
1750	*
1751	* Invoked whenever the command associated with the widget is deleted.
1752	* If the widget is not already being destroyed, this starts the process.
1753	* ----------------------------------------------------------------------
1754	*/
1755	static void
1756	DiffviewCmdDeletedProc(cdata)
1757	ClientData cdata; /* widget data */
1758	{
1759	Diffview dvPtr = (Diffview)cdata;
1760
1761	/*
1762	* This gets invoked whenever the command is deleted. If we haven't
1763	* started destroying the widget yet, then do it now to clean up.
1764	*/
1765	if (!(dvPtr->flags & WIDGET_DELETED)) {
1766	Tk_DestroyWindow(dvPtr->tkwin);
1767	}
1768	}
1769
1770	/*
1771	* ----------------------------------------------------------------------
1772	* ChangeDiffviewView()
1773	*
1774	* Changes the y-view of the widget for scrolling operations. Sets the
1775	* given line to the top of the view.
1776	* ----------------------------------------------------------------------
1777	*/
1778	static void
1779	ChangeDiffviewView(dvPtr, lnum)
1780	Diffview dvPtr; / widget data */
1781	int lnum; /* this line should appear at the top */
1782	{
1783	int maxLines, ySize, yLines;
1784
1785	DiffviewUpdateLayout(dvPtr);
1786	ySize = Tk_Height(dvPtr->tkwin) - 2*dvPtr->inset;
1787	yLines = ySize/dvPtr->lineHeight;
1788	maxLines = dvPtr->maxHeight/dvPtr->lineHeight;
1789
1790	if (lnum >= (maxLines - yLines)) {
1791	lnum = maxLines - yLines;
1792	}
1793	if (lnum < 0) {
1794	lnum = 0;
1795	}
1796	if (dvPtr->topLine != lnum) {
1797	dvPtr->topLine = lnum;
1798	dvPtr->yOffset = lnum * dvPtr->lineHeight;
1799	EventuallyRedraw(dvPtr);
1800	dvPtr->flags \|= UPDATE_V_SCROLLBAR;
1801	}
1802	}
1803
1804	/*
1805	* ----------------------------------------------------------------------
1806	* DiffviewScanTo()
1807	*
1808	* Implements the "scan dragto" operation on the widget. Given a
1809	* starting point from the "scan mark" operation, this adjusts the
1810	* view to the given location.
1811	* ----------------------------------------------------------------------
1812	*/
1813	static void
1814	DiffviewScanTo(dvPtr, x, y)
1815	Diffview dvPtr; / widget data */
1816	int x; /* x-coord for drag-to location */
1817	int y; /* y-coord for drag-to location */
1818	{
1819	int newTopLine, newOffset, maxLine, maxOffset;
1820
1821	/*
1822	* Compute the top line for the display by amplifying the difference
1823	* between the current "drag" point and the original "start" point.
1824	*/
1825	maxLine = dvPtr->maxHeight/dvPtr->lineHeight - dvPtr->fullLines;
1826
1827	newTopLine = dvPtr->scanMarkYStart
1828	- (10*(y - dvPtr->scanMarkY))/dvPtr->lineHeight;
1829
1830	if (newTopLine > maxLine) {
1831	newTopLine = dvPtr->scanMarkYStart = maxLine;
1832	dvPtr->scanMarkY = y;
1833	}
1834	else if (newTopLine < 0) {
1835	newTopLine = dvPtr->scanMarkYStart = 0;
1836	dvPtr->scanMarkY = y;
1837	}
1838	ChangeDiffviewView(dvPtr, newTopLine);
1839
1840	/*
1841	* Compute the left edge for the display by amplifying the difference
1842	* between the current "drag" point and the original "start" point.
1843	*/
1844	maxOffset = dvPtr->maxWidth - (Tk_Width(dvPtr->tkwin) - 2*dvPtr->inset);
1845	newOffset = dvPtr->scanMarkXStart - (10*(x - dvPtr->scanMarkX));
1846	if (newOffset > maxOffset) {
1847	newOffset = dvPtr->scanMarkXStart = maxOffset;
1848	dvPtr->scanMarkX = x;
1849	} else if (newOffset < 0) {
1850	newOffset = dvPtr->scanMarkXStart = 0;
1851	dvPtr->scanMarkX = x;
1852	}
1853	newOffset -= newOffset % dvPtr->xScrollUnit;
1854
1855	if (newOffset != dvPtr->xOffset) {
1856	dvPtr->xOffset = newOffset;
1857	dvPtr->flags \|= UPDATE_H_SCROLLBAR;
1858	EventuallyRedraw(dvPtr);
1859	}
1860	}
1861
1862	/*
1863	* ----------------------------------------------------------------------
1864	* DiffviewUpdateLayout()
1865	*
1866	* Called whenever the widget is about to access layout information
1867	* to make sure that the latest info is in place and up-to-date.
1868	* Computes the line start/end for each line in each buffer, then
1869	* computes the diffs and figures out how many lines to show.
1870	* ----------------------------------------------------------------------
1871	*/
1872	static void
1873	DiffviewUpdateLayout(dvPtr)
1874	Diffview dvPtr; / widget data */
1875	{
1876	int changes = 0; /* no layout changes yet */
1877	DiffviewBuffer* bufferPtr;
1878	DiffviewDiffOp *currOp;
1879	DiffviewLayoutLine line;
1880	int i, bnum, bline, pixelWidth, maxWidth, ySize;
1881	int numLines1, numLines2, lnum1, lnum2, dnum, lastdnum, pastDiff;
1882	char textPtr, textPtr2; int textLen;
1883	Tk_FontMetrics fm;
1884
1885	/* if the font changed, then re-measure everything */
1886	changes = ((dvPtr->flags & FONT_CHANGED) != 0);
1887
1888	/* fill in line limits for any new data */
1889	for (bnum=0; bnum < 2; bnum++) {
1890	bufferPtr = &dvPtr->buffer[bnum];
1891
1892	if (bufferPtr->textObj != NULL && bufferPtr->lineLimits == NULL) {
1893	textPtr = Tcl_GetStringFromObj(bufferPtr->textObj, &textLen);
1894	bufferPtr->lineLimits = DiffviewLinesCreate(textPtr, textLen);
1895	changes = 1;
1896	}
1897	}
1898
1899	if (changes) {
1900	/* recompute the diffs between the buffers */
1901	if (dvPtr->diffsPtr) {
1902	DiffviewDiffsFree(dvPtr->diffsPtr);
1903	dvPtr->diffsPtr = NULL;
1904	}
1905
1906	if (dvPtr->buffer[0].textObj && dvPtr->buffer[1].textObj) {
1907	textPtr = Tcl_GetStringFromObj(dvPtr->buffer[0].textObj, &textLen);
1908	textPtr2 = Tcl_GetStringFromObj(dvPtr->buffer[1].textObj, &textLen);
1909
1910	dvPtr->diffsPtr = DiffviewDiffsCreate(
1911	textPtr, dvPtr->buffer[0].lineLimits,
1912	textPtr2, dvPtr->buffer[1].lineLimits);
1913	}
1914
1915	/*
1916	* Compute the layout of all lines according to the current
1917	* view mode. Each line in the world view is stored in the
1918	* array dvPtr->worldview.lines. Each line has a style (color
1919	* for normal, add, delete, etc.) and an indication of which
1920	* buffer it comes from.
1921	*/
1922	DiffviewLayoutClear(&dvPtr->worldview);
1923
1924	/*
1925	* March through the lines and figure out the source and style
1926	* of each line based on the diffs:
1927	* 'n' = normal (common) line
1928	* 'a' = draw with the "added" style
1929	* 'd' = draw with the "deleted" style
1930	* 'c' = draw with the "changed" style
1931	*/
1932	numLines1 = (dvPtr->buffer[0].lineLimits)
1933	? dvPtr->buffer[0].lineLimits->numLines : 0;
1934	numLines2 = (dvPtr->buffer[1].lineLimits)
1935	? dvPtr->buffer[1].lineLimits->numLines : 0;
1936
1937	dnum = 0; /* current difference in diffsPtr */
1938	lnum1 = lnum2 = 0;
1939
1940	while (lnum1 < numLines1 \|\| lnum2 < numLines2) {
1941	/* assume it's a normal-looking line (buffers are the same) */
1942	line.style = 'n';
1943	line.bnum = 0;
1944	line.bline = lnum1;
1945	line.diffNum = -1;
1946
1947	/* is there a diff that contains this line? */
1948	if (dvPtr->diffsPtr && dnum < dvPtr->diffsPtr->numDiffs) {
1949	currOp = &dvPtr->diffsPtr->ops[dnum];
1950
1951	if ( (lnum1 >= currOp->fromIndex1
1952	&& lnum1 <= currOp->toIndex1)
1953	\|\| (lnum2 >= currOp->fromIndex2
1954	&& lnum2 <= currOp->toIndex2) ) {
1955
1956	line.diffNum = dnum; /* line is part of this diff */
1957
1958	switch (currOp->op) {
1959	case 'c': {
1960	if (dvPtr->layout == LAYOUT_INLINE) {
1961	if (dvPtr->diffdir == DIFF_1TO2) {
1962	/* show the buffer #1 lines first, then #2 */
1963	if (lnum1 <= currOp->toIndex1) {
1964	line.style = 'd';
1965	line.bnum = 0;
1966	line.bline = lnum1++;
1967	} else {
1968	line.style = 'a';
1969	line.bnum = 1;
1970	line.bline = lnum2++;
1971	}
1972	} else {
1973	/* reverse -- show #2 lines first, then #1 */
1974	if (lnum2 <= currOp->toIndex2) {
1975	line.style = 'd';
1976	line.bnum = 1;
1977	line.bline = lnum2++;
1978	} else {
1979	line.style = 'a';
1980	line.bnum = 0;
1981	line.bline = lnum1++;
1982	}
1983	}
1984	} else {
1985	if (dvPtr->diffdir == DIFF_1TO2) {
1986	/* show final lines in buf #2 as "changed" */
1987	line.style = 'c';
1988	line.bnum = 1;
1989	line.bline = lnum2++;
1990	lnum1 = currOp->toIndex1+1;
1991	} else {
1992	/* show final lines in buf #1 as "changed" */
1993	line.style = 'c';
1994	line.bnum = 0;
1995	line.bline = lnum1++;
1996	lnum2 = currOp->toIndex2+1;
1997	}
1998	}
1999	break;
2000	}
2001	case 'a': {
2002	if (dvPtr->diffdir == DIFF_1TO2) {
2003	/* show lines in buffer #2 as 'added' */
2004	line.style = 'a';
2005	line.bnum = 1;
2006	line.bline = lnum2++;
2007	lnum1 = currOp->toIndex1;
2008	} else {
2009	/* reverse diff -- like we're deleting lines */
2010	if (dvPtr->layout == LAYOUT_INLINE) {
2011	line.style = 'd';
2012	line.bnum = 1;
2013	line.bline = lnum2++;
2014	lnum1 = currOp->toIndex1;
2015	} else {
2016	/* show lines from buffer #2 as empty */
2017	line.style = 'd';
2018	line.bnum = 0;
2019	line.bline = -1;
2020	lnum2++;
2021	lnum1 = currOp->toIndex1;
2022	}
2023	}
2024	break;
2025	}
2026	case 'd': {
2027	if (dvPtr->diffdir == DIFF_1TO2) {
2028	if (dvPtr->layout == LAYOUT_INLINE) {
2029	line.style = 'd';
2030	line.bnum = 0;
2031	line.bline = lnum1++;
2032	lnum2 = currOp->toIndex2;
2033	} else {
2034	/* show lines from buffer #2 as empty */
2035	line.style = 'd';
2036	line.bnum = 0;
2037	line.bline = -1;
2038	lnum1++;
2039	lnum2 = currOp->toIndex2;
2040	}
2041	} else {
2042	/* reverse diff -- like we're adding lines */
2043	line.style = 'a';
2044	line.bnum = 0;
2045	line.bline = lnum1++;
2046	lnum2 = currOp->toIndex2;
2047	}
2048	break;
2049	}
2050	default: {
2051	Tcl_Panic("bad diff type '%c' found in layout",
2052	currOp->op);
2053	break;
2054	}
2055	}
2056	} else {
2057	/* normal line -- keep moving forward */
2058	lnum1++; lnum2++;
2059	}
2060
2061	/* have we reached the end of the diff? then move on */
2062	pastDiff = 0;
2063	switch (currOp->op) {
2064	case 'c':
2065	pastDiff = (lnum1 > currOp->toIndex1
2066	&& lnum2 > currOp->toIndex2);
2067	break;
2068	case 'a':
2069	pastDiff = (lnum2 > currOp->toIndex2);
2070	break;
2071	case 'd':
2072	pastDiff = (lnum1 > currOp->toIndex1);
2073	break;
2074	}
2075	if (pastDiff) {
2076	dnum++;
2077	}
2078	} else {
2079	/* no more diffs -- keep moving forward */
2080	lnum1++; lnum2++;
2081	}
2082
2083	/* add this new line to the layout */
2084	DiffviewLayoutAdd(&dvPtr->worldview, &line);
2085	}
2086
2087	/*
2088	* Figure out where the diffs are located, and put that info
2089	* back into the diffs. This makes it easy later to refer to
2090	* diff "#3" and understand what lines we're talking about.
2091	*/
2092	lastdnum = -1;
2093	for (i=0; i < dvPtr->worldview.numLines; i++) {
2094	dnum = dvPtr->worldview.lines[i].diffNum;
2095	if (dnum != lastdnum) {
2096	if (lastdnum < 0) {
2097	/* leading edge -- catch the "from" line */
2098	lnum1 = i;
2099	} else {
2100	/* trailing edge -- save diff info */
2101	dvPtr->diffsPtr->ops[lastdnum].fromWorld = lnum1;
2102	dvPtr->diffsPtr->ops[lastdnum].toWorld = i-1;
2103	}
2104	}
2105	lastdnum = dnum;
2106	}
2107	if (lastdnum >= 0) {
2108	dvPtr->diffsPtr->ops[lastdnum].fromWorld = lnum1;
2109	dvPtr->diffsPtr->ops[lastdnum].toWorld = i-1;
2110	}
2111
2112	/* compute overall text width for all lines */
2113	maxWidth = 0;
2114	for (i=0; i < dvPtr->worldview.numLines; i++) {
2115	bline = dvPtr->worldview.lines[i].bline;
2116	if (bline >= 0) {
2117	bnum = dvPtr->worldview.lines[i].bnum;
2118	bufferPtr = &dvPtr->buffer[bnum];
2119
2120	if (bufferPtr->lineLimits) {
2121	textPtr = bufferPtr->lineLimits->startPtr[bline];
2122	textLen = bufferPtr->lineLimits->lenPtr[bline];
2123	pixelWidth = Tk_TextWidth(dvPtr->tkfont, textPtr, textLen);
2124
2125	if (pixelWidth > maxWidth) {
2126	maxWidth = pixelWidth;
2127	}
2128	}
2129	}
2130	}
2131	dvPtr->maxWidth = maxWidth;
2132
2133	/* compute overall height of the widget */
2134	Tk_GetFontMetrics(dvPtr->tkfont, &fm);
2135	dvPtr->lineHeight = fm.linespace;
2136	dvPtr->lineAscent = fm.ascent;
2137	dvPtr->maxHeight = dvPtr->worldview.numLines * fm.linespace;
2138
2139	/* figure out the limits of the current view */
2140	ySize = Tk_Height(dvPtr->tkwin) - 2*dvPtr->inset;
2141	dvPtr->topLine = dvPtr->yOffset/fm.linespace;
2142	dvPtr->btmLine = (dvPtr->yOffset + ySize)/fm.linespace + 1;
2143	dvPtr->fullLines = ySize/fm.linespace;
2144
2145	dvPtr->flags &= ~FONT_CHANGED;
2146	}
2147	}
2148
2149	/*
2150	* ----------------------------------------------------------------------
2151	* DiffviewUpdateVScrollbar()
2152	*
2153	* Used to invoke the -yscrollcommand whenever the y-view has changed.
2154	* This updates the scrollbar so that it shows the proper bubble.
2155	* If there is no -yscrollcommand option, this does nothing.
2156	* ----------------------------------------------------------------------
2157	*/
2158	static void
2159	DiffviewUpdateVScrollbar(dvPtr)
2160	Diffview dvPtr; / widget data */
2161	{
2162	char string[TCL_DOUBLE_SPACE*2 + 2];
2163	double first, last;
2164	int result, ySize;
2165
2166	/* make sure the layout info is up to date */
2167	DiffviewUpdateLayout(dvPtr);
2168
2169	/* update the limits of the current view */
2170	ySize = Tk_Height(dvPtr->tkwin) - 2*dvPtr->inset;
2171	if (dvPtr->lineHeight > 0) {
2172	dvPtr->topLine = dvPtr->yOffset/dvPtr->lineHeight;
2173	dvPtr->btmLine = (dvPtr->yOffset + ySize)/dvPtr->lineHeight + 1;
2174	dvPtr->fullLines = ySize/dvPtr->lineHeight;
2175	}
2176
2177	/* if there's no scroll command, then there's nothing left to do */
2178	if (dvPtr->yScrollCmd == NULL) {
2179	return;
2180	}
2181
2182	if (dvPtr->maxHeight == 0) {
2183	first = 0.0;
2184	last = 1.0;
2185	} else {
2186	first = dvPtr->yOffset/((double)dvPtr->maxHeight);
2187	last = (dvPtr->yOffset + ySize)/((double)dvPtr->maxHeight);
2188	if (last > 1.0) {
2189	last = 1.0;
2190	}
2191	}
2192	sprintf(string, " %g %g", first, last);
2193
2194	/* preserve/release the interp, in case it gets destroyed during the call */
2195	Tcl_Preserve((ClientData)dvPtr->interp);
2196
2197	result = Tcl_VarEval(dvPtr->interp, dvPtr->yScrollCmd, string,
2198	(char*)NULL);
2199	if (result != TCL_OK) {
2200	Tcl_AddErrorInfo(dvPtr->interp,
2201	"\n (vertical scrolling command executed by diffview)");
2202	Tcl_BackgroundError(dvPtr->interp);
2203	}
2204
2205	Tcl_Release((ClientData)dvPtr->interp);
2206	}
2207
2208	/*
2209	* ----------------------------------------------------------------------
2210	* DiffviewUpdateHScrollbar()
2211	*
2212	* Used to invoke the -xscrollcommand whenever the x-view has changed.
2213	* This updates the scrollbar so that it shows the proper bubble.
2214	* If there is no -xscrollcommand option, this does nothing.
2215	* ----------------------------------------------------------------------
2216	*/
2217	static void
2218	DiffviewUpdateHScrollbar(dvPtr)
2219	Diffview dvPtr; / widget data */
2220	{
2221	char string[TCL_DOUBLE_SPACE*2 + 3];
2222	int result, viewWidth;
2223	double first, last;
2224
2225	/* make sure the layout info is up to date */
2226	DiffviewUpdateLayout(dvPtr);
2227
2228	/* if there's no scroll command, then there's nothing left to do */
2229	if (dvPtr->xScrollCmd == NULL) {
2230	return;
2231	}
2232
2233	viewWidth = Tk_Width(dvPtr->tkwin) - 2*dvPtr->inset;
2234	if (dvPtr->maxWidth == 0) {
2235	first = 0;
2236	last = 1.0;
2237	} else {
2238	first = dvPtr->xOffset/((double)dvPtr->maxWidth);
2239	last = (dvPtr->xOffset + viewWidth)/((double) dvPtr->maxWidth);
2240	if (last > 1.0) {
2241	last = 1.0;
2242	}
2243	}
2244	sprintf(string, " %g %g", first, last);
2245
2246	/* preserve/release the interp, in case it gets destroyed during the call */
2247	Tcl_Preserve((ClientData)dvPtr->interp);
2248
2249	result = Tcl_VarEval(dvPtr->interp, dvPtr->xScrollCmd, string,
2250	(char*)NULL);
2251	if (result != TCL_OK) {
2252	Tcl_AddErrorInfo(dvPtr->interp,
2253	"\n (horizontal scrolling command executed by diffview)");
2254	Tcl_BackgroundError(dvPtr->interp);
2255	}
2256
2257	Tcl_Release((ClientData)dvPtr->interp);
2258	}
2259
2260	/*
2261	* ----------------------------------------------------------------------
2262	* DiffviewLinesCreate()
2263	*
2264	* Used to breakup a Tcl string object into the indices for the start
2265	* and end of each line. This is the first step in the computation
2266	* of diffs and the world view of the widget.
2267	*
2268	* Returns a pointer to a description of the line geometry, which should
2269	* be freed by calling DiffviewLinesFree() when it is no longer needed.
2270	* ----------------------------------------------------------------------
2271	*/
2272	static DiffviewLines*
2273	DiffviewLinesCreate(textPtr, textLen)
2274	char textPtr; / text string being broken up */
2275	int textLen; /* length of the string */
2276	{
2277	int numLines = 0;
2278	DiffviewLines *lineLimitsPtr;
2279	char **newStarts;
2280	int *newLens;
2281	unsigned int len;
2282
2283	lineLimitsPtr = (DiffviewLines*)ckalloc(sizeof(DiffviewLines));
2284	lineLimitsPtr->maxLines = 0;
2285	lineLimitsPtr->startPtr = NULL;
2286	lineLimitsPtr->lenPtr = NULL;
2287
2288	while (textLen > 0) {
2289	/*
2290	* If we're out of space, double the size and copy existing
2291	* info over.
2292	*/
2293	if (numLines >= lineLimitsPtr->maxLines) {
2294	if (lineLimitsPtr->maxLines == 0) {
2295	lineLimitsPtr->maxLines = 100;
2296	} else {
2297	lineLimitsPtr->maxLines *= 2;
2298	}
2299
2300	/* resize the start point array */
2301	newStarts = (char*)ckalloc(lineLimitsPtr->maxLinessizeof(char*));
2302	if (lineLimitsPtr->startPtr) {
2303	memcpy((VOID)newStarts, (VOID)lineLimitsPtr->startPtr,
2304	numLinessizeof(char));
2305	ckfree((char*)lineLimitsPtr->startPtr);
2306	}
2307	lineLimitsPtr->startPtr = newStarts;
2308
2309	/* resize the end point array */
2310	newLens = (int)ckalloc(lineLimitsPtr->maxLinessizeof(int));
2311	if (lineLimitsPtr->lenPtr) {
2312	memcpy((VOID)newLens, (VOID)lineLimitsPtr->lenPtr,
2313	numLines*sizeof(int));
2314	ckfree((char*)lineLimitsPtr->lenPtr);
2315	}
2316	lineLimitsPtr->lenPtr = newLens;
2317	}
2318
2319	/* mark the start of this line, then search for the end */
2320	lineLimitsPtr->startPtr[numLines] = textPtr;
2321	lineLimitsPtr->lenPtr[numLines] = 0;
2322
2323	while (*textPtr != '\n' && textLen > 0) {
2324	textPtr++; textLen--;
2325	}
2326	if (textPtr > lineLimitsPtr->startPtr[numLines]) {
2327	len = textPtr - lineLimitsPtr->startPtr[numLines];
2328	lineLimitsPtr->lenPtr[numLines] = len;
2329	}
2330	numLines++;
2331
2332	/* skip over the newline and start with next line */
2333	if (*textPtr == '\n') {
2334	textPtr++; textLen--;
2335	}
2336	}
2337	lineLimitsPtr->numLines = numLines;
2338
2339	return lineLimitsPtr;
2340	}
2341
2342	/*
2343	* ----------------------------------------------------------------------
2344	* DiffviewLinesFree()
2345	*
2346	* Used to free up the data structure created by DiffviewLinesCreate().
2347	* ----------------------------------------------------------------------
2348	*/
2349	static void
2350	DiffviewLinesFree(lineLimitsPtr)
2351	DiffviewLines lineLimitsPtr; / data structure being freed */
2352	{
2353	if (lineLimitsPtr) {
2354	if (lineLimitsPtr->startPtr) {
2355	ckfree((char*)lineLimitsPtr->startPtr);
2356	}
2357	if (lineLimitsPtr->lenPtr) {
2358	ckfree((char*)lineLimitsPtr->lenPtr);
2359	}
2360	ckfree((char*)lineLimitsPtr);
2361	}
2362	}
2363
2364	/*
2365	* ----------------------------------------------------------------------
2366	* DiffviewDiffsCreate()
2367	*
2368	* Considers two strings textPtr1 and textPtr2 (divided into segments
2369	* according to limsPtr1 and limsPtr2), and computes the longest common
2370	* subsequences between the two strings. This is the first step in
2371	* computing the differences between the two strings.
2372	*
2373	* Returns a data structure that contains a series of "diff" operations.
2374	* This should be freed when it is no longer needed by calling
2375	* DiffviewDiffsFree().
2376	*
2377	* REFERENCE:
2378	* J. W. Hunt and M. D. McIlroy, "An algorithm for differential
2379	* file comparison," Comp. Sci. Tech. Rep. #41, Bell Telephone
2380	* Laboratories (1976). Available on the Web at the second
2381	* author's personal site: http://www.cs.dartmouth.edu/~doug/
2382	*
2383	* ----------------------------------------------------------------------
2384	*/
2385	static DiffviewDiffs*
2386	DiffviewDiffsCreate(textPtr1, limsPtr1, textPtr2, limsPtr2)
2387	char textPtr1; / text from buffer #1 */
2388	DiffviewLines limsPtr1; / limits of individual strings in textPtr1 */
2389	char textPtr2; / text from buffer #2 */
2390	DiffviewLines limsPtr2; / limits of individual strings in textPtr2 */
2391	{
2392	DiffviewDiffs *diffPtr = NULL;
2393
2394	Tcl_HashTable eqv;
2395	Tcl_HashSearch iter;
2396	Tcl_HashEntry *entryPtr;
2397	Tcl_DString buffer;
2398	DiffviewSubseq K, newK, newCandidate;
2399	int Kmax; int Klen;
2400	Tcl_Obj listPtr, *objv;
2401	int i, j, candidateIdx, subseqLen, longestMatch;
2402	int max, min, mid, midval, sLen, del;
2403	int len, created, o, objc, index1, lcsIndex1, index2, lcsIndex2;
2404	char *key;
2405
2406	newCandidate.index1 = -1; /* Suppress compiler warning. */
2407	newCandidate.index2 = -1;
2408	newCandidate.next = -1;
2409
2410	/*
2411	* Build a set of equivalence classes. Scan through all of
2412	* buffer #2 and map each string to a list of indices for the
2413	* lines that have that string.
2414	*/
2415	Tcl_DStringInit(&buffer);
2416	Tcl_InitHashTable(&eqv, TCL_STRING_KEYS);
2417	for (i=0; i < limsPtr2->numLines; i++) {
2418	len = limsPtr2->lenPtr[i];
2419	Tcl_DStringSetLength(&buffer, len);
2420	key = Tcl_DStringValue(&buffer);
2421	memcpy((VOID)key, (VOID)limsPtr2->startPtr[i], len);
2422
2423	entryPtr = Tcl_CreateHashEntry(&eqv, key, &created);
2424	if (created) {
2425	listPtr = Tcl_NewListObj(0, (Tcl_Obj**)NULL);
2426	Tcl_IncrRefCount(listPtr);
2427	Tcl_SetHashValue(entryPtr, (ClientData)listPtr);
2428	}
2429
2430	listPtr = (Tcl_Obj*)Tcl_GetHashValue(entryPtr);
2431	Tcl_ListObjAppendElement((Tcl_Interp*)NULL, listPtr, Tcl_NewIntObj(i));
2432	}
2433
2434	/*
2435	* Build a list K that holds the descriptions of the common
2436	* subsequences. At first, there is one common subsequence of
2437	* length 0 with a fence that includes line -1 of both files.
2438	*/
2439	Kmax = 10;
2440	K = (DiffviewSubseq)ckalloc(Kmaxsizeof(DiffviewSubseq));
2441	K[0].index1 = -1;
2442	K[0].index2 = -1;
2443	K[0].next = -1;
2444	K[1].index1 = limsPtr1->numLines;
2445	K[1].index2 = limsPtr2->numLines;
2446	K[1].next = -1;
2447	Klen = 2;
2448	longestMatch = 0;
2449
2450	/*
2451	* Step through the first buffer line by line.
2452	*/
2453	for (i=0; i < limsPtr1->numLines; i++) {
2454	len = limsPtr1->lenPtr[i];
2455	Tcl_DStringSetLength(&buffer, len);
2456	key = Tcl_DStringValue(&buffer);
2457	memcpy((VOID)key, (VOID)limsPtr1->startPtr[i], len);
2458
2459	/* look at each possible line j in second buffer */
2460	entryPtr = Tcl_FindHashEntry(&eqv, key);
2461	if (entryPtr) {
2462	subseqLen = 0;
2463	candidateIdx = 0;
2464
2465	listPtr = (Tcl_Obj*)Tcl_GetHashValue(entryPtr);
2466	Tcl_ListObjGetElements((Tcl_Interp*)NULL, listPtr, &objc, &objv);
2467	for (o=0; o < objc; o++) {
2468	Tcl_GetIntFromObj((Tcl_Interp*)NULL, objv[o], &j);
2469
2470	/*
2471	* Binary search to find a candidate common subsequence.
2472	* This match may get appended to that.
2473	*/
2474	max = longestMatch;
2475	min = subseqLen;
2476	mid = subseqLen;
2477	sLen = longestMatch + 1;
2478	while (max >= min) {
2479	mid = (max+min)/2;
2480	midval = K[mid].index2;
2481	if (j == midval) {
2482	break;
2483	} else if (j < midval) {
2484	max = mid-1;
2485	} else {
2486	sLen = mid;
2487	min = mid+1;
2488	}
2489	}
2490
2491	/* no good candidate? then go to the next match point */
2492	if (j == K[mid].index2 \|\| sLen > longestMatch) {
2493	continue;
2494	}
2495
2496	/*
2497	* sLen = sequence length of the longest sequence that
2498	* this match point can be appended to
2499	*
2500	* Make a new candidate match and store the old on in K.
2501	* Set subseqLen to the length of the new candidate match.
2502	*/
2503	if (subseqLen >= 0) {
2504	if (candidateIdx >= 0) {
2505	K[subseqLen].index1 = K[candidateIdx].index1;
2506	K[subseqLen].index2 = K[candidateIdx].index2;
2507	K[subseqLen].next = K[candidateIdx].next;
2508	} else {
2509	K[subseqLen].index1 = newCandidate.index1;
2510	K[subseqLen].index2 = newCandidate.index2;
2511	K[subseqLen].next = newCandidate.next;
2512	}
2513	}
2514	newCandidate.index1 = i;
2515	newCandidate.index2 = j;
2516	newCandidate.next = sLen;
2517	candidateIdx = -1; /* use newCandidate info */
2518	subseqLen = sLen + 1;
2519
2520	/*
2521	* If we've extended the length of the longest match,
2522	* we don't need to keep checking candidate lines.
2523	* We're done. Move the fence.
2524	*/
2525	if (sLen >= longestMatch) {
2526	if (Klen >= Kmax) {
2527	Kmax *= 2;
2528	newK = (DiffviewSubseq)ckalloc(Kmaxsizeof(DiffviewSubseq));
2529	memcpy((VOID)newK, (VOID)K, Klen*sizeof(DiffviewSubseq));
2530	ckfree((char*)K);
2531	K = newK;
2532	}
2533	K[Klen].index1 = K[Klen-1].index1;
2534	K[Klen].index2 = K[Klen-1].index2;
2535	K[Klen].next = K[Klen-1].next;
2536	Klen++;
2537
2538	longestMatch++;
2539	break;
2540	}
2541	}
2542
2543	/* put the last candidate into the array */
2544	if (candidateIdx >= 0) {
2545	K[subseqLen].index1 = K[candidateIdx].index1;
2546	K[subseqLen].index2 = K[candidateIdx].index2;
2547	K[subseqLen].next = K[candidateIdx].next;
2548	} else {
2549	K[subseqLen].index1 = newCandidate.index1;
2550	K[subseqLen].index2 = newCandidate.index2;
2551	K[subseqLen].next = newCandidate.next;
2552	}
2553	}
2554	}
2555
2556	/*
2557	* Translate the resulting info into a list of common subseq indices.
2558	*/
2559	lcsIndex1 = (int)ckalloc(longestMatchsizeof(int));
2560	memset((void)lcsIndex1, 0, (longestMatchsizeof(int)));
2561	lcsIndex2 = (int)ckalloc(longestMatchsizeof(int));
2562	memset((void)lcsIndex2, 0, (longestMatchsizeof(int)));
2563	len = longestMatch;
2564
2565	candidateIdx = longestMatch;
2566	while (K[candidateIdx].index1 >= 0) {
2567	if (longestMatch-- < 0) {
2568	Tcl_Panic("internal mismatch in diff algorithm");
2569	}
2570	lcsIndex1[longestMatch] = K[candidateIdx].index1;
2571	lcsIndex2[longestMatch] = K[candidateIdx].index2;
2572	candidateIdx = K[candidateIdx].next;
2573	}
2574
2575	/*
2576	* Now, march through all lines in both buffers and convert the
2577	* lcs indices into a sequence of diff-style operations.
2578	*/
2579	diffPtr = (DiffviewDiffs*)ckalloc(sizeof(DiffviewDiffs));
2580	diffPtr->maxDiffs = 0;
2581	diffPtr->numDiffs = 0;
2582	diffPtr->ops = NULL;
2583
2584	i = j = 0;
2585	for (o=0; o < len; o++) {
2586	index1 = lcsIndex1[o];
2587	index2 = lcsIndex2[o];
2588
2589	if (index1-i == index2-j && index1-i > 0) {
2590	del = index1-i;
2591	DiffviewDiffsAppend(diffPtr, 'c', i, i+del-1, j, j+del-1);
2592	i += del; j += del;
2593	} else {
2594	del = index1-i;
2595	if (del > 0) {
2596	DiffviewDiffsAppend(diffPtr, 'd', i, i+del-1, j, j);
2597	i += del;
2598	}
2599
2600	del = index2-j;
2601	if (del > 0) {
2602	DiffviewDiffsAppend(diffPtr, 'a', i, i, j, j+del-1);
2603	j += del;
2604	}
2605	}
2606	i++; j++;
2607	}
2608
2609	/* lines left over? mark as many "changed" as possible */
2610	if (limsPtr1->numLines-i > 0 && limsPtr2->numLines-j > 0) {
2611	del = (limsPtr1->numLines-i < limsPtr2->numLines-j)
2612	? limsPtr1->numLines-i : limsPtr2->numLines-j;
2613	DiffviewDiffsAppend(diffPtr, 'c', i, i+del-1, j, j+del-1);
2614	i += del;
2615	j += del;
2616	}
2617
2618	/* still have lines left over? then mark them added or deleted */
2619	if (i < limsPtr1->numLines) {
2620	del = limsPtr1->numLines - i;
2621	DiffviewDiffsAppend(diffPtr, 'd', i, i+del-1, j, j);
2622	i += del;
2623	}
2624	if (j < limsPtr2->numLines) {
2625	del = limsPtr2->numLines - j;
2626	DiffviewDiffsAppend(diffPtr, 'a', i, i, j, j+del-1);
2627	j += del;
2628	}
2629
2630	/*
2631	* Clean up all memory used during the diff.
2632	*/
2633	ckfree((char*)K);
2634	ckfree((char*)lcsIndex1);
2635	ckfree((char*)lcsIndex2);
2636
2637	entryPtr = Tcl_FirstHashEntry(&eqv, &iter);
2638	while (entryPtr) {
2639	listPtr = (Tcl_Obj*)Tcl_GetHashValue(entryPtr);
2640	Tcl_DecrRefCount(listPtr);
2641	entryPtr = Tcl_NextHashEntry(&iter);
2642	}
2643	Tcl_DeleteHashTable(&eqv);
2644
2645	return diffPtr;
2646	}
2647
2648	/*
2649	* ----------------------------------------------------------------------
2650	* DiffviewDiffsAppend()
2651	*
2652	* Appends a "diff" operation onto a list of diffs. The list is extended
2653	* automatically, if need be, to store the new element.
2654	* ----------------------------------------------------------------------
2655	*/
2656	static void
2657	DiffviewDiffsAppend(diffsPtr, op, fromIndex1, toIndex1, fromIndex2, toIndex2)
2658	DiffviewDiffs diffsPtr; / diffs being updated */
2659	int op; /* diff operation: a/d/c */
2660	int fromIndex1; /* starts at this line in buffer 1 */
2661	int toIndex1; /* ends at this line in buffer 1 */
2662	int fromIndex2; /* starts at this line in buffer 2 */
2663	int toIndex2; /* ends at this line in buffer 2 */
2664	{
2665	DiffviewDiffOp *newOpArray;
2666	int last;
2667
2668	if (diffsPtr->numDiffs >= diffsPtr->maxDiffs) {
2669	if (diffsPtr->maxDiffs == 0) {
2670	diffsPtr->maxDiffs = 10;
2671	} else {
2672	diffsPtr->maxDiffs *= 2;
2673	}
2674	newOpArray = (DiffviewDiffOp*)ckalloc(
2675	diffsPtr->maxDiffs*sizeof(DiffviewDiffOp));
2676
2677	if (diffsPtr->ops) {
2678	memcpy((VOID)newOpArray, (VOID)diffsPtr->ops,
2679	diffsPtr->numDiffs*sizeof(DiffviewDiffOp));
2680	ckfree((char*)diffsPtr->ops);
2681	}
2682	diffsPtr->ops = newOpArray;
2683	}
2684
2685	last = diffsPtr->numDiffs;
2686	diffsPtr->ops[last].op = op;
2687	diffsPtr->ops[last].fromIndex1 = fromIndex1;
2688	diffsPtr->ops[last].toIndex1 = toIndex1;
2689	diffsPtr->ops[last].fromIndex2 = fromIndex2;
2690	diffsPtr->ops[last].toIndex2 = toIndex2;
2691	diffsPtr->numDiffs++;
2692	}
2693
2694	/*
2695	* ----------------------------------------------------------------------
2696	* DiffviewDiffsFree()
2697	*
2698	* Frees up the storage previously created by calling
2699	* DiffviewDiffsAppend().
2700	* ----------------------------------------------------------------------
2701	*/
2702	static void
2703	DiffviewDiffsFree(diffsPtr)
2704	DiffviewDiffs diffsPtr; / diffs being freed */
2705	{
2706	if (diffsPtr->ops) {
2707	ckfree((char*)diffsPtr->ops);
2708	}
2709	ckfree((char*)diffsPtr);
2710	}
2711
2712	/*
2713	* ----------------------------------------------------------------------
2714	* DiffviewLayoutAdd()
2715	*
2716	* Clears out the layout storage in preparation for building another
2717	* layout. If the previous number of lines was much less than the
2718	* maximum allocated, then this routine reallocates a smaller storage
2719	* space. This provides a way to give back a large chunk of memory
2720	* if the contents of the widget is nulled out, for example.
2721	* ----------------------------------------------------------------------
2722	*/
2723	static void
2724	DiffviewLayoutAdd(layoutPtr, linePtr)
2725	DiffviewLayout layoutPtr; / line layout being updated */
2726	DiffviewLayoutLine linePtr; / line being added to layout */
2727	{
2728	DiffviewLayoutLine *newLineArray;
2729
2730	/* expand the array as needed */
2731	if (layoutPtr->numLines >= layoutPtr->maxLines) {
2732	if (layoutPtr->maxLines == 0) {
2733	layoutPtr->maxLines = 100;
2734	} else {
2735	layoutPtr->maxLines *= 2;
2736	}
2737	newLineArray = (DiffviewLayoutLine*)ckalloc(
2738	(unsigned)(layoutPtr->maxLines*sizeof(DiffviewLayoutLine)));
2739
2740	if (layoutPtr->lines) {
2741	memcpy((VOID)newLineArray, (VOID)layoutPtr->lines,
2742	layoutPtr->numLines*sizeof(DiffviewLayoutLine));
2743	ckfree((char*)layoutPtr->lines);
2744	}
2745	layoutPtr->lines = newLineArray;
2746	}
2747
2748	/* copy the latest line in and bump the count */
2749	memcpy((VOID*)&layoutPtr->lines[layoutPtr->numLines],
2750	(VOID*)linePtr, sizeof(DiffviewLayoutLine));
2751
2752	layoutPtr->numLines++;
2753	}
2754
2755	/*
2756	* ----------------------------------------------------------------------
2757	* DiffviewLayoutClear()
2758	*
2759	* Clears out the layout storage in preparation for building another
2760	* layout. If the previous number of lines was much less than the
2761	* maximum allocated, then this routine reallocates a smaller storage
2762	* space. This provides a way to give back a large chunk of memory
2763	* if the contents of the widget is nulled out, for example.
2764	* ----------------------------------------------------------------------
2765	*/
2766	static void
2767	DiffviewLayoutClear(layoutPtr)
2768	DiffviewLayout layoutPtr; / line layout being freed */
2769	{
2770	if (layoutPtr->numLines > 0
2771	&& layoutPtr->numLines < layoutPtr->maxLines/3
2772	&& layoutPtr->maxLines > 100) {
2773	ckfree((char*)layoutPtr->lines);
2774	layoutPtr->lines = (DiffviewLayoutLine*)ckalloc(
2775	(unsigned)(layoutPtr->numLines * sizeof(DiffviewLayoutLine)));
2776	layoutPtr->maxLines = layoutPtr->numLines;
2777	}
2778	layoutPtr->numLines = 0;
2779	}
2780
2781	/*
2782	* ----------------------------------------------------------------------
2783	* DiffviewLayoutFree()
2784	*
2785	* Frees the storage associated with the layout of all lines within
2786	* the widget.
2787	* ----------------------------------------------------------------------
2788	*/
2789	static void
2790	DiffviewLayoutFree(layoutPtr)
2791	DiffviewLayout layoutPtr; / line layout being freed */
2792	{
2793	if (layoutPtr->lines) {
2794	ckfree((char*)layoutPtr->lines);
2795	layoutPtr->lines = NULL;
2796	}
2797	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: