summaryrefslogtreecommitdiffstats
path: root/generic
diff options
context:
space:
mode:
authordkf <donal.k.fellows@manchester.ac.uk>2007-02-22 13:56:32 (GMT)
committerdkf <donal.k.fellows@manchester.ac.uk>2007-02-22 13:56:32 (GMT)
commitdde89e53698859ca30c7ef441d2b64350d2a8187 (patch)
treed27aec929ff20b2ab6ba34faa14bd56439bf1d33 /generic
parent18bcf9971777b9bf6d2eacd064c42f0f7e58ae47 (diff)
downloadtk-dde89e53698859ca30c7ef441d2b64350d2a8187.zip
tk-dde89e53698859ca30c7ef441d2b64350d2a8187.tar.gz
tk-dde89e53698859ca30c7ef441d2b64350d2a8187.tar.bz2
Less of that K&R or wrongly indented function header style!
Diffstat (limited to 'generic')
-rw-r--r--generic/tkText.c816
-rw-r--r--generic/tkTextBTree.c652
-rw-r--r--generic/tkTextDisp.c462
-rw-r--r--generic/tkTextIndex.c275
-rw-r--r--generic/tkTextMark.c24
-rw-r--r--generic/tkTextTag.c67
-rw-r--r--generic/tkTextWind.c42
7 files changed, 1163 insertions, 1175 deletions
diff --git a/generic/tkText.c b/generic/tkText.c
index 77b30e5..fd65352 100644
--- a/generic/tkText.c
+++ b/generic/tkText.c
@@ -13,7 +13,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkText.c,v 1.72 2007/01/03 05:06:27 nijtmans Exp $
+ * RCS: @(#) $Id: tkText.c,v 1.73 2007/02/22 13:56:32 dkf Exp $
*/
#include "default.h"
@@ -66,9 +66,9 @@ static char *wrapStrings[] = {
};
/*
- * The 'TkTextTabStyle' enum in tkText.h is used to define a type for
- * the -tabstyle option of the Text widget. These values are used as
- * indices into the string table below.
+ * The 'TkTextTabStyle' enum in tkText.h is used to define a type for the
+ * -tabstyle option of the Text widget. These values are used as indices into
+ * the string table below.
*/
static char *tabStyleStrings[] = {
@@ -91,8 +91,9 @@ static int SetLineStartEnd(ClientData clientData,
Tcl_Obj **value, char *recordPtr,
int internalOffset, char *oldInternalPtr,
int flags);
-static Tcl_Obj* GetLineStartEnd(ClientData clientData, Tk_Window tkwin,
- char *recordPtr, int internalOffset);
+static Tcl_Obj * GetLineStartEnd(ClientData clientData,
+ Tk_Window tkwin, char *recordPtr,
+ int internalOffset);
static void RestoreLineStartEnd(ClientData clientData,
Tk_Window tkwin, char *internalPtr,
char *oldInternalPtr);
@@ -158,7 +159,7 @@ static const Tk_OptionSpec optionSpecs[] = {
{TK_OPTION_PIXELS, "-highlightthickness", "highlightThickness",
"HighlightThickness", DEF_TEXT_HIGHLIGHT_WIDTH, -1,
Tk_Offset(TkText, highlightWidth), 0, 0, TK_TEXT_LINE_GEOMETRY},
- {TK_OPTION_BORDER, "-inactiveselectbackground", "inactiveSelectBackground",
+ {TK_OPTION_BORDER, "-inactiveselectbackground","inactiveSelectBackground",
"Foreground",
DEF_TEXT_INACTIVE_SELECT_COLOR,
-1, Tk_Offset(TkText, inactiveSelBorder),
@@ -270,7 +271,7 @@ typedef int SearchLineIndexProc(Tcl_Interp *interp,
int *linePosPtr, int *offsetPosPtr);
typedef struct SearchSpec {
- int exact; /* Whether search is exact or regexp */
+ int exact; /* Whether search is exact or regexp. */
int noCase; /* Case-insenstivive? */
int noLineStop; /* If not set, a regexp search will use the
* TCL_REG_NLSTOP flag. */
@@ -287,7 +288,7 @@ typedef struct SearchSpec {
int stopLine; /* Last line to examine, or -1 when we search
* all available text. */
int stopOffset; /* Index to stop at, provided stopLine is not
- * -1 */
+ * -1. */
int numLines; /* Total lines which are available. */
int backwards; /* Searching forwards or backwards. */
Tcl_Obj *varPtr; /* If non-NULL, store length(s) of match(es)
@@ -332,8 +333,8 @@ int tkTextDebug = 0;
static int ConfigureText(Tcl_Interp *interp,
TkText *textPtr, int objc, Tcl_Obj *CONST objv[]);
-static int DeleteIndexRange(TkSharedText *sharedPtr, TkText *textPtr,
- CONST TkTextIndex *indexPtr1,
+static int DeleteIndexRange(TkSharedText *sharedPtr,
+ TkText *textPtr, CONST TkTextIndex *indexPtr1,
CONST TkTextIndex *indexPtr2, int viewUpdate);
static int CountIndices(CONST TkText *textPtr,
CONST TkTextIndex *indexPtr1,
@@ -348,11 +349,12 @@ static void TextCmdDeletedProc(ClientData clientData);
static int CreateWidget(TkSharedText *sharedPtr, Tk_Window tkwin,
Tcl_Interp *interp, CONST TkText *parent,
int objc, Tcl_Obj *CONST objv[]);
-static void TextEventProc(ClientData clientData, XEvent *eventPtr);
+static void TextEventProc(ClientData clientData,
+ XEvent *eventPtr);
static int TextFetchSelection(ClientData clientData, int offset,
char *buffer, int maxBytes);
-static int TextIndexSortProc(CONST VOID *first,
- CONST VOID *second);
+static int TextIndexSortProc(CONST void *first,
+ CONST void *second);
static int TextInsertCmd(TkSharedText *sharedTextPtr,
TkText *textPtr, Tcl_Interp *interp,
int objc, Tcl_Obj *CONST objv[],
@@ -375,8 +377,8 @@ static void TextWorldChangedCallback(ClientData instanceData);
static void TextWorldChanged(TkText *textPtr, int mask);
static int TextDumpCmd(TkText *textPtr, Tcl_Interp *interp,
int objc, Tcl_Obj *CONST objv[]);
-static int DumpLine(Tcl_Interp *interp, TkText *textPtr, int what,
- TkTextLine *linePtr, int start, int end,
+static int DumpLine(Tcl_Interp *interp, TkText *textPtr,
+ int what, TkTextLine *linePtr, int start, int end,
int lineno, Tcl_Obj *command);
static int DumpSegment(TkText *textPtr, Tcl_Interp *interp,
CONST char *key, CONST char *value,
@@ -435,11 +437,11 @@ static Tk_ClassProcs textClass = {
*/
int
-Tk_TextObjCmd(clientData, interp, objc, objv)
- ClientData clientData; /* Main window associated with interpreter. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+Tk_TextObjCmd(
+ ClientData clientData, /* Main window associated with interpreter. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
Tk_Window tkwin = (Tk_Window) clientData;
@@ -473,14 +475,14 @@ Tk_TextObjCmd(clientData, interp, objc, objv)
*/
static int
-CreateWidget(sharedPtr, tkwin, interp, parent, objc, objv)
- TkSharedText *sharedPtr; /* Shared widget info, or null */
- Tk_Window tkwin; /* Main window associated with interpreter. */
- Tcl_Interp *interp; /* Current interpreter. */
- CONST TkText *parent; /* If non-NULL then take default start, end
+CreateWidget(
+ TkSharedText *sharedPtr, /* Shared widget info, or NULL. */
+ Tk_Window tkwin, /* Main window associated with interpreter. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ CONST TkText *parent, /* If non-NULL then take default start, end
* from this parent. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
register TkText *textPtr;
Tk_OptionTable optionTable;
@@ -504,7 +506,7 @@ CreateWidget(sharedPtr, tkwin, interp, parent, objc, objv)
*/
textPtr = (TkText *) ckalloc(sizeof(TkText));
- memset((VOID *) textPtr, 0, sizeof(TkText));
+ memset(textPtr, 0, sizeof(TkText));
textPtr->tkwin = newWin;
textPtr->display = Tk_Display(newWin);
@@ -515,7 +517,7 @@ CreateWidget(sharedPtr, tkwin, interp, parent, objc, objv)
if (sharedPtr == NULL) {
sharedPtr = (TkSharedText *) ckalloc(sizeof(TkSharedText));
- memset((VOID *) sharedPtr, 0, sizeof(TkSharedText));
+ memset(sharedPtr, 0, sizeof(TkSharedText));
sharedPtr->refCount = 0;
sharedPtr->peers = NULL;
@@ -614,7 +616,7 @@ CreateWidget(sharedPtr, tkwin, interp, parent, objc, objv)
textPtr->selTagPtr->reliefString = (char *)
ckalloc(sizeof(DEF_TEXT_SELECT_RELIEF));
strcpy(textPtr->selTagPtr->reliefString, DEF_TEXT_SELECT_RELIEF);
- Tk_GetRelief(interp, DEF_TEXT_SELECT_RELIEF, &(textPtr->selTagPtr->relief));
+ Tk_GetRelief(interp, DEF_TEXT_SELECT_RELIEF, &textPtr->selTagPtr->relief);
textPtr->currentMarkPtr = TkTextSetMark(textPtr, "current", &startIndex);
textPtr->insertMarkPtr = TkTextSetMark(textPtr, "insert", &startIndex);
@@ -673,21 +675,21 @@ CreateWidget(sharedPtr, tkwin, interp, parent, objc, objv)
*/
static int
-TextWidgetObjCmd(clientData, interp, objc, objv)
- ClientData clientData; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+TextWidgetObjCmd(
+ ClientData clientData, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
register TkText *textPtr = (TkText *) clientData;
int result = TCL_OK;
int index;
static CONST char *optionStrings[] = {
- "bbox", "cget", "compare", "configure", "count", "debug",
- "delete", "dlineinfo", "dump", "edit", "get", "image", "index",
- "insert", "mark", "peer", "replace", "scan", "search", "see",
- "tag", "window", "xview", "yview", NULL
+ "bbox", "cget", "compare", "configure", "count", "debug", "delete"
+ "dlineinfo", "dump", "edit", "get", "image", "index", "insert",
+ "mark", "peer", "replace", "scan", "search", "see", "tag", "window",
+ "xview", "yview", NULL
};
enum options {
TEXT_BBOX, TEXT_CGET, TEXT_COMPARE, TEXT_CONFIGURE, TEXT_COUNT,
@@ -862,7 +864,7 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
value = CountIndices(textPtr, indexFromPtr, indexToPtr,
COUNT_DISPLAY_CHARS);
} else if (c == 'd' && (length > 8)
- && !strncmp("-displayindices", option, (unsigned)length)) {
+ && !strncmp("-displayindices", option,(unsigned)length)) {
value = CountIndices(textPtr, indexFromPtr, indexToPtr,
COUNT_DISPLAY_INDICES);
} else if (c == 'd' && (length > 8)
@@ -899,16 +901,16 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
index = *indexFromPtr;
index.byteIndex = 0;
-
+
/*
- * We're going to count up all display lines in the
- * logical line of 'indexFromPtr' up to, but not
- * including the logical line of 'indexToPtr', and
- * then subtract off what we didn't what from 'from'
- * and add on what we didn't count from 'to.
+ * We're going to count up all display lines in the logical
+ * line of 'indexFromPtr' up to, but not including the logical
+ * line of 'indexToPtr', and then subtract off what we didn't
+ * what from 'from' and add on what we didn't count from 'to.
*/
+
while (index.linePtr != indexToPtr->linePtr) {
- value += TkTextUpdateOneLine(textPtr, fromPtr, 0,&index,0);
+ value += TkTextUpdateOneLine(textPtr, fromPtr,0,&index,0);
/*
* We might have skipped past indexToPtr, if we have
@@ -1004,9 +1006,10 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
} else {
if (found == 2) {
/*
- * Move the first item we put into the result into
- * the first element of the list object.
+ * Move the first item we put into the result into the
+ * first element of the list object.
*/
+
objPtr = Tcl_NewObj();
Tcl_ListObjAppendElement(NULL, objPtr,
Tcl_GetObjResult(interp));
@@ -1022,6 +1025,7 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
int value = CountIndices(textPtr, indexFromPtr, indexToPtr,
COUNT_INDICES);
+
Tcl_SetObjResult(interp, Tcl_NewIntObj(value));
} else if (found > 1) {
Tcl_SetObjResult(interp, objPtr);
@@ -1070,8 +1074,8 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
goto done;
}
if (objc == 4) {
- indexPtr2 = TkTextGetIndexFromObj(textPtr->interp, textPtr,
- objv[3]);
+ indexPtr2 = TkTextGetIndexFromObj(textPtr->interp,
+ textPtr, objv[3]);
if (indexPtr2 == NULL) {
result = TCL_ERROR;
goto done;
@@ -1132,7 +1136,7 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
* first to maintain index consistency.
*/
- qsort((VOID *) indices, (unsigned) (objc / 2),
+ qsort(indices, (unsigned) objc / 2,
2 * sizeof(TkTextIndex), TextIndexSortProc);
lastStart = NULL;
@@ -1184,8 +1188,8 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
* indices are preparsed above.
*/
- DeleteIndexRange(NULL, textPtr, &indices[i], &indices[i+1],
- 1);
+ DeleteIndexRange(NULL, textPtr, &indices[i],
+ &indices[i+1], 1);
}
}
ckfree((char *) indices);
@@ -1522,11 +1526,11 @@ TextWidgetObjCmd(clientData, interp, objc, objv)
*/
static int
-SharedTextObjCmd(clientData, interp, objc, objv)
- ClientData clientData; /* Information about shared test B-tree. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+SharedTextObjCmd(
+ ClientData clientData, /* Information about shared test B-tree. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
register TkSharedText *sharedPtr = (TkSharedText *) clientData;
int result = TCL_OK;
@@ -1628,11 +1632,11 @@ SharedTextObjCmd(clientData, interp, objc, objv)
*/
static int
-TextPeerCmd(textPtr, interp, objc, objv)
- TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+TextPeerCmd(
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
Tk_Window tkwin = textPtr->tkwin;
int index;
@@ -1703,24 +1707,23 @@ TextPeerCmd(textPtr, interp, objc, objv)
*/
static int
-TextReplaceCmd(textPtr, interp, indexFromPtr, indexToPtr, objc, objv,
- viewUpdate)
- TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- CONST TkTextIndex *indexFromPtr;
- /* Index from which to replace */
- CONST TkTextIndex *indexToPtr;
- /* Index to which to replace */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
- int viewUpdate; /* Update vertical view if set. */
+TextReplaceCmd(
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ CONST TkTextIndex *indexFromPtr,
+ /* Index from which to replace. */
+ CONST TkTextIndex *indexToPtr,
+ /* Index to which to replace. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[], /* Argument objects. */
+ int viewUpdate) /* Update vertical view if set. */
{
/*
* Perform the deletion and insertion, but ensure no undo-separator is
* placed between the two operations. Since we are using the helper
- * functions 'DeleteIndexRange' and 'TextInsertCmd' we have to pretend that the
- * autoSeparators setting is off, so that we don't get an undo-separator
- * between the delete and insert.
+ * functions 'DeleteIndexRange' and 'TextInsertCmd' we have to pretend
+ * that the autoSeparators setting is off, so that we don't get an
+ * undo-separator between the delete and insert.
*/
int origAutoSep = textPtr->sharedTextPtr->autoSeparators;
@@ -1729,7 +1732,7 @@ TextReplaceCmd(textPtr, interp, indexFromPtr, indexToPtr, objc, objv,
if (textPtr->sharedTextPtr->undo) {
textPtr->sharedTextPtr->autoSeparators = 0;
if (origAutoSep &&
- textPtr->sharedTextPtr->lastEditMode != TK_TEXT_EDIT_REPLACE) {
+ textPtr->sharedTextPtr->lastEditMode!=TK_TEXT_EDIT_REPLACE) {
TkUndoInsertUndoSeparator(textPtr->sharedTextPtr->undoStack);
}
}
@@ -1766,8 +1769,9 @@ TextReplaceCmd(textPtr, interp, indexFromPtr, indexToPtr, objc, objv,
*/
static int
-TextIndexSortProc(first, second)
- CONST VOID *first, *second; /* Elements to be compared. */
+TextIndexSortProc(
+ CONST void *first, /* Elements to be compared. */
+ CONST void *second)
{
TkTextIndex *pair1 = (TkTextIndex *) first;
TkTextIndex *pair2 = (TkTextIndex *) second;
@@ -1814,8 +1818,8 @@ TextIndexSortProc(first, second)
*/
static void
-DestroyText(textPtr)
- TkText *textPtr; /* Info about text widget. */
+DestroyText(
+ TkText *textPtr) /* Info about text widget. */
{
Tcl_HashSearch search;
Tcl_HashEntry *hPtr;
@@ -1834,7 +1838,7 @@ DestroyText(textPtr)
textPtr->dInfoPtr = NULL;
/*
- * Remove ourselves from the peer list
+ * Remove ourselves from the peer list.
*/
if (sharedTextPtr->peers == textPtr) {
@@ -1871,7 +1875,7 @@ DestroyText(textPtr)
* disassociate outselves from it.
*
* When the refCount reaches zero, it's time to clean up the shared
- * portion of the text widget
+ * portion of the text widget.
*/
sharedTextPtr->refCount--;
@@ -1922,7 +1926,7 @@ DestroyText(textPtr)
/*
* No need to use 'TkTextDeleteTag' since we've already removed
- * the B-tree completely
+ * the B-tree completely.
*/
TkTextFreeTag(textPtr, tagPtr);
@@ -1978,18 +1982,18 @@ DestroyText(textPtr)
*/
static int
-ConfigureText(interp, textPtr, objc, objv)
- Tcl_Interp *interp; /* Used for error reporting. */
- register TkText *textPtr; /* Information about widget; may or may not
+ConfigureText(
+ Tcl_Interp *interp, /* Used for error reporting. */
+ register TkText *textPtr, /* Information about widget; may or may not
* already have values for some fields. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
Tk_SavedOptions savedOptions;
int oldExport = textPtr->exportSelection;
int mask = 0;
- if (Tk_SetOptions(interp, (char*)textPtr, textPtr->optionTable,
+ if (Tk_SetOptions(interp, (char *) textPtr, textPtr->optionTable,
objc, objv, textPtr->tkwin, &savedOptions, &mask) != TCL_OK) {
return TCL_ERROR;
}
@@ -2034,7 +2038,8 @@ ConfigureText(interp, textPtr, objc, objv)
}
if (start > end) {
Tcl_AppendResult(interp,
- "-startline must be less than or equal to -endline", NULL);
+ "-startline must be less than or equal to -endline",
+ NULL);
Tk_RestoreSavedOptions(&savedOptions);
return TCL_ERROR;
}
@@ -2234,8 +2239,8 @@ ConfigureText(interp, textPtr, objc, objv)
*/
static void
-TextWorldChangedCallback(instanceData)
- ClientData instanceData; /* Information about widget. */
+TextWorldChangedCallback(
+ ClientData instanceData) /* Information about widget. */
{
TkText *textPtr;
@@ -2264,9 +2269,10 @@ TextWorldChangedCallback(instanceData)
*/
static void
-TextWorldChanged(textPtr, mask)
- TkText *textPtr; /* Information about widget. */
- int mask; /* OR'd collection of bits showing what has changed */
+TextWorldChanged(
+ TkText *textPtr, /* Information about widget. */
+ int mask) /* OR'd collection of bits showing what has
+ * changed. */
{
Tk_FontMetrics fm;
int border;
@@ -2284,7 +2290,7 @@ TextWorldChanged(textPtr, mask)
border = textPtr->borderWidth + textPtr->highlightWidth;
Tk_GeometryRequest(textPtr->tkwin,
textPtr->width * textPtr->charWidth + 2*textPtr->padX + 2*border,
- textPtr->height* (fm.linespace+textPtr->spacing1+textPtr->spacing3)
+ textPtr->height*(fm.linespace+textPtr->spacing1+textPtr->spacing3)
+ 2*textPtr->padY + 2*border);
Tk_SetInternalBorderEx(textPtr->tkwin,
@@ -2320,9 +2326,9 @@ TextWorldChanged(textPtr, mask)
*/
static void
-TextEventProc(clientData, eventPtr)
- ClientData clientData; /* Information about window. */
- register XEvent *eventPtr; /* Information about event. */
+TextEventProc(
+ ClientData clientData, /* Information about window. */
+ register XEvent *eventPtr) /* Information about event. */
{
register TkText *textPtr = (TkText *) clientData;
TkTextIndex index, index2;
@@ -2400,7 +2406,7 @@ TextEventProc(clientData, eventPtr)
/*
* While we wish to redisplay, no heights have changed, so no need
- * to call TkTextInvalidateLineMetrics
+ * to call TkTextInvalidateLineMetrics.
*/
TkTextChanged(NULL, textPtr, &index, &index2);
@@ -2431,8 +2437,8 @@ TextEventProc(clientData, eventPtr)
*/
static void
-TextCmdDeletedProc(clientData)
- ClientData clientData; /* Pointer to widget record for widget. */
+TextCmdDeletedProc(
+ ClientData clientData) /* Pointer to widget record for widget. */
{
TkText *textPtr = (TkText *) clientData;
Tk_Window tkwin = textPtr->tkwin;
@@ -2476,15 +2482,15 @@ TextCmdDeletedProc(clientData)
*/
static int
-InsertChars(sharedTextPtr, textPtr, indexPtr, stringPtr, viewUpdate)
- TkSharedText *sharedTextPtr;
- TkText *textPtr; /* Overall information about text widget. */
- TkTextIndex *indexPtr; /* Where to insert new characters. May be
+InsertChars(
+ TkSharedText *sharedTextPtr,
+ TkText *textPtr, /* Overall information about text widget. */
+ TkTextIndex *indexPtr, /* Where to insert new characters. May be
* modified if the index is not valid for
* insertion (e.g. if at "end"). */
- Tcl_Obj *stringPtr; /* Null-terminated string containing new
+ Tcl_Obj *stringPtr, /* Null-terminated string containing new
* information to add to text. */
- int viewUpdate; /* Update the view if set */
+ int viewUpdate) /* Update the view if set. */
{
int lineIndex, length;
TkText *tPtr;
@@ -2544,28 +2550,27 @@ InsertChars(sharedTextPtr, textPtr, indexPtr, stringPtr, viewUpdate)
TkBTreeInsertChars(sharedTextPtr->tree, indexPtr, string);
/*
- * Push the insertion on the undo stack, and update
- * the modified status of the widget
+ * Push the insertion on the undo stack, and update the modified status of
+ * the widget.
*/
if (length > 0) {
if (sharedTextPtr->undo) {
TkTextIndex toIndex;
-
+
if (sharedTextPtr->autoSeparators &&
sharedTextPtr->lastEditMode != TK_TEXT_EDIT_INSERT) {
TkUndoInsertUndoSeparator(sharedTextPtr->undoStack);
}
-
+
sharedTextPtr->lastEditMode = TK_TEXT_EDIT_INSERT;
-
+
TkTextIndexForwBytes(textPtr, indexPtr, length, &toIndex);
TextPushUndoAction(textPtr, stringPtr, 1, indexPtr, &toIndex);
}
UpdateDirtyFlag(sharedTextPtr);
}
-
resetViewCount = 0;
for (tPtr = sharedTextPtr->peers; tPtr != NULL ; tPtr = tPtr->next) {
@@ -2583,7 +2588,7 @@ InsertChars(sharedTextPtr, textPtr, indexPtr, stringPtr, viewUpdate)
resetViewCount += 2;
}
if (sharedTextPtr->refCount > PIXEL_CLIENTS) {
- ckfree((char*)lineAndByteIndex);
+ ckfree((char *) lineAndByteIndex);
}
/*
@@ -2621,14 +2626,14 @@ InsertChars(sharedTextPtr, textPtr, indexPtr, stringPtr, viewUpdate)
*/
static void
-TextPushUndoAction (textPtr, undoString, insert, index1Ptr, index2Ptr)
- TkText *textPtr; /* Overall information about text widget. */
- Tcl_Obj *undoString; /* New text */
- int insert; /* 1 if insert, else delete */
- CONST TkTextIndex *index1Ptr;
- /* Index describing first location */
- CONST TkTextIndex *index2Ptr;
- /* Index describing second location */
+TextPushUndoAction(
+ TkText *textPtr, /* Overall information about text widget. */
+ Tcl_Obj *undoString, /* New text. */
+ int insert, /* 1 if insert, else delete. */
+ CONST TkTextIndex *index1Ptr,
+ /* Index describing first location. */
+ CONST TkTextIndex *index2Ptr)
+ /* Index describing second location. */
{
TkUndoSubAtom *iAtom, *dAtom;
@@ -2675,7 +2680,8 @@ TextPushUndoAction (textPtr, undoString, insert, index1Ptr, index2Ptr)
Tcl_ListObjAppendElement(NULL, markSet1InsertObj, index1Obj);
Tcl_ListObjAppendElement(NULL, markSet2InsertObj, index2Obj);
- Tcl_ListObjAppendElement(NULL, insertCmdObj, Tcl_NewStringObj("insert",6));
+ Tcl_ListObjAppendElement(NULL, insertCmdObj,
+ Tcl_NewStringObj("insert", 6));
Tcl_ListObjAppendElement(NULL, insertCmdObj, index1Obj);
/*
@@ -2684,7 +2690,8 @@ TextPushUndoAction (textPtr, undoString, insert, index1Ptr, index2Ptr)
Tcl_ListObjAppendElement(NULL, insertCmdObj, undoString);
- Tcl_ListObjAppendElement(NULL, deleteCmdObj, Tcl_NewStringObj("delete",6));
+ Tcl_ListObjAppendElement(NULL, deleteCmdObj,
+ Tcl_NewStringObj("delete", 6));
Tcl_ListObjAppendElement(NULL, deleteCmdObj, index1Obj);
Tcl_ListObjAppendElement(NULL, deleteCmdObj, index2Obj);
@@ -2692,7 +2699,7 @@ TextPushUndoAction (textPtr, undoString, insert, index1Ptr, index2Ptr)
* Note: we don't wish to use textPtr->widgetCmd in these callbacks
* because if we delete the textPtr, but peers still exist, we will then
* have references to a non-existent Tcl_Command in the undo stack, which
- * will lead to crashes later. Also, the behaviour of the widget wrt
+ * will lead to crashes later. Also, the behaviour of the widget w.r.t.
* bindings (%W substitutions) always uses the widget path name, so there
* is no good reason the undo stack should do otherwise.
*
@@ -2749,17 +2756,16 @@ TextPushUndoAction (textPtr, undoString, insert, index1Ptr, index2Ptr)
*/
int
-TextUndoRedoCallback(interp, clientData, objPtr)
- Tcl_Interp *interp; /* Current interpreter. */
- ClientData clientData; /* Passed from undo code, but contains our
+TextUndoRedoCallback(
+ Tcl_Interp *interp, /* Current interpreter. */
+ ClientData clientData, /* Passed from undo code, but contains our
* shared text data structure. */
- Tcl_Obj *objPtr; /* Arguments of a command to be handled by the
+ Tcl_Obj *objPtr) /* Arguments of a command to be handled by the
* shared text data structure. */
{
- TkSharedText *sharedPtr = (TkSharedText*)clientData;
- int objc;
+ TkSharedText *sharedPtr = (TkSharedText *) clientData;
+ int res, objc;
Tcl_Obj **objv;
- int res;
TkText *textPtr;
res = Tcl_ListObjGetElements(interp, objPtr, &objc, &objv);
@@ -2847,16 +2853,16 @@ TextUndoRedoCallback(interp, clientData, objPtr)
*/
static int
-CountIndices(textPtr, indexPtr1, indexPtr2, type)
- CONST TkText *textPtr; /* Overall information about text widget. */
- CONST TkTextIndex *indexPtr1;
+CountIndices(
+ CONST TkText *textPtr, /* Overall information about text widget. */
+ CONST TkTextIndex *indexPtr1,
/* Index describing location of first
* character to delete. */
- CONST TkTextIndex *indexPtr2;
+ CONST TkTextIndex *indexPtr2,
/* Index describing location of last character
* to delete. NULL means just delete the one
* character given by indexPtr1. */
- TkTextCountType type; /* The kind of indices to count */
+ TkTextCountType type) /* The kind of indices to count. */
{
/*
* Order the starting and stopping indices.
@@ -2885,8 +2891,8 @@ CountIndices(textPtr, indexPtr1, indexPtr2, type)
* Returns a standard Tcl result, currently always TCL_OK.
*
* Side effects:
- * Characters and other entities (windows, images) get deleted
- * from the text.
+ * Characters and other entities (windows, images) get deleted from the
+ * text.
*
* If 'viewUpdate' is true, we may adjust the window contents'
* y-position, and scrollbar setting.
@@ -2902,18 +2908,18 @@ CountIndices(textPtr, indexPtr1, indexPtr2, type)
*/
static int
-DeleteIndexRange(sharedTextPtr, textPtr, indexPtr1, indexPtr2, viewUpdate)
- TkSharedText *sharedTextPtr;/* Shared portion of peer widgets. */
- TkText *textPtr; /* Overall information about text widget. */
- CONST TkTextIndex *indexPtr1;
+DeleteIndexRange(
+ TkSharedText *sharedTextPtr,/* Shared portion of peer widgets. */
+ TkText *textPtr, /* Overall information about text widget. */
+ CONST TkTextIndex *indexPtr1,
/* Index describing location of first
* character (or other entity) to delete. */
- CONST TkTextIndex *indexPtr2;
+ CONST TkTextIndex *indexPtr2,
/* Index describing location of last
* character (or other entity) to delete.
* NULL means just delete the one character
- * given by indexPtr1. */
- int viewUpdate; /* Update vertical view if set. */
+ * given by indexPtr1. */
+ int viewUpdate) /* Update vertical view if set. */
{
int line1, line2;
TkTextIndex index1, index2;
@@ -2955,9 +2961,8 @@ DeleteIndexRange(sharedTextPtr, textPtr, indexPtr1, indexPtr2, viewUpdate)
* even number of lines gets deleted. Furthermore, remove any tags that
* are present on the newline that isn't going to be deleted after all
* (this simulates deleting the newline and then adding a "clean" one back
- * again).
- * Note that index1 and index2 might now be equal again which means that
- * no text will be deleted but tags might be removed.
+ * again). Note that index1 and index2 might now be equal again which
+ * means that no text will be deleted but tags might be removed.
*/
line1 = TkBTreeLinesTo(textPtr, index1.linePtr);
@@ -3089,27 +3094,27 @@ DeleteIndexRange(sharedTextPtr, textPtr, indexPtr1, indexPtr2, viewUpdate)
}
/*
- * Push the deletion on the undo stack if something was actually deleted
+ * Push the deletion on the undo stack if something was actually deleted.
*/
if (TkTextIndexCmp(&index1, &index2) < 0) {
if (sharedTextPtr->undo) {
Tcl_Obj *get;
-
+
if (sharedTextPtr->autoSeparators
&& (sharedTextPtr->lastEditMode != TK_TEXT_EDIT_DELETE)) {
TkUndoInsertUndoSeparator(sharedTextPtr->undoStack);
}
-
+
sharedTextPtr->lastEditMode = TK_TEXT_EDIT_DELETE;
-
+
get = TextGetText(textPtr, &index1, &index2, 0);
TextPushUndoAction(textPtr, get, 0, &index1, &index2);
}
UpdateDirtyFlag(sharedTextPtr);
-
+
sharedTextPtr->stateEpoch++;
-
+
TkBTreeDeleteIndexRange(sharedTextPtr->tree, &index1, &index2);
}
@@ -3135,7 +3140,7 @@ DeleteIndexRange(sharedTextPtr, textPtr, indexPtr1, indexPtr2, viewUpdate)
resetViewCount += 2;
}
if (sharedTextPtr->refCount > PIXEL_CLIENTS) {
- ckfree((char*)lineAndByteIndex);
+ ckfree((char *) lineAndByteIndex);
}
if (line1 >= line2) {
@@ -3175,12 +3180,12 @@ DeleteIndexRange(sharedTextPtr, textPtr, indexPtr1, indexPtr2, viewUpdate)
*/
static int
-TextFetchSelection(clientData, offset, buffer, maxBytes)
- ClientData clientData; /* Information about text widget. */
- int offset; /* Offset within selection of first character
+TextFetchSelection(
+ ClientData clientData, /* Information about text widget. */
+ int offset, /* Offset within selection of first character
* to be returned. */
- char *buffer; /* Location in which to place selection. */
- int maxBytes; /* Maximum number of bytes to place at buffer,
+ char *buffer, /* Location in which to place selection. */
+ int maxBytes) /* Maximum number of bytes to place at buffer,
* not including terminating NULL
* character. */
{
@@ -3267,8 +3272,8 @@ TextFetchSelection(clientData, offset, buffer, maxBytes)
}
if ((segPtr->typePtr == &tkTextCharType)
&& !TkTextIsElided(textPtr, &textPtr->selIndex, NULL)) {
- memcpy((VOID *) buffer, (VOID *) (segPtr->body.chars
- + offsetInSeg), (size_t) chunkSize);
+ memcpy(buffer, segPtr->body.chars + offsetInSeg,
+ (size_t) chunkSize);
buffer += chunkSize;
maxBytes -= chunkSize;
count += chunkSize;
@@ -3312,8 +3317,8 @@ TextFetchSelection(clientData, offset, buffer, maxBytes)
*/
void
-TkTextLostSelection(clientData)
- ClientData clientData; /* Information about text widget. */
+TkTextLostSelection(
+ ClientData clientData) /* Information about text widget. */
{
register TkText *textPtr = (TkText *) clientData;
@@ -3367,8 +3372,8 @@ TkTextLostSelection(clientData)
*/
void
-TkTextSelectionEvent(textPtr)
- TkText *textPtr;
+TkTextSelectionEvent(
+ TkText *textPtr)
{
/*
* Send an event that the selection changed. This is equivalent to:
@@ -3377,7 +3382,7 @@ TkTextSelectionEvent(textPtr)
XEvent event;
- memset((VOID *) &event, 0, sizeof(event));
+ memset(&event, 0, sizeof(event));
event.xany.type = VirtualEvent;
event.xany.serial = NextRequest(Tk_Display(textPtr->tkwin));
event.xany.send_event = False;
@@ -3406,8 +3411,8 @@ TkTextSelectionEvent(textPtr)
*/
static void
-TextBlinkProc(clientData)
- ClientData clientData; /* Pointer to record describing text. */
+TextBlinkProc(
+ ClientData clientData) /* Pointer to record describing text. */
{
register TkText *textPtr = (TkText *) clientData;
TkTextIndex index;
@@ -3471,14 +3476,14 @@ TextBlinkProc(clientData)
*/
static int
-TextInsertCmd(sharedTextPtr, textPtr, interp, objc, objv, indexPtr, viewUpdate)
- TkSharedText *sharedTextPtr;/* Shared portion of peer widgets. */
- TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
- CONST TkTextIndex *indexPtr;/* Index at which to insert */
- int viewUpdate; /* Update the view if set */
+TextInsertCmd(
+ TkSharedText *sharedTextPtr,/* Shared portion of peer widgets. */
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[], /* Argument objects. */
+ CONST TkTextIndex *indexPtr,/* Index at which to insert. */
+ int viewUpdate) /* Update the view if set. */
{
TkTextIndex index1, index2;
int j;
@@ -3551,25 +3556,24 @@ TextInsertCmd(sharedTextPtr, textPtr, interp, objc, objv, indexPtr, viewUpdate)
*/
static int
-TextSearchCmd(textPtr, interp, objc, objv)
- TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+TextSearchCmd(
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
int i, argsLeft, code;
SearchSpec searchSpec;
static CONST char *switchStrings[] = {
- "--", "-all", "-backwards", "-count", "-elide", "-exact",
- "-forwards", "-hidden", "-nocase", "-nolinestop",
- "-overlap", "-regexp", "-strictlimits", NULL
+ "--", "-all", "-backwards", "-count", "-elide", "-exact", "-forwards",
+ "-hidden", "-nocase", "-nolinestop", "-overlap", "-regexp",
+ "-strictlimits", NULL
};
enum SearchSwitches {
SEARCH_END, SEARCH_ALL, SEARCH_BACK, SEARCH_COUNT, SEARCH_ELIDE,
SEARCH_EXACT, SEARCH_FWD, SEARCH_HIDDEN, SEARCH_NOCASE,
- SEARCH_NOLINESTOP, SEARCH_OVERLAP, SEARCH_REGEXP,
- SEARCH_STRICTLIMITS
+ SEARCH_NOLINESTOP, SEARCH_OVERLAP, SEARCH_REGEXP, SEARCH_STRICTLIMITS
};
/*
@@ -3608,7 +3612,7 @@ TextSearchCmd(textPtr, interp, objc, objv)
if (Tcl_GetIndexFromObj(interp, objv[i], switchStrings, "switch", 0,
&index) != TCL_OK) {
/*
- * Hide the -hidden option
+ * Hide the -hidden option.
*/
Tcl_ResetResult(interp);
@@ -3720,7 +3724,7 @@ TextSearchCmd(textPtr, interp, objc, objv)
}
/*
- * Set the result
+ * Set the result.
*/
if (searchSpec.resPtr != NULL) {
@@ -3763,18 +3767,19 @@ TextSearchCmd(textPtr, interp, objc, objv)
*
*----------------------------------------------------------------------
*/
+
static int
-TextSearchGetLineIndex(interp, objPtr, searchSpecPtr, linePosPtr, offsetPosPtr)
- Tcl_Interp *interp; /* For error messages */
- Tcl_Obj *objPtr; /* Contains a textual index like "1.2" */
- SearchSpec *searchSpecPtr; /* Contains other search parameters */
- int *linePosPtr; /* For returning the line number. */
- int *offsetPosPtr; /* For returning the text offset in the
+TextSearchGetLineIndex(
+ Tcl_Interp *interp, /* For error messages. */
+ Tcl_Obj *objPtr, /* Contains a textual index like "1.2" */
+ SearchSpec *searchSpecPtr, /* Contains other search parameters. */
+ int *linePosPtr, /* For returning the line number. */
+ int *offsetPosPtr) /* For returning the text offset in the
* line. */
{
CONST TkTextIndex *indexPtr;
int line;
- TkText *textPtr = (TkText*)(searchSpecPtr->clientData);
+ TkText *textPtr = (TkText *) searchSpecPtr->clientData;
indexPtr = TkTextGetIndexFromObj(interp, textPtr, objPtr);
if (indexPtr == NULL) {
@@ -3799,8 +3804,8 @@ TextSearchGetLineIndex(interp, objPtr, searchSpecPtr, linePosPtr, offsetPosPtr)
}
*offsetPosPtr = TextSearchIndexInLine(searchSpecPtr, linePtr, count);
} else {
- *offsetPosPtr = TextSearchIndexInLine(searchSpecPtr, indexPtr->linePtr,
- indexPtr->byteIndex);
+ *offsetPosPtr = TextSearchIndexInLine(searchSpecPtr,
+ indexPtr->linePtr, indexPtr->byteIndex);
}
*linePosPtr = line;
@@ -3830,16 +3835,16 @@ TextSearchGetLineIndex(interp, objPtr, searchSpecPtr, linePosPtr, offsetPosPtr)
*/
static int
-TextSearchIndexInLine(searchSpecPtr, linePtr, byteIndex)
- CONST SearchSpec *searchSpecPtr;
- /* Search parameters */
- TkTextLine *linePtr; /* The line we're looking at */
- int byteIndex; /* Index into the line */
+TextSearchIndexInLine(
+ CONST SearchSpec *searchSpecPtr,
+ /* Search parameters. */
+ TkTextLine *linePtr, /* The line we're looking at. */
+ int byteIndex) /* Index into the line. */
{
TkTextSegment *segPtr;
TkTextIndex curIndex;
int index, leftToScan;
- TkText *textPtr = (TkText*)(searchSpecPtr->clientData);
+ TkText *textPtr = (TkText *) searchSpecPtr->clientData;
index = 0;
curIndex.tree = textPtr->sharedTextPtr->tree;
@@ -3896,20 +3901,20 @@ TextSearchIndexInLine(searchSpecPtr, linePtr, byteIndex)
*/
static ClientData
-TextSearchAddNextLine(lineNum, searchSpecPtr, theLine, lenPtr, extraLinesPtr)
- int lineNum; /* Line we must add */
- SearchSpec *searchSpecPtr; /* Search parameters */
- Tcl_Obj *theLine; /* Object to append to */
- int *lenPtr; /* For returning the total length */
- int *extraLinesPtr; /* If non-NULL, will have its value
+TextSearchAddNextLine(
+ int lineNum, /* Line we must add. */
+ SearchSpec *searchSpecPtr, /* Search parameters. */
+ Tcl_Obj *theLine, /* Object to append to. */
+ int *lenPtr, /* For returning the total length. */
+ int *extraLinesPtr) /* If non-NULL, will have its value
* incremented by the number of additional
* logical lines which are merged into this
- * one by newlines being elided */
+ * one by newlines being elided. */
{
TkTextLine *linePtr, *thisLinePtr;
TkTextIndex curIndex;
TkTextSegment *segPtr;
- TkText *textPtr = (TkText*)(searchSpecPtr->clientData);
+ TkText *textPtr = (TkText *) searchSpecPtr->clientData;
int nothingYet = 1;
/*
@@ -4010,20 +4015,19 @@ TextSearchAddNextLine(lineNum, searchSpecPtr, theLine, lenPtr, extraLinesPtr)
*/
static int
-TextSearchFoundMatch(lineNum, searchSpecPtr, clientData, theLine, matchOffset,
- matchLength)
- int lineNum; /* Line on which match was found. */
- SearchSpec *searchSpecPtr; /* Search parameters. */
- ClientData clientData; /* Token returned by the 'addNextLineProc',
+TextSearchFoundMatch(
+ int lineNum, /* Line on which match was found. */
+ SearchSpec *searchSpecPtr, /* Search parameters. */
+ ClientData clientData, /* Token returned by the 'addNextLineProc',
* TextSearchAddNextLine. May be NULL, in
* which we case we must generate it (from
* lineNum). */
- Tcl_Obj *theLine; /* Text from current line, only accessed for
+ Tcl_Obj *theLine, /* Text from current line, only accessed for
* exact searches, and is allowed to be NULL
* for regexp searches. */
- int matchOffset; /* Offset of found item in utf-8 bytes for
- * exact search, Unicode chars for regexp */
- int matchLength; /* Length also in bytes/chars as per search
+ int matchOffset, /* Offset of found item in utf-8 bytes for
+ * exact search, Unicode chars for regexp. */
+ int matchLength) /* Length also in bytes/chars as per search
* type. */
{
int numChars;
@@ -4031,7 +4035,7 @@ TextSearchFoundMatch(lineNum, searchSpecPtr, clientData, theLine, matchOffset,
TkTextIndex curIndex, foundIndex;
TkTextSegment *segPtr;
TkTextLine *linePtr;
- TkText *textPtr = (TkText*)(searchSpecPtr->clientData);
+ TkText *textPtr = (TkText *) searchSpecPtr->clientData;
if (lineNum == searchSpecPtr->stopLine) {
/*
@@ -4060,10 +4064,10 @@ TextSearchFoundMatch(lineNum, searchSpecPtr, clientData, theLine, matchOffset,
}
/*
- * If we're using strict limits checking, ensure that the match with
- * its full length fits inside the given range.
+ * If we're using strict limits checking, ensure that the match with its
+ * full length fits inside the given range.
*/
-
+
if (searchSpecPtr->strictLimits && lineNum == searchSpecPtr->stopLine) {
if (searchSpecPtr->backwards ^
((matchOffset + numChars) > searchSpecPtr->stopOffset)) {
@@ -4248,10 +4252,10 @@ TextSearchFoundMatch(lineNum, searchSpecPtr, clientData, theLine, matchOffset,
*/
TkTextTabArray *
-TkTextGetTabs(interp, textPtr, stringPtr)
- Tcl_Interp *interp; /* Used for error reporting. */
- TkText *textPtr; /* Information about the text widget. */
- Tcl_Obj *stringPtr; /* Description of the tab stops. See the text
+TkTextGetTabs(
+ Tcl_Interp *interp, /* Used for error reporting. */
+ TkText *textPtr, /* Information about the text widget. */
+ Tcl_Obj *stringPtr) /* Description of the tab stops. See the text
* manual entry for details. */
{
int objc, i, count;
@@ -4292,8 +4296,7 @@ TkTextGetTabs(interp, textPtr, stringPtr)
tabArrayPtr->numTabs = 0;
prevStop = 0.0;
lastStop = 0.0;
- for (i = 0, tabPtr = &tabArrayPtr->tabs[0]; i < objc;
- i++, tabPtr++) {
+ for (i = 0, tabPtr = &tabArrayPtr->tabs[0]; i < objc; i++, tabPtr++) {
int index;
/*
@@ -4414,21 +4417,21 @@ TkTextGetTabs(interp, textPtr, stringPtr)
*/
static int
-TextDumpCmd(textPtr, interp, objc, objv)
- register TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. Someone else has already
+TextDumpCmd(
+ register TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. Someone else has already
* parsed this command enough to know that
* objv[1] is "dump". */
{
TkTextIndex index1, index2;
int arg;
- int lineno; /* Current line number */
- int what = 0; /* bitfield to select segment types */
- int atEnd; /* True if dumping up to logical end */
+ int lineno; /* Current line number. */
+ int what = 0; /* bitfield to select segment types. */
+ int atEnd; /* True if dumping up to logical end. */
TkTextLine *linePtr;
- Tcl_Obj *command = NULL; /* Script callback to apply to segments */
+ Tcl_Obj *command = NULL; /* Script callback to apply to segments. */
#define TK_DUMP_TEXT 0x1
#define TK_DUMP_MARK 0x2
#define TK_DUMP_TAG 0x4
@@ -4525,13 +4528,15 @@ TextDumpCmd(textPtr, interp, objc, objv)
int textChanged;
int lineend = TkBTreeLinesTo(textPtr, index2.linePtr);
int endByteIndex = index2.byteIndex;
-
+
textChanged = DumpLine(interp, textPtr, what, index1.linePtr,
index1.byteIndex, 32000000, lineno, command);
if (textChanged) {
- if (textPtr->flags & DESTROYED) return TCL_OK;
- linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
- textPtr, lineno);
+ if (textPtr->flags & DESTROYED) {
+ return TCL_OK;
+ }
+ linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+ textPtr, lineno);
textChanged = 0;
} else {
linePtr = index1.linePtr;
@@ -4544,16 +4549,20 @@ TextDumpCmd(textPtr, interp, objc, objv)
textChanged = DumpLine(interp, textPtr, what, linePtr, 0, 32000000,
lineno, command);
if (textChanged) {
- if (textPtr->flags & DESTROYED) return TCL_OK;
- linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
- textPtr, lineno);
+ if (textPtr->flags & DESTROYED) {
+ return TCL_OK;
+ }
+ linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+ textPtr, lineno);
textChanged = 0;
}
}
if (linePtr != NULL) {
- DumpLine(interp, textPtr, what, linePtr, 0,
- endByteIndex, lineno, command);
- if (textPtr->flags & DESTROYED) return TCL_OK;
+ DumpLine(interp, textPtr, what, linePtr, 0, endByteIndex, lineno,
+ command);
+ if (textPtr->flags & DESTROYED) {
+ return TCL_OK;
+ }
}
}
@@ -4562,8 +4571,14 @@ TextDumpCmd(textPtr, interp, objc, objv)
*/
if (atEnd) {
- if (textPtr->flags & DESTROYED) return TCL_OK;
- /* Re-get the end index, in case it has changed */
+ if (textPtr->flags & DESTROYED) {
+ return TCL_OK;
+ }
+
+ /*
+ * Re-get the end index, in case it has changed.
+ */
+
if (TkTextGetObjIndex(interp, textPtr, objv[arg], &index2) != TCL_OK) {
return TCL_ERROR;
}
@@ -4582,29 +4597,31 @@ TextDumpCmd(textPtr, interp, objc, objv)
* "start" up to, but not including, "end".
*
* Results:
- * Returns 1 if the command callback made any changes to the text
- * widget which will have invalidated internal structures such as
- * TkTextSegment, TkTextIndex, pointers. Our caller can then take
- * action to recompute such entities. Returns 0 otherwise.
+ * Returns 1 if the command callback made any changes to the text widget
+ * which will have invalidated internal structures such as TkTextSegment,
+ * TkTextIndex, pointers. Our caller can then take action to recompute
+ * such entities. Returns 0 otherwise.
*
* Side effects:
* None, but see DumpSegment which can have arbitrary side-effects
*
*----------------------------------------------------------------------
*/
+
static int
-DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
- Tcl_Interp *interp;
- TkText *textPtr;
- int what; /* bit flags to select segment types */
- TkTextLine *linePtr; /* The current line */
- int startByte, endByte; /* Byte range to dump */
- int lineno; /* Line number for indices dump */
- Tcl_Obj *command; /* Script to apply to the segment */
+DumpLine(
+ Tcl_Interp *interp,
+ TkText *textPtr,
+ int what, /* Bit flags to select segment types. */
+ TkTextLine *linePtr, /* The current line. */
+ int startByte, int endByte, /* Byte range to dump. */
+ int lineno, /* Line number for indices dump. */
+ Tcl_Obj *command) /* Script to apply to the segment. */
{
- int offset = 0;
TkTextSegment *segPtr;
TkTextIndex index;
+ int offset = 0, textChanged = 0;
+
/*
* Must loop through line looking at its segments.
* character
@@ -4614,17 +4631,15 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
* window
*/
- int textChanged = 0;
-
segPtr = linePtr->segPtr;
while ((offset < endByte) && (segPtr != NULL)) {
int lineChanged = 0;
int currentSize = segPtr->size;
-
+
if ((what & TK_DUMP_TEXT) && (segPtr->typePtr == &tkTextCharType) &&
(offset + segPtr->size > startByte)) {
- int last = segPtr->size; /* Index of last char in seg */
- int first = 0; /* Index of first char in seg */
+ int last = segPtr->size; /* Index of last char in seg. */
+ int first = 0; /* Index of first char in seg. */
if (offset + segPtr->size > endByte) {
last = endByte - offset;
@@ -4634,27 +4649,29 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
}
if (last != segPtr->size) {
/*
- * To avoid modifying the string in place we copy over
- * just the segment that we want. Since DumpSegment can
- * modify the text, we could not confidently revert the
- * modification here.
+ * To avoid modifying the string in place we copy over just
+ * the segment that we want. Since DumpSegment can modify the
+ * text, we could not confidently revert the modification
+ * here.
*/
+
int length = last - first;
-
- char *range = (char*) ckalloc((length + 1) * sizeof(char));
- memcpy(range, segPtr->body.chars + first, length * sizeof(char));
+ char *range = ckalloc((length + 1) * sizeof(char));
+
+ memcpy(range, segPtr->body.chars + first,
+ length * sizeof(char));
range[length] = '\0';
- TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, lineno,
- offset + first, &index);
+ TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
+ lineno, offset + first, &index);
lineChanged = DumpSegment(textPtr, interp, "text", range,
command, &index, what);
ckfree(range);
} else {
- TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, lineno,
- offset + first, &index);
- lineChanged = DumpSegment(textPtr, interp, "text", segPtr->body.chars + first,
- command, &index, what);
+ TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
+ lineno, offset + first, &index);
+ lineChanged = DumpSegment(textPtr, interp, "text",
+ segPtr->body.chars + first, command, &index, what);
}
} else if ((offset >= startByte)) {
if ((what & TK_DUMP_MARK) && (segPtr->typePtr->name[0] == 'm')) {
@@ -4671,7 +4688,8 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
}
TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
lineno, offset, &index);
- lineChanged = DumpSegment(textPtr, interp, "mark", name, command, &index, what);
+ lineChanged = DumpSegment(textPtr, interp, "mark", name,
+ command, &index, what);
} else if ((what & TK_DUMP_TAG) &&
(segPtr->typePtr == &tkTextToggleOnType)) {
TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
@@ -4693,8 +4711,8 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
lineno, offset, &index);
- lineChanged = DumpSegment(textPtr, interp, "image", name, command, &index,
- what);
+ lineChanged = DumpSegment(textPtr, interp, "image", name,
+ command, &index, what);
} else if ((what & TK_DUMP_WIN) &&
(segPtr->typePtr->name[0] == 'w')) {
TkTextEmbWindow *ewPtr = (TkTextEmbWindow *)&segPtr->body;
@@ -4707,34 +4725,42 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
}
TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
lineno, offset, &index);
- lineChanged = DumpSegment(textPtr, interp, "window", pathname, command,
- &index, what);
+ lineChanged = DumpSegment(textPtr, interp, "window", pathname,
+ command, &index, what);
}
}
offset += currentSize;
if (lineChanged) {
- TkTextSegment * newSegPtr;
+ TkTextSegment *newSegPtr;
int newOffset = 0;
+
textChanged = 1;
- /* Our indices are no longer valid */
+
+ /*
+ * Our indices are no longer valid.
+ */
+
if (textPtr->flags & DESTROYED) {
return textChanged;
}
- linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
- textPtr, lineno);
+ linePtr = TkBTreeFindLine(textPtr->sharedTextPtr->tree,
+ textPtr, lineno);
newSegPtr = linePtr->segPtr;
if (segPtr == newSegPtr) {
segPtr = segPtr->nextPtr;
} else {
- while ((newOffset < endByte) && (newOffset < offset)
- && (newSegPtr != NULL)) {
+ while ((newOffset < endByte) && (newOffset < offset)
+ && (newSegPtr != NULL)) {
newOffset += segPtr->size;
newSegPtr = newSegPtr->nextPtr;
- if (segPtr == newSegPtr) break;
+ if (segPtr == newSegPtr) {
+ break;
+ }
}
- if (segPtr != newSegPtr && newOffset == offset
- && currentSize == 0) {
+ if (segPtr != newSegPtr && newOffset == offset
+ && currentSize == 0) {
TkTextSegment *searchPtr = newSegPtr;
+
while (searchPtr != NULL && searchPtr->size == 0) {
if (searchPtr == segPtr) {
newSegPtr = searchPtr;
@@ -4764,10 +4790,10 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
* make a script callback with that information as arguments.
*
* Results:
- * Returns 1 if the command callback made any changes to the text
- * widget which will have invalidated internal structures such as
- * TkTextSegment, TkTextIndex, pointers. Our caller can then take
- * action to recompute such entities. Returns 0 otherwise.
+ * Returns 1 if the command callback made any changes to the text widget
+ * which will have invalidated internal structures such as TkTextSegment,
+ * TkTextIndex, pointers. Our caller can then take action to recompute
+ * such entities. Returns 0 otherwise.
*
* Side effects:
* Either evals the callback or appends elements to the result string.
@@ -4777,14 +4803,14 @@ DumpLine(interp, textPtr, what, linePtr, startByte, endByte, lineno, command)
*/
static int
-DumpSegment(textPtr, interp, key, value, command, index, what)
- TkText *textPtr;
- Tcl_Interp *interp;
- CONST char *key; /* Segment type key */
- CONST char *value; /* Segment value */
- Tcl_Obj *command; /* Script callback */
- CONST TkTextIndex *index; /* index with line/byte position info */
- int what; /* Look for TK_DUMP_INDEX bit */
+DumpSegment(
+ TkText *textPtr,
+ Tcl_Interp *interp,
+ CONST char *key, /* Segment type key. */
+ CONST char *value, /* Segment value. */
+ Tcl_Obj *command, /* Script callback. */
+ CONST TkTextIndex *index, /* index with line/byte position info. */
+ int what) /* Look for TK_DUMP_INDEX bit. */
{
char buffer[TK_POS_CHARS];
@@ -4798,7 +4824,7 @@ DumpSegment(textPtr, interp, key, value, command, index, what)
CONST char *argv[4];
char *list;
int oldStateEpoch = TkBTreeEpoch(textPtr->sharedTextPtr->tree);
-
+
argv[0] = key;
argv[1] = value;
argv[2] = buffer;
@@ -4806,8 +4832,8 @@ DumpSegment(textPtr, interp, key, value, command, index, what)
list = Tcl_Merge(3, argv);
Tcl_VarEval(interp, Tcl_GetString(command), " ", list, NULL);
ckfree(list);
- if ((textPtr->flags & DESTROYED)
- || (TkBTreeEpoch(textPtr->sharedTextPtr->tree) != oldStateEpoch)) {
+ if ((textPtr->flags & DESTROYED) ||
+ TkBTreeEpoch(textPtr->sharedTextPtr->tree) != oldStateEpoch) {
return 1;
} else {
return 0;
@@ -4833,8 +4859,8 @@ DumpSegment(textPtr, interp, key, value, command, index, what)
*/
static int
-TextEditUndo(textPtr)
- TkText *textPtr; /* Overall information about text widget. */
+TextEditUndo(
+ TkText *textPtr) /* Overall information about text widget. */
{
int status;
@@ -4876,8 +4902,8 @@ TextEditUndo(textPtr)
*/
static int
-TextEditRedo(textPtr)
- TkText *textPtr; /* Overall information about text widget. */
+TextEditRedo(
+ TkText *textPtr) /* Overall information about text widget. */
{
int status;
@@ -4916,11 +4942,11 @@ TextEditRedo(textPtr)
*/
static int
-TextEditCmd(textPtr, interp, objc, objv)
- TkText *textPtr; /* Information about text widget. */
- Tcl_Interp *interp; /* Current interpreter. */
- int objc; /* Number of arguments. */
- Tcl_Obj *CONST objv[]; /* Argument objects. */
+TextEditCmd(
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Interp *interp, /* Current interpreter. */
+ int objc, /* Number of arguments. */
+ Tcl_Obj *CONST objv[]) /* Argument objects. */
{
int index;
@@ -4975,7 +5001,7 @@ TextEditCmd(textPtr, interp, objc, objv)
* "event generate $textWidget <<Modified>>"
*/
- memset((VOID *) &event, 0, sizeof(event));
+ memset(&event, 0, sizeof(event));
event.xany.type = VirtualEvent;
event.xany.serial = NextRequest(Tk_Display(textPtr->tkwin));
event.xany.send_event = False;
@@ -5056,14 +5082,14 @@ TextEditCmd(textPtr, interp, objc, objv)
*----------------------------------------------------------------------
*/
-static Tcl_Obj*
-TextGetText(textPtr, indexPtr1,indexPtr2, visibleOnly)
- CONST TkText *textPtr; /* Information about text widget. */
- CONST TkTextIndex *indexPtr1;
+static Tcl_Obj *
+TextGetText(
+ CONST TkText *textPtr, /* Information about text widget. */
+ CONST TkTextIndex *indexPtr1,
/* Get text from this index... */
- CONST TkTextIndex *indexPtr2;
+ CONST TkTextIndex *indexPtr2,
/* ...to this index. */
- int visibleOnly; /* If non-zero, then only return non-elided
+ int visibleOnly) /* If non-zero, then only return non-elided
* characters. */
{
TkTextIndex tmpIndex;
@@ -5090,8 +5116,8 @@ TextGetText(textPtr, indexPtr1,indexPtr2, visibleOnly)
if (indexPtr2->byteIndex == tmpIndex.byteIndex) {
break;
} else {
- int last2 =
- indexPtr2->byteIndex - tmpIndex.byteIndex + offset;
+ int last2 = indexPtr2->byteIndex - tmpIndex.byteIndex
+ + offset;
if (last2 < last) {
last = last2;
@@ -5127,8 +5153,8 @@ TextGetText(textPtr, indexPtr1,indexPtr2, visibleOnly)
*/
static void
-UpdateDirtyFlag(sharedTextPtr)
- TkSharedText *sharedTextPtr;/* Information about text widget. */
+UpdateDirtyFlag(
+ TkSharedText *sharedTextPtr)/* Information about text widget. */
{
int oldDirtyFlag;
@@ -5148,7 +5174,7 @@ UpdateDirtyFlag(sharedTextPtr)
XEvent event;
- memset((VOID *) &event, 0, sizeof(event));
+ memset(&event, 0, sizeof(event));
event.xany.type = VirtualEvent;
event.xany.serial = NextRequest(Tk_Display(textPtr->tkwin));
event.xany.send_event = False;
@@ -5182,15 +5208,15 @@ UpdateDirtyFlag(sharedTextPtr)
*/
static int
-SearchPerform(interp, searchSpecPtr, patObj, fromPtr, toPtr)
- Tcl_Interp *interp; /* For error messages */
- SearchSpec *searchSpecPtr; /* Search parameters */
- Tcl_Obj *patObj; /* Contains an exact string or a regexp
- * pattern. Must have a refCount > 0 */
- Tcl_Obj *fromPtr; /* Contains information describing the first
- * index */
- Tcl_Obj *toPtr; /* NULL or information describing the last
- * index */
+SearchPerform(
+ Tcl_Interp *interp, /* For error messages. */
+ SearchSpec *searchSpecPtr, /* Search parameters. */
+ Tcl_Obj *patObj, /* Contains an exact string or a regexp
+ * pattern. Must have a refCount > 0. */
+ Tcl_Obj *fromPtr, /* Contains information describing the first
+ * index. */
+ Tcl_Obj *toPtr) /* NULL or information describing the last
+ * index. */
{
/*
* Find the starting line and starting offset (measured in Unicode chars
@@ -5209,7 +5235,7 @@ SearchPerform(interp, searchSpecPtr, patObj, fromPtr, toPtr)
if (toPtr != NULL) {
CONST TkTextIndex *indexToPtr, *indexFromPtr;
- TkText *textPtr = (TkText*)(searchSpecPtr->clientData);
+ TkText *textPtr = (TkText *) searchSpecPtr->clientData;
indexToPtr = TkTextGetIndexFromObj(interp, textPtr, toPtr);
if (indexToPtr == NULL) {
@@ -5284,11 +5310,11 @@ SearchPerform(interp, searchSpecPtr, patObj, fromPtr, toPtr)
*/
static int
-SearchCore(interp, searchSpecPtr, patObj)
- Tcl_Interp *interp; /* For error messages */
- SearchSpec *searchSpecPtr; /* Search parameters */
- Tcl_Obj *patObj; /* Contains an exact string or a regexp
- * pattern. Must have a refCount > 0 */
+SearchCore(
+ Tcl_Interp *interp, /* For error messages. */
+ SearchSpec *searchSpecPtr, /* Search parameters. */
+ Tcl_Obj *patObj) /* Contains an exact string or a regexp
+ * pattern. Must have a refCount > 0. */
{
/*
* For exact searches these are utf-8 char* offsets, for regexp searches
@@ -5569,6 +5595,7 @@ SearchCore(interp, searchSpecPtr, patObj)
/*
* No match.
*/
+
break;
} else {
int extraLines = 1;
@@ -5687,7 +5714,7 @@ SearchCore(interp, searchSpecPtr, patObj)
searchSpecPtr, lineInfo, theLine, matchOffset,
matchLength)) {
/*
- * We reached the end of the search
+ * We reached the end of the search.
*/
goto searchDone;
@@ -5730,13 +5757,11 @@ SearchCore(interp, searchSpecPtr, patObj)
}
} else {
firstOffset = p - startOfLine +
- Tcl_UtfToUniChar(startOfLine+matchOffset, &ch);
+ Tcl_UtfToUniChar(startOfLine+matchOffset,&ch);
}
}
} while (searchSpecPtr->all);
-
} else {
-
int maxExtraLines = 0;
int matches = 0;
int lastNonOverlap = -1;
@@ -5746,8 +5771,8 @@ SearchCore(interp, searchSpecPtr, patObj)
int match;
int lastFullLine = lastOffset;
- match = Tcl_RegExpExecObj(interp, regexp, theLine, firstOffset,
- 1, ((firstOffset > 0) ? TCL_REG_NOTBOL : 0));
+ match = Tcl_RegExpExecObj(interp, regexp, theLine,
+ firstOffset, 1, (firstOffset>0 ? TCL_REG_NOTBOL : 0));
if (match < 0) {
code = TCL_ERROR;
goto searchDone;
@@ -5798,7 +5823,7 @@ SearchCore(interp, searchSpecPtr, patObj)
prevFullLine = lastTotal;
/*
- * Move firstOffset to first possible start
+ * Move firstOffset to first possible start.
*/
if (!match) {
@@ -5896,7 +5921,7 @@ SearchCore(interp, searchSpecPtr, patObj)
if (match && ((firstOffset + info.matches[0].end)
>= prevFullLine)) {
if (extraLines > 0) {
- extraLinesSearched = extraLines - 1;
+ extraLinesSearched = extraLines - 1;
}
lastFullLine = prevFullLine;
}
@@ -5948,7 +5973,7 @@ SearchCore(interp, searchSpecPtr, patObj)
*/
if (thisOffset-lastNonOverlap >=
- lastBackwardsMatchOffset+matchLength) {
+ lastBackwardsMatchOffset+matchLength){
/*
* Totally encloses previous match, so
* forget the previous match.
@@ -6078,7 +6103,7 @@ SearchCore(interp, searchSpecPtr, patObj)
searchSpecPtr, lineInfo, theLine, matchOffset,
matchLength)) {
/*
- * We reached the end of the search
+ * We reached the end of the search.
*/
goto searchDone;
@@ -6213,7 +6238,7 @@ SearchCore(interp, searchSpecPtr, patObj)
while (linesSearched-- > 0) {
/*
- * If we have just completed the 'stopLine', we are done
+ * If we have just completed the 'stopLine', we are done.
*/
if (lineNum == searchSpecPtr->stopLine) {
@@ -6277,18 +6302,18 @@ SearchCore(interp, searchSpecPtr, patObj)
}
/*
- * Free up the cached line and pattern
+ * Free up the cached line and pattern.
*/
Tcl_DecrRefCount(theLine);
Tcl_DecrRefCount(patObj);
/*
- * Free up any extra space we allocated
+ * Free up any extra space we allocated.
*/
if (storeMatch != smArray) {
- ckfree((char*)storeMatch);
+ ckfree((char *) storeMatch);
}
return code;
@@ -6312,11 +6337,11 @@ SearchCore(interp, searchSpecPtr, patObj)
*/
static Tcl_Obj *
-GetLineStartEnd(clientData, tkwin, recordPtr, internalOffset)
- ClientData clientData;
- Tk_Window tkwin;
- char *recordPtr; /* Pointer to widget record. */
- int internalOffset; /* Offset within *recordPtr containing the
+GetLineStartEnd(
+ ClientData clientData,
+ Tk_Window tkwin,
+ char *recordPtr, /* Pointer to widget record. */
+ int internalOffset) /* Offset within *recordPtr containing the
* line value. */
{
TkTextLine *linePtr = *(TkTextLine **)(recordPtr + internalOffset);
@@ -6348,23 +6373,22 @@ GetLineStartEnd(clientData, tkwin, recordPtr, internalOffset)
*/
static int
-SetLineStartEnd(clientData, interp, tkwin, value, recordPtr, internalOffset,
- oldInternalPtr, flags)
- ClientData clientData;
- Tcl_Interp *interp; /* Current interp; may be used for errors. */
- Tk_Window tkwin; /* Window for which option is being set. */
- Tcl_Obj **value; /* Pointer to the pointer to the value object.
+SetLineStartEnd(
+ ClientData clientData,
+ Tcl_Interp *interp, /* Current interp; may be used for errors. */
+ Tk_Window tkwin, /* Window for which option is being set. */
+ Tcl_Obj **value, /* Pointer to the pointer to the value object.
* We use a pointer to the pointer because we
* may need to return a value (NULL). */
- char *recordPtr; /* Pointer to storage for the widget record. */
- int internalOffset; /* Offset within *recordPtr at which the
+ char *recordPtr, /* Pointer to storage for the widget record. */
+ int internalOffset, /* Offset within *recordPtr at which the
* internal value is to be stored. */
- char *oldInternalPtr; /* Pointer to storage for the old value. */
- int flags; /* Flags for the option, set Tk_SetOptions. */
+ char *oldInternalPtr, /* Pointer to storage for the old value. */
+ int flags) /* Flags for the option, set Tk_SetOptions. */
{
TkTextLine *linePtr = NULL;
char *internalPtr;
- TkText *textPtr = (TkText*)recordPtr;
+ TkText *textPtr = (TkText *) recordPtr;
if (internalOffset >= 0) {
internalPtr = recordPtr + internalOffset;
@@ -6408,11 +6432,11 @@ SetLineStartEnd(clientData, interp, tkwin, value, recordPtr, internalOffset,
*/
static void
-RestoreLineStartEnd(clientData, tkwin, internalPtr, oldInternalPtr)
- ClientData clientData;
- Tk_Window tkwin;
- char *internalPtr; /* Pointer to storage for value. */
- char *oldInternalPtr; /* Pointer to old value. */
+RestoreLineStartEnd(
+ ClientData clientData,
+ Tk_Window tkwin,
+ char *internalPtr, /* Pointer to storage for value. */
+ char *oldInternalPtr) /* Pointer to old value. */
{
*(TkTextLine **)internalPtr = *(TkTextLine **)oldInternalPtr;
}
@@ -6436,8 +6460,8 @@ RestoreLineStartEnd(clientData, tkwin, internalPtr, oldInternalPtr)
*/
static int
-ObjectIsEmpty(objPtr)
- Tcl_Obj *objPtr; /* Object to test. May be NULL. */
+ObjectIsEmpty(
+ Tcl_Obj *objPtr) /* Object to test. May be NULL. */
{
int length;
@@ -6493,7 +6517,7 @@ TkpTesttextCmd(
if (info.isNativeObjectProc) {
textPtr = (TkText *) info.objClientData;
} else {
- textPtr = (TkText *) info.clientData;
+ textPtr = (TkText *) info.clientData;
}
len = strlen(argv[2]);
if (strncmp(argv[2], "byteindex", len) == 0) {
@@ -6534,3 +6558,11 @@ TkpTesttextCmd(
return TCL_OK;
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkTextBTree.c b/generic/tkTextBTree.c
index e8f0112..9b104c6 100644
--- a/generic/tkTextBTree.c
+++ b/generic/tkTextBTree.c
@@ -11,7 +11,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextBTree.c,v 1.23 2007/01/18 23:20:37 nijtmans Exp $
+ * RCS: @(#) $Id: tkTextBTree.c,v 1.24 2007/02/22 13:56:33 dkf Exp $
*/
#include "tkInt.h"
@@ -66,7 +66,7 @@ typedef struct Node {
Summary *summaryPtr; /* First in malloc-ed list of info about tags
* in this subtree (NULL if no tag info in the
* subtree). */
- int level; /* Level of this node in the B-tree. 0 refers
+ int level; /* Level of this node in the B-tree. 0 refers
* to the bottom of the tree (children are
* lines, not nodes). */
union { /* First in linked list of children. */
@@ -76,7 +76,7 @@ typedef struct Node {
int numChildren; /* Number of children of this node. */
int numLines; /* Total number of lines (leaves) in the
* subtree rooted here. */
- int* numPixels; /* Array containing total number of vertical
+ int *numPixels; /* Array containing total number of vertical
* display pixels in the subtree rooted here,
* one entry for each peer widget. */
} Node;
@@ -108,8 +108,8 @@ typedef struct BTree {
int clients; /* Number of clients of this B-tree. */
int pixelReferences; /* Number of clients of this B-tree which care
* about pixel heights. */
- int stateEpoch; /* Updated each time any aspect of the B-tree
- * changes. */
+ int stateEpoch; /* Updated each time any aspect of the B-tree
+ * changes. */
TkSharedText *sharedTextPtr;/* Used to find tagTable in consistency
* checking code, and to access list of all
* B-tree clients. */
@@ -134,8 +134,7 @@ typedef struct TagInfo {
} TagInfo;
/*
- * Variable that indicates whether to enable consistency checks for
- * debugging.
+ * Variable that indicates whether to enable consistency checks for debugging.
*/
int tkBTreeDebug = 0;
@@ -153,47 +152,44 @@ int tkBTreeDebug = 0;
* Forward declarations for functions defined in this file:
*/
-static int AdjustPixelClient _ANSI_ARGS_((BTree *treePtr,
- int defaultHeight, Node *nodePtr, TkTextLine *start,
- TkTextLine *end, int useReference,
- int newPixelReferences, int *counting));
-static void ChangeNodeToggleCount _ANSI_ARGS_((Node *nodePtr,
- TkTextTag *tagPtr, int delta));
-static void CharCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr));
-static int CharDeleteProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr, int treeGone));
-static TkTextSegment * CharCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr));
-static TkTextSegment * CharSplitProc _ANSI_ARGS_((TkTextSegment *segPtr,
- int index));
-static void CheckNodeConsistency _ANSI_ARGS_((Node *nodePtr,
- int references));
-static void CleanupLine _ANSI_ARGS_((TkTextLine *linePtr));
-static void DeleteSummaries _ANSI_ARGS_((Summary *tagPtr));
-static void DestroyNode _ANSI_ARGS_((Node *nodePtr));
-static TkTextSegment * FindTagEnd _ANSI_ARGS_((TkTextBTree tree,
- TkTextTag *tagPtr, TkTextIndex *indexPtr));
-static void IncCount _ANSI_ARGS_((TkTextTag *tagPtr, int inc,
- TagInfo *tagInfoPtr));
-static void Rebalance _ANSI_ARGS_((BTree *treePtr, Node *nodePtr));
-static void RecomputeNodeCounts _ANSI_ARGS_((BTree *treePtr,
- Node *nodePtr));
-static void RemovePixelClient _ANSI_ARGS_((BTree *treePtr,
- Node *nodePtr, int overwriteWithLast));
-static TkTextSegment * SplitSeg _ANSI_ARGS_((TkTextIndex *indexPtr));
-static void ToggleCheckProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr));
-static TkTextSegment * ToggleCleanupProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr));
-static int ToggleDeleteProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr, int treeGone));
-static void ToggleLineChangeProc _ANSI_ARGS_((TkTextSegment *segPtr,
- TkTextLine *linePtr));
-static TkTextSegment * FindTagStart _ANSI_ARGS_((TkTextBTree tree,
- TkTextTag *tagPtr, TkTextIndex *indexPtr));
-static void AdjustStartEndRefs _ANSI_ARGS_((BTree *treePtr,
- TkText *textPtr, int action));
+static int AdjustPixelClient(BTree *treePtr, int defaultHeight,
+ Node *nodePtr, TkTextLine *start, TkTextLine *end,
+ int useReference, int newPixelReferences,
+ int *counting);
+static void ChangeNodeToggleCount(Node *nodePtr,
+ TkTextTag *tagPtr, int delta);
+static void CharCheckProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr);
+static int CharDeleteProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr, int treeGone);
+static TkTextSegment * CharCleanupProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr);
+static TkTextSegment * CharSplitProc(TkTextSegment *segPtr, int index);
+static void CheckNodeConsistency(Node *nodePtr, int references);
+static void CleanupLine(TkTextLine *linePtr);
+static void DeleteSummaries(Summary *tagPtr);
+static void DestroyNode(Node *nodePtr);
+static TkTextSegment * FindTagEnd(TkTextBTree tree, TkTextTag *tagPtr,
+ TkTextIndex *indexPtr);
+static void IncCount(TkTextTag *tagPtr, int inc,
+ TagInfo *tagInfoPtr);
+static void Rebalance(BTree *treePtr, Node *nodePtr);
+static void RecomputeNodeCounts(BTree *treePtr, Node *nodePtr);
+static void RemovePixelClient(BTree *treePtr, Node *nodePtr,
+ int overwriteWithLast);
+static TkTextSegment * SplitSeg(TkTextIndex *indexPtr);
+static void ToggleCheckProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr);
+static TkTextSegment * ToggleCleanupProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr);
+static int ToggleDeleteProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr, int treeGone);
+static void ToggleLineChangeProc(TkTextSegment *segPtr,
+ TkTextLine *linePtr);
+static TkTextSegment * FindTagStart(TkTextBTree tree, TkTextTag *tagPtr,
+ TkTextIndex *indexPtr);
+static void AdjustStartEndRefs(BTree *treePtr, TkText *textPtr,
+ int action);
/*
* Actions for use by AdjustStartEndRefs
@@ -265,8 +261,8 @@ const Tk_SegType tkTextToggleOffType = {
*/
TkTextBTree
-TkBTreeCreate(sharedTextPtr)
- TkSharedText *sharedTextPtr;
+TkBTreeCreate(
+ TkSharedText *sharedTextPtr)
{
register BTree *treePtr;
register Node *rootPtr;
@@ -294,7 +290,7 @@ TkBTreeCreate(sharedTextPtr)
/*
* The tree currently has no registered clients, so all pixel count
- * pointers are simply NULL
+ * pointers are simply NULL.
*/
rootPtr->numPixels = NULL;
@@ -357,8 +353,8 @@ TkBTreeCreate(sharedTextPtr)
*
* Results:
* The return value is the pixelReference used by the B-tree to refer to
- * pixel counts for the new client. It should be stored by the caller.
- * If defaultHeight was negative, then the return value will be -1.
+ * pixel counts for the new client. It should be stored by the caller. If
+ * defaultHeight was negative, then the return value will be -1.
*
* Side effects:
* Memory may be allocated and initialized.
@@ -367,13 +363,13 @@ TkBTreeCreate(sharedTextPtr)
*/
void
-TkBTreeAddClient(tree, textPtr, defaultHeight)
- TkTextBTree tree; /* B-tree to add a client to */
- TkText *textPtr; /* Client to add */
- int defaultHeight; /* Default line height for the new client, or
+TkBTreeAddClient(
+ TkTextBTree tree, /* B-tree to add a client to. */
+ TkText *textPtr, /* Client to add. */
+ int defaultHeight) /* Default line height for the new client, or
* -1 if no pixel heights are to be kept. */
{
- register BTree *treePtr = (BTree*) tree;
+ register BTree *treePtr = (BTree *) tree;
if (treePtr == NULL) {
Tcl_Panic("NULL treePtr in TkBTreeAddClient");
@@ -427,13 +423,13 @@ TkBTreeAddClient(tree, textPtr, defaultHeight)
*/
void
-TkBTreeClientRangeChanged(textPtr, defaultHeight)
- TkText *textPtr; /* Client whose start, end have changed. */
- int defaultHeight; /* Default line height for the new client, or
+TkBTreeClientRangeChanged(
+ TkText *textPtr, /* Client whose start, end have changed. */
+ int defaultHeight) /* Default line height for the new client, or
* -1 if no pixel heights are to be kept. */
{
TkTextLine *end;
- BTree *treePtr = (BTree*) textPtr->sharedTextPtr->tree;
+ BTree *treePtr = (BTree *) textPtr->sharedTextPtr->tree;
int counting = (textPtr->start == NULL ? 1 : 0);
int useReference = textPtr->pixelReference;
@@ -472,8 +468,8 @@ TkBTreeClientRangeChanged(textPtr, defaultHeight)
*/
void
-TkBTreeDestroy(tree)
- TkTextBTree tree; /* Tree to clean up */
+TkBTreeDestroy(
+ TkTextBTree tree) /* Tree to clean up. */
{
BTree *treePtr = (BTree *) tree;
@@ -496,8 +492,8 @@ TkBTreeDestroy(tree)
*
* TkBTreeEpoch --
*
- * Return the epoch for the B-tree. This number is incremented
- * any time anything changes in the tree.
+ * Return the epoch for the B-tree. This number is incremented any time
+ * anything changes in the tree.
*
* Results:
* The epoch number.
@@ -509,8 +505,8 @@ TkBTreeDestroy(tree)
*/
int
-TkBTreeEpoch(tree)
- TkTextBTree tree; /* Tree to get epoch for */
+TkBTreeEpoch(
+ TkTextBTree tree) /* Tree to get epoch for. */
{
BTree *treePtr = (BTree *) tree;
return treePtr->stateEpoch;
@@ -537,9 +533,9 @@ TkBTreeEpoch(tree)
*/
void
-TkBTreeRemoveClient(tree, textPtr)
- TkTextBTree tree; /* Tree to remove client from. */
- TkText *textPtr; /* Client to remove. */
+TkBTreeRemoveClient(
+ TkTextBTree tree, /* Tree to remove client from. */
+ TkText *textPtr) /* Client to remove. */
{
BTree *treePtr = (BTree *) tree;
int pixelReference = textPtr->pixelReference;
@@ -582,7 +578,7 @@ TkBTreeRemoveClient(tree, textPtr)
adjustPtr = treePtr->sharedTextPtr->peers;
while (adjustPtr != NULL) {
- if (adjustPtr->pixelReference == (treePtr->pixelReferences-1)) {
+ if (adjustPtr->pixelReference == treePtr->pixelReferences-1) {
adjustPtr->pixelReference = pixelReference;
break;
}
@@ -618,11 +614,11 @@ TkBTreeRemoveClient(tree, textPtr)
*/
static void
-AdjustStartEndRefs(treePtr, textPtr, action)
- BTree *treePtr; /* The entire B-tree */
- TkText *textPtr; /* The text widget for which we want to adjust
+AdjustStartEndRefs(
+ BTree *treePtr, /* The entire B-tree. */
+ TkText *textPtr, /* The text widget for which we want to adjust
* it's start and end cache. */
- int action; /* Action to perform */
+ int action) /* Action to perform. */
{
if (action & TEXT_REMOVE_REFS) {
int i = 0;
@@ -688,9 +684,9 @@ AdjustStartEndRefs(treePtr, textPtr, action)
* of a new peer widget based on this B-tree, or for the modification of
* the start, end lines of an existing peer widget.
*
- * Immediately _after_ calling this, treePtr->clients and
- * treePtr->pixelReferences should be adjusted if needed (i.e. if this is
- * a new peer).
+ * Immediately _after_ calling this, treePtr->pixelReferences and
+ * treePtr->clients should be adjusted if needed (i.e. if this is a new
+ * peer).
*
* Results:
* None.
@@ -702,19 +698,18 @@ AdjustStartEndRefs(treePtr, textPtr, action)
*/
static int
-AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end,
- useReference, newPixelReferences, counting)
- BTree *treePtr; /* Pointer to tree */
- int defaultHeight; /* Default pixel line height, which can be
+AdjustPixelClient(
+ BTree *treePtr, /* Pointer to tree. */
+ int defaultHeight, /* Default pixel line height, which can be
* zero. */
- Node *nodePtr; /* Adjust from this node downwards */
- TkTextLine *start; /* First line for this pixel client */
- TkTextLine *end; /* Last line for this pixel client */
- int useReference; /* pixel reference for the client we are
- * adding or changing */
- int newPixelReferences; /* New number of pixel references to this
- * B-tree */
- int *counting; /* References an integer which is zero if
+ Node *nodePtr, /* Adjust from this node downwards. */
+ TkTextLine *start, /* First line for this pixel client. */
+ TkTextLine *end, /* Last line for this pixel client. */
+ int useReference, /* pixel reference for the client we are
+ * adding or changing. */
+ int newPixelReferences, /* New number of pixel references to this
+ * B-tree. */
+ int *counting) /* References an integer which is zero if
* we're outside the relevant range for this
* client, and 1 if we're inside. */
{
@@ -730,6 +725,7 @@ AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end,
if (nodePtr->level != 0) {
Node *loopPtr = nodePtr->children.nodePtr;
+
while (loopPtr != NULL) {
pixelCount += AdjustPixelClient(treePtr, defaultHeight, loopPtr,
start, end, useReference, newPixelReferences, counting);
@@ -756,7 +752,7 @@ AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end,
*/
linePtr->pixels[2*useReference] = (*counting ? defaultHeight : 0);
- linePtr->pixels[1+2*useReference] = (*counting ? 0 : 1);
+ linePtr->pixels[2*useReference+1] = (*counting ? 0 : 1);
pixelCount += linePtr->pixels[2*useReference];
linePtr = linePtr->nextPtr;
@@ -791,18 +787,18 @@ AdjustPixelClient(treePtr, defaultHeight, nodePtr, start, end,
*/
static void
-RemovePixelClient(treePtr, nodePtr, overwriteWithLast)
- BTree *treePtr; /* Pointer to tree */
- Node *nodePtr; /* Adjust from this node downwards */
- int overwriteWithLast; /* Over-write this peer widget's information
+RemovePixelClient(
+ BTree *treePtr, /* Pointer to tree. */
+ Node *nodePtr, /* Adjust from this node downwards. */
+ int overwriteWithLast) /* Over-write this peer widget's information
* with the last one. */
{
/*
* Traverse entire tree down from nodePtr, reallocating pixel structures
- * for each Node and TkTextLine, removing space allocated for one peer.
- * If 'overwriteWithLast' is not -1, then copy the information which was
- * in the last slot on top of one of the others (i.e. it's not the last
- * one we're deleting).
+ * for each Node and TkTextLine, removing space allocated for one peer. If
+ * 'overwriteWithLast' is not -1, then copy the information which was in
+ * the last slot on top of one of the others (i.e. it's not the last one
+ * we're deleting).
*/
if (overwriteWithLast != -1) {
@@ -859,8 +855,8 @@ RemovePixelClient(treePtr, nodePtr, overwriteWithLast)
*/
static void
-DestroyNode(nodePtr)
- register Node *nodePtr; /* Destroy from this node downwards */
+DestroyNode(
+ register Node *nodePtr) /* Destroy from this node downwards. */
{
if (nodePtr->level == 0) {
TkTextLine *linePtr;
@@ -909,11 +905,12 @@ DestroyNode(nodePtr)
*/
static void
-DeleteSummaries(summaryPtr)
- register Summary *summaryPtr;
+DeleteSummaries(
+ register Summary *summaryPtr)
/* First in list of node's tag summaries. */
{
register Summary *nextPtr;
+
while (summaryPtr != NULL) {
nextPtr = summaryPtr->nextPtr;
ckfree((char *) summaryPtr);
@@ -939,23 +936,24 @@ DeleteSummaries(summaryPtr)
*/
int
-TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines)
- const TkText *textPtr; /* Client of the B-tree */
- register TkTextLine *linePtr;
+TkBTreeAdjustPixelHeight(
+ const TkText *textPtr, /* Client of the B-tree. */
+ register TkTextLine *linePtr,
/* The logical line to update. */
- int newPixelHeight; /* The line's known height in pixels. */
- int mergedLogicalLines; /* The number of extra logical lines which
+ int newPixelHeight, /* The line's known height in pixels. */
+ int mergedLogicalLines) /* The number of extra logical lines which
* have been merged with this one (due to
* elided eols). They will have their pixel
* height set to zero, and the total pixel
- * height associated with the given linePtr */
+ * height associated with the given
+ * linePtr. */
{
register Node *nodePtr;
int changeToPixelCount; /* Counts change to total number of pixels in
* file. */
int pixelReference = textPtr->pixelReference;
- changeToPixelCount = newPixelHeight - linePtr->pixels[2*pixelReference];
+ changeToPixelCount = newPixelHeight - linePtr->pixels[2 * pixelReference];
/*
* Increment the pixel counts in all the parent nodes of the current line,
@@ -970,7 +968,7 @@ TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines)
nodePtr->numPixels[pixelReference] += changeToPixelCount;
}
- linePtr->pixels[2*pixelReference] = newPixelHeight;
+ linePtr->pixels[2 * pixelReference] = newPixelHeight;
/*
* Any merged logical lines must have their height set to zero.
@@ -1007,14 +1005,14 @@ TkBTreeAdjustPixelHeight(textPtr, linePtr, newPixelHeight, mergedLogicalLines)
*/
void
-TkBTreeInsertChars(tree, indexPtr, string)
- TkTextBTree tree; /* Tree to insert into */
- register TkTextIndex *indexPtr;
+TkBTreeInsertChars(
+ TkTextBTree tree, /* Tree to insert into. */
+ register TkTextIndex *indexPtr,
/* Indicates where to insert text. When the
* function returns, this index is no longer
* valid because of changes to the segment
* structure. */
- const char *string; /* Pointer to bytes to insert (may contain
+ const char *string) /* Pointer to bytes to insert (may contain
* newlines, must be null-terminated). */
{
register Node *nodePtr;
@@ -1039,7 +1037,7 @@ TkBTreeInsertChars(tree, indexPtr, string)
int ref;
int pixels[PIXEL_CLIENTS];
- BTree *treePtr = (BTree*)tree;
+ BTree *treePtr = (BTree *) tree;
treePtr->stateEpoch++;
prevPtr = SplitSeg(indexPtr);
linePtr = indexPtr->linePtr;
@@ -1093,7 +1091,7 @@ TkBTreeInsertChars(tree, indexPtr, string)
newLinePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine));
newLinePtr->pixels = (int *)
- ckalloc(sizeof(int)*2*treePtr->pixelReferences);
+ ckalloc(sizeof(int) * 2 * treePtr->pixelReferences);
newLinePtr->parentPtr = linePtr->parentPtr;
newLinePtr->nextPtr = linePtr->nextPtr;
@@ -1101,14 +1099,14 @@ TkBTreeInsertChars(tree, indexPtr, string)
newLinePtr->segPtr = segPtr->nextPtr;
/*
- * Set up a starting default height, which will be re-adjusted
- * later. We need to do this for each referenced widget
+ * Set up a starting default height, which will be re-adjusted later.
+ * We need to do this for each referenced widget.
*/
for (ref = 0; ref < treePtr->pixelReferences; ref++) {
- newLinePtr->pixels[2*ref] = linePtr->pixels[2*ref];
- newLinePtr->pixels[1+2*ref] = 0;
- changeToPixelCount[ref] += newLinePtr->pixels[2*ref];
+ newLinePtr->pixels[2 * ref] = linePtr->pixels[2 * ref];
+ newLinePtr->pixels[2 * ref + 1] = 0;
+ changeToPixelCount[ref] += newLinePtr->pixels[2 * ref];
}
segPtr->nextPtr = NULL;
@@ -1152,7 +1150,7 @@ TkBTreeInsertChars(tree, indexPtr, string)
}
}
if (treePtr->pixelReferences > PIXEL_CLIENTS) {
- ckfree((char*)changeToPixelCount);
+ ckfree((char *) changeToPixelCount);
}
nodePtr = linePtr->parentPtr;
@@ -1193,14 +1191,14 @@ TkBTreeInsertChars(tree, indexPtr, string)
*/
static TkTextSegment *
-SplitSeg(indexPtr)
- TkTextIndex *indexPtr; /* Index identifying position at which to
+SplitSeg(
+ TkTextIndex *indexPtr) /* Index identifying position at which to
* split a segment. */
{
TkTextSegment *prevPtr, *segPtr;
TkTextLine *linePtr;
-
int count = indexPtr->byteIndex;
+
linePtr = indexPtr->linePtr;
prevPtr = NULL;
segPtr = linePtr->segPtr;
@@ -1228,12 +1226,14 @@ SplitSeg(indexPtr)
if (segPtr == NULL) {
/*
* Two logical lines merged into one display line through eliding
- * of a newline
+ * of a newline.
*/
linePtr = TkBTreeNextLine(NULL, linePtr);
if (linePtr == NULL) {
- /* Reached end of the text */
+ /*
+ * Reached end of the text.
+ */
}
segPtr = linePtr->segPtr;
}
@@ -1262,8 +1262,8 @@ SplitSeg(indexPtr)
*/
static void
-CleanupLine(linePtr)
- TkTextLine *linePtr; /* Line to be cleaned up. */
+CleanupLine(
+ TkTextLine *linePtr) /* Line to be cleaned up. */
{
TkTextSegment *segPtr, **prevPtrPtr;
int anyChanges;
@@ -1316,12 +1316,12 @@ CleanupLine(linePtr)
*/
void
-TkBTreeDeleteIndexRange(tree, index1Ptr, index2Ptr)
- TkTextBTree tree; /* Tree to delete from */
- register TkTextIndex *index1Ptr;
+TkBTreeDeleteIndexRange(
+ TkTextBTree tree, /* Tree to delete from. */
+ register TkTextIndex *index1Ptr,
/* Indicates first character that is to be
* deleted. */
- register TkTextIndex *index2Ptr;
+ register TkTextIndex *index2Ptr)
/* Indicates character just after the last one
* that is to be deleted. */
{
@@ -1334,7 +1334,8 @@ TkBTreeDeleteIndexRange(tree, index1Ptr, index2Ptr)
Node *curNodePtr, *nodePtr;
int changeToLineCount = 0;
int ref;
- BTree *treePtr = (BTree*)tree;
+ BTree *treePtr = (BTree *) tree;
+
treePtr->stateEpoch++;
/*
@@ -1345,7 +1346,7 @@ TkBTreeDeleteIndexRange(tree, index1Ptr, index2Ptr)
lastPtr = SplitSeg(index2Ptr);
if (lastPtr != NULL) {
lastPtr = lastPtr->nextPtr;
- } else {
+ } else {
lastPtr = index2Ptr->linePtr->segPtr;
}
prevPtr = SplitSeg(index1Ptr);
@@ -1426,8 +1427,8 @@ TkBTreeDeleteIndexRange(tree, index1Ptr, index2Ptr)
segPtr = curLinePtr->segPtr;
/*
- * If the node is empty then delete it and its parents,
- * recursively upwards until a non-empty node is found.
+ * If the node is empty then delete it and its parents recursively
+ * upwards until a non-empty node is found.
*/
while (curNodePtr->numChildren == 0) {
@@ -1591,10 +1592,10 @@ TkBTreeDeleteIndexRange(tree, index1Ptr, index2Ptr)
*/
TkTextLine *
-TkBTreeFindLine(tree, textPtr, line)
- TkTextBTree tree; /* B-tree in which to find line. */
- const TkText *textPtr; /* Relative to this client of the B-tree */
- int line; /* Index of desired line. */
+TkBTreeFindLine(
+ TkTextBTree tree, /* B-tree in which to find line. */
+ const TkText *textPtr, /* Relative to this client of the B-tree. */
+ int line) /* Index of desired line. */
{
BTree *treePtr = (BTree *) tree;
register Node *nodePtr;
@@ -1610,7 +1611,7 @@ TkBTreeFindLine(tree, textPtr, line)
}
/*
- * Check for the any start/end offset for this text widget
+ * Check for the any start/end offset for this text widget.
*/
if (textPtr != NULL) {
@@ -1680,11 +1681,11 @@ TkBTreeFindLine(tree, textPtr, line)
*/
TkTextLine *
-TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset)
- TkTextBTree tree; /* B-tree to use. */
- const TkText *textPtr; /* Relative to this client of the B-tree */
- int pixels; /* Pixel index of desired line. */
- int *pixelOffset; /* Used to return offset */
+TkBTreeFindPixelLine(
+ TkTextBTree tree, /* B-tree to use. */
+ const TkText *textPtr, /* Relative to this client of the B-tree. */
+ int pixels, /* Pixel index of desired line. */
+ int *pixelOffset) /* Used to return offset. */
{
BTree *treePtr = (BTree *) tree;
register Node *nodePtr;
@@ -1721,12 +1722,12 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset)
*/
for (linePtr = nodePtr->children.linePtr;
- linePtr->pixels[2*pixelReference] < pixels;
+ linePtr->pixels[2 * pixelReference] < pixels;
linePtr = linePtr->nextPtr) {
if (linePtr == NULL) {
Tcl_Panic("TkBTreeFindPixelLine ran out of lines");
}
- pixels -= linePtr->pixels[2*pixelReference];
+ pixels -= linePtr->pixels[2 * pixelReference];
}
if (pixelOffset != NULL && linePtr != NULL) {
*pixelOffset = pixels;
@@ -1754,9 +1755,9 @@ TkBTreeFindPixelLine(tree, textPtr, pixels, pixelOffset)
*/
TkTextLine *
-TkBTreeNextLine(textPtr, linePtr)
- const TkText *textPtr; /* Next line in the context of this client */
- register TkTextLine *linePtr;
+TkBTreeNextLine(
+ const TkText *textPtr, /* Next line in the context of this client. */
+ register TkTextLine *linePtr)
/* Pointer to existing line in B-tree. */
{
register Node *nodePtr;
@@ -1810,9 +1811,9 @@ TkBTreeNextLine(textPtr, linePtr)
*/
TkTextLine *
-TkBTreePreviousLine(textPtr, linePtr)
- TkText *textPtr; /* Relative to this client of the B-tree */
- register TkTextLine *linePtr;
+TkBTreePreviousLine(
+ TkText *textPtr /* Relative to this client of the B-tree. */
+ register TkTextLine *linePtr)
/* Pointer to existing line in B-tree. */
{
register Node *nodePtr;
@@ -1827,7 +1828,7 @@ TkBTreePreviousLine(textPtr, linePtr)
* Find the line under this node just before the starting line.
*/
- prevPtr = linePtr->parentPtr->children.linePtr; /* First line at leaf */
+ prevPtr = linePtr->parentPtr->children.linePtr; /* First line at leaf. */
while (prevPtr != linePtr) {
if (prevPtr->nextPtr == linePtr) {
return prevPtr;
@@ -1893,9 +1894,9 @@ TkBTreePreviousLine(textPtr, linePtr)
*/
int
-TkBTreePixelsTo(textPtr, linePtr)
- const TkText *textPtr; /* Relative to this client of the B-tree */
- TkTextLine *linePtr; /* Pointer to existing line in B-tree. */
+TkBTreePixelsTo(
+ const TkText *textPtr, /* Relative to this client of the B-tree. */
+ TkTextLine *linePtr) /* Pointer to existing line in B-tree. */
{
register TkTextLine *linePtr2;
register Node *nodePtr, *parentPtr;
@@ -1913,7 +1914,7 @@ TkBTreePixelsTo(textPtr, linePtr)
if (linePtr2 == NULL) {
Tcl_Panic("TkBTreePixelsTo couldn't find line");
}
- index += linePtr2->pixels[2*pixelReference];
+ index += linePtr2->pixels[2 * pixelReference];
}
/*
@@ -1924,6 +1925,7 @@ TkBTreePixelsTo(textPtr, linePtr)
for (parentPtr = nodePtr->parentPtr ; parentPtr != NULL;
nodePtr = parentPtr, parentPtr = parentPtr->parentPtr) {
register Node *nodePtr2;
+
for (nodePtr2 = parentPtr->children.nodePtr; nodePtr2 != nodePtr;
nodePtr2 = nodePtr2->nextPtr) {
if (nodePtr2 == NULL) {
@@ -1954,9 +1956,9 @@ TkBTreePixelsTo(textPtr, linePtr)
*/
int
-TkBTreeLinesTo(textPtr, linePtr)
- const TkText *textPtr; /* Relative to this client of the B-tree */
- TkTextLine *linePtr; /* Pointer to existing line in B-tree. */
+TkBTreeLinesTo(
+ const TkText *textPtr, /* Relative to this client of the B-tree. */
+ TkTextLine *linePtr) /* Pointer to existing line in B-tree. */
{
register TkTextLine *linePtr2;
register Node *nodePtr, *parentPtr, *nodePtr2;
@@ -2015,11 +2017,11 @@ TkBTreeLinesTo(textPtr, linePtr)
/* ARGSUSED */
void
-TkBTreeLinkSegment(segPtr, indexPtr)
- TkTextSegment *segPtr; /* Pointer to new segment to be added to
+TkBTreeLinkSegment(
+ TkTextSegment *segPtr, /* Pointer to new segment to be added to
* B-tree. Should be completely initialized by
* caller except for nextPtr field. */
- TkTextIndex *indexPtr; /* Where to add segment: it gets linked in
+ TkTextIndex *indexPtr) /* Where to add segment: it gets linked in
* just before the segment indicated here. */
{
register TkTextSegment *prevPtr;
@@ -2036,7 +2038,7 @@ TkBTreeLinkSegment(segPtr, indexPtr)
if (tkBTreeDebug) {
TkBTreeCheck(indexPtr->tree);
}
- ((BTree*)indexPtr->tree)->stateEpoch++;
+ ((BTree *)indexPtr->tree)->stateEpoch++;
}
/*
@@ -2058,9 +2060,9 @@ TkBTreeLinkSegment(segPtr, indexPtr)
/* ARGSUSED */
void
-TkBTreeUnlinkSegment(segPtr, linePtr)
- TkTextSegment *segPtr; /* Segment to be unlinked. */
- TkTextLine *linePtr; /* Line that currently contains segment. */
+TkBTreeUnlinkSegment(
+ TkTextSegment *segPtr, /* Segment to be unlinked. */
+ TkTextLine *linePtr) /* Line that currently contains segment. */
{
register TkTextSegment *prevPtr;
@@ -2074,7 +2076,7 @@ TkBTreeUnlinkSegment(segPtr, linePtr)
if (prevPtr == NULL) {
/*
* Two logical lines merged into one display line through
- * eliding of a newline
+ * eliding of a newline.
*/
linePtr = TkBTreeNextLine(NULL, linePtr);
@@ -2110,23 +2112,21 @@ TkBTreeUnlinkSegment(segPtr, linePtr)
*/
int
-TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add)
- register TkTextIndex *index1Ptr;
+TkBTreeTag(
+ register TkTextIndex *index1Ptr,
/* Indicates first character in range. */
- register TkTextIndex *index2Ptr;
+ register TkTextIndex *index2Ptr,
/* Indicates character just after the last one
* in range. */
- TkTextTag *tagPtr; /* Tag to add or remove. */
- int add; /* One means add tag to the given range of
+ TkTextTag *tagPtr, /* Tag to add or remove. */
+ int add) /* One means add tag to the given range of
* characters; zero means remove the tag from
* the range. */
{
TkTextSegment *segPtr, *prevPtr;
TkTextSearch search;
TkTextLine *cleanupLinePtr;
- int oldState;
- int changed;
- int anyChanges = 0;
+ int oldState, changed, anyChanges = 0;
/*
* See whether the tag is present at the start of the range. If the state
@@ -2232,7 +2232,7 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add)
if (cleanupLinePtr != index2Ptr->linePtr) {
CleanupLine(index2Ptr->linePtr);
}
- ((BTree*)index1Ptr->tree)->stateEpoch++;
+ ((BTree *)index1Ptr->tree)->stateEpoch++;
}
if (tkBTreeDebug) {
@@ -2262,16 +2262,16 @@ TkBTreeTag(index1Ptr, index2Ptr, tagPtr, add)
*/
static void
-ChangeNodeToggleCount(nodePtr, tagPtr, delta)
- register Node *nodePtr; /* Node whose toggle count for a tag must be
+ChangeNodeToggleCount(
+ register Node *nodePtr, /* Node whose toggle count for a tag must be
* changed. */
- TkTextTag *tagPtr; /* Information about tag. */
- int delta; /* Amount to add to current toggle count for
+ TkTextTag *tagPtr, /* Information about tag. */
+ int delta) /* Amount to add to current toggle count for
* tag (may be negative). */
{
register Summary *summaryPtr, *prevPtr;
register Node *node2Ptr;
- int rootLevel; /* Level of original tag root */
+ int rootLevel; /* Level of original tag root. */
tagPtr->toggleCount += delta;
if (tagPtr->tagRootPtr == NULL) {
@@ -2323,7 +2323,7 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta)
}
/*
- * Zero toggle count; must remove this tag from the list.
+ * Zero toggle count; must remove this tag from the list.
*/
if (prevPtr == NULL) {
@@ -2338,7 +2338,6 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta)
*/
if (rootLevel == nodePtr->level) {
-
/*
* The old tag root is at the same level in the tree as this
* node, but it isn't at this node. Move the tag root up a
@@ -2350,6 +2349,7 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta)
*/
Node *rootNodePtr = tagPtr->tagRootPtr;
+
summaryPtr = (Summary *) ckalloc(sizeof(Summary));
summaryPtr->tagPtr = tagPtr;
summaryPtr->toggleCount = tagPtr->toggleCount - delta;
@@ -2444,10 +2444,10 @@ ChangeNodeToggleCount(nodePtr, tagPtr, delta)
*/
static TkTextSegment *
-FindTagStart(tree, tagPtr, indexPtr)
- TkTextBTree tree; /* Tree to search within */
- TkTextTag *tagPtr; /* Tag to search for. */
- TkTextIndex *indexPtr; /* Return - index information */
+FindTagStart(
+ TkTextBTree tree, /* Tree to search within. */
+ TkTextTag *tagPtr, /* Tag to search for. */
+ TkTextIndex *indexPtr) /* Return - index information. */
{
register Node *nodePtr;
register TkTextLine *linePtr;
@@ -2525,10 +2525,10 @@ FindTagStart(tree, tagPtr, indexPtr)
*/
static TkTextSegment *
-FindTagEnd(tree, tagPtr, indexPtr)
- TkTextBTree tree; /* Tree to search within */
- TkTextTag *tagPtr; /* Tag to search for. */
- TkTextIndex *indexPtr; /* Return - index information */
+FindTagEnd(
+ TkTextBTree tree, /* Tree to search within. */
+ TkTextTag *tagPtr, /* Tag to search for. */
+ TkTextIndex *indexPtr) /* Return - index information. */
{
register Node *nodePtr, *lastNodePtr;
register TkTextLine *linePtr ,*lastLinePtr;
@@ -2615,20 +2615,20 @@ FindTagEnd(tree, tagPtr, indexPtr)
*/
void
-TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr)
- TkTextIndex *index1Ptr; /* Search starts here. Tag toggles at this
+TkBTreeStartSearch(
+ TkTextIndex *index1Ptr, /* Search starts here. Tag toggles at this
* position will not be returned. */
- TkTextIndex *index2Ptr; /* Search stops here. Tag toggles at this
+ TkTextIndex *index2Ptr, /* Search stops here. Tag toggles at this
* position *will* be returned. */
- TkTextTag *tagPtr; /* Tag to search for. NULL means search for
+ TkTextTag *tagPtr, /* Tag to search for. NULL means search for
* any tag. */
- register TkTextSearch *searchPtr;
+ register TkTextSearch *searchPtr)
/* Where to store information about search's
* progress. */
{
int offset;
- TkTextIndex index0; /* First index of the tag */
- TkTextSegment *seg0Ptr; /* First segment of the tag */
+ TkTextIndex index0; /* First index of the tag. */
+ TkTextSegment *seg0Ptr; /* First segment of the tag. */
/*
* Find the segment that contains the first toggle for the tag. This may
@@ -2650,12 +2650,12 @@ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr)
}
if (TkTextIndexCmp(index1Ptr, &index0) < 0) {
/*
- * Adjust start of search up to the first range of the tag
+ * Adjust start of search up to the first range of the tag.
*/
searchPtr->curIndex = index0;
searchPtr->segPtr = NULL;
- searchPtr->nextPtr = seg0Ptr; /* Will be returned by NextTag */
+ searchPtr->nextPtr = seg0Ptr; /* Will be returned by NextTag. */
index1Ptr = &index0;
} else {
searchPtr->curIndex = *index1Ptr;
@@ -2711,21 +2711,21 @@ TkBTreeStartSearch(index1Ptr, index2Ptr, tagPtr, searchPtr)
*/
void
-TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
- TkTextIndex *index1Ptr; /* Search starts here. Tag toggles at this
+TkBTreeStartSearchBack(
+ TkTextIndex *index1Ptr, /* Search starts here. Tag toggles at this
* position will not be returned. */
- TkTextIndex *index2Ptr; /* Search stops here. Tag toggles at this
+ TkTextIndex *index2Ptr, /* Search stops here. Tag toggles at this
* position *will* be returned. */
- TkTextTag *tagPtr; /* Tag to search for. NULL means search for
+ TkTextTag *tagPtr, /* Tag to search for. NULL means search for
* any tag. */
- register TkTextSearch *searchPtr;
- /* Where to store information about
- * search's progress. */
+ register TkTextSearch *searchPtr)
+ /* Where to store information about search's
+ * progress. */
{
int offset;
- TkTextIndex index0; /* Last index of the tag */
- TkTextIndex backOne; /* One character before starting index */
- TkTextSegment *seg0Ptr; /* Last segment of the tag */
+ TkTextIndex index0; /* Last index of the tag. */
+ TkTextIndex backOne; /* One character before starting index. */
+ TkTextSegment *seg0Ptr; /* Last segment of the tag. */
/*
* Find the segment that contains the last toggle for the tag. This may
@@ -2770,7 +2770,7 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
if ((TkBTreeLinesTo(NULL, index2Ptr->linePtr) == 0) &&
(index2Ptr->byteIndex == 0)) {
backOne = *index2Ptr;
- searchPtr->lastPtr = NULL; /* Signals special case for 1.0 */
+ searchPtr->lastPtr = NULL; /* Signals special case for 1.0. */
} else {
TkTextIndexBackChars(NULL, index2Ptr, 1, &backOne, COUNT_INDICES);
searchPtr->lastPtr = TkTextIndexToSeg(&backOne, NULL);
@@ -2818,8 +2818,8 @@ TkBTreeStartSearchBack(index1Ptr, index2Ptr, tagPtr, searchPtr)
*/
int
-TkBTreeNextTag(searchPtr)
- register TkTextSearch *searchPtr;
+TkBTreeNextTag(
+ register TkTextSearch *searchPtr)
/* Information about search in progress; must
* have been set up by call to
* TkBTreeStartSearch. */
@@ -2983,8 +2983,8 @@ TkBTreeNextTag(searchPtr)
*/
int
-TkBTreePrevTag(searchPtr)
- register TkTextSearch *searchPtr;
+TkBTreePrevTag(
+ register TkTextSearch *searchPtr)
/* Information about search in progress; must
* have been set up by call to
* TkBTreeStartSearch. */
@@ -2993,9 +2993,8 @@ TkBTreePrevTag(searchPtr)
register TkTextLine *linePtr, *prevLinePtr;
register Node *nodePtr, *node2Ptr, *prevNodePtr;
register Summary *summaryPtr;
- int byteIndex;
- int pastLast; /* Saw last marker during scan */
- int linesSkipped;
+ int byteIndex, linesSkipped;
+ int pastLast; /* Saw last marker during scan. */
if (searchPtr->linesLeft <= 0) {
goto searchOver;
@@ -3035,7 +3034,8 @@ TkBTreePrevTag(searchPtr)
searchPtr->curIndex.byteIndex = byteIndex;
}
if (segPtr == searchPtr->lastPtr) {
- prevPtr = NULL; /* Segments earlier than last don't count */
+ prevPtr = NULL; /* Segments earlier than last don't
+ * count. */
pastLast = 1;
}
byteIndex += segPtr->size;
@@ -3197,10 +3197,10 @@ TkBTreePrevTag(searchPtr)
*/
int
-TkBTreeCharTagged(indexPtr, tagPtr)
- const TkTextIndex *indexPtr;/* Indicates a character position at which to
+TkBTreeCharTagged(
+ const TkTextIndex *indexPtr,/* Indicates a character position at which to
* check for a tag. */
- TkTextTag *tagPtr; /* Tag of interest. */
+ TkTextTag *tagPtr) /* Tag of interest. */
{
register Node *nodePtr;
register TkTextLine *siblingLinePtr;
@@ -3308,13 +3308,13 @@ TkBTreeCharTagged(indexPtr, tagPtr)
/* ARGSUSED */
TkTextTag **
-TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
- const TkTextIndex *indexPtr;/* Indicates a particular position in the
+TkBTreeGetTags(
+ const TkTextIndex *indexPtr,/* Indicates a particular position in the
* B-tree. */
- const TkText *textPtr; /* If non-NULL, then only return tags for this
+ const TkText *textPtr, /* If non-NULL, then only return tags for this
* text widget (when there are peer
* widgets). */
- int *numTagsPtr; /* Store number of tags found at this
+ int *numTagsPtr) /* Store number of tags found at this
* location. */
{
register Node *nodePtr;
@@ -3327,10 +3327,10 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
tagInfo.numTags = 0;
tagInfo.arraySize = NUM_TAG_INFOS;
- tagInfo.tagPtrs = (TkTextTag **) ckalloc((unsigned)
- NUM_TAG_INFOS*sizeof(TkTextTag *));
- tagInfo.counts = (int *) ckalloc((unsigned)
- NUM_TAG_INFOS*sizeof(int));
+ tagInfo.tagPtrs = (TkTextTag **)
+ ckalloc((unsigned) NUM_TAG_INFOS * sizeof(TkTextTag *));
+ tagInfo.counts = (int *)
+ ckalloc((unsigned) NUM_TAG_INFOS * sizeof(int));
/*
* Record tag toggles within the line of indexPtr but preceding indexPtr.
@@ -3407,7 +3407,8 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
for (src = 0, dst = 0; src < tagInfo.numTags; src++) {
if (tagInfo.counts[src] & 1) {
const TkText *tagTextPtr = tagInfo.tagPtrs[src]->textPtr;
- if (tagTextPtr == NULL || textPtr == NULL || tagTextPtr == textPtr) {
+
+ if (tagTextPtr==NULL || textPtr==NULL || tagTextPtr==textPtr) {
tagInfo.tagPtrs[dst] = tagInfo.tagPtrs[src];
dst++;
}
@@ -3455,11 +3456,11 @@ TkBTreeGetTags(indexPtr, textPtr, numTagsPtr)
/* ARGSUSED */
int
-TkTextIsElided(textPtr, indexPtr, elideInfo)
- const TkText *textPtr; /* Overall information about text widget. */
- const TkTextIndex *indexPtr;/* The character in the text for which display
+TkTextIsElided(
+ const TkText *textPtr, /* Overall information about text widget. */
+ const TkTextIndex *indexPtr,/* The character in the text for which display
* information is wanted. */
- TkTextElideInfo *elideInfo; /* NULL or a pointer to a structure in which
+ TkTextElideInfo *elideInfo) /* NULL or a pointer to a structure in which
* indexPtr's elide state will be stored and
* returned. */
{
@@ -3473,12 +3474,13 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
int elide;
if (elideInfo == NULL) {
- infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo));
+ infoPtr = (TkTextElideInfo *)
+ ckalloc((unsigned) sizeof(TkTextElideInfo));
} else {
infoPtr = elideInfo;
}
- infoPtr->elide = 0; /* if nobody says otherwise, it's visible */
+ infoPtr->elide = 0; /* If nobody says otherwise, it's visible. */
infoPtr->tagCnts = infoPtr->deftagCnts;
infoPtr->tagPtrs = infoPtr->deftagPtrs;
infoPtr->numTags = textPtr->sharedTextPtr->numTags;
@@ -3491,7 +3493,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
infoPtr->tagCnts = (int *)
ckalloc((unsigned) sizeof(int) * infoPtr->numTags);
infoPtr->tagPtrs = (TkTextTag **)
- ckalloc((unsigned)sizeof(TkTextTag *) * infoPtr->numTags);
+ ckalloc((unsigned) sizeof(TkTextTag *) * infoPtr->numTags);
}
for (i=0; i<infoPtr->numTags; i++) {
@@ -3585,7 +3587,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
/*
* Now traverse from highest priority to lowest, take elided value from
- * first odd count (= on)
+ * first odd count (= on).
*/
infoPtr->elidePriority = -1;
@@ -3624,7 +3626,7 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
ckfree((char *) infoPtr->tagPtrs);
}
- ckfree((char*) infoPtr);
+ ckfree((char *) infoPtr);
}
return elide;
@@ -3648,13 +3650,13 @@ TkTextIsElided(textPtr, indexPtr, elideInfo)
*/
void
-TkTextFreeElideInfo(elideInfo)
- TkTextElideInfo *elideInfo; /* Free any allocated memory in this
+TkTextFreeElideInfo(
+ TkTextElideInfo *elideInfo) /* Free any allocated memory in this
* structure. */
{
if (LOTSA_TAGS < elideInfo->numTags) {
- ckfree((char*)elideInfo->tagCnts);
- ckfree((char*)elideInfo->tagPtrs);
+ ckfree((char *) elideInfo->tagCnts);
+ ckfree((char *) elideInfo->tagPtrs);
}
}
@@ -3678,10 +3680,10 @@ TkTextFreeElideInfo(elideInfo)
*/
static void
-IncCount(tagPtr, inc, tagInfoPtr)
- TkTextTag *tagPtr; /* Handle for tag. */
- int inc; /* Amount by which to increment tag count. */
- TagInfo *tagInfoPtr; /* Holds cumulative information about tags;
+IncCount(
+ TkTextTag *tagPtr, /* Handle for tag. */
+ int inc, /* Amount by which to increment tag count. */
+ TagInfo *tagInfoPtr) /* Holds cumulative information about tags;
* increment count here. */
{
register TkTextTag **tagPtrPtr;
@@ -3704,15 +3706,15 @@ IncCount(tagPtr, inc, tagInfoPtr)
TkTextTag **newTags;
int *newCounts, newSize;
- newSize = 2*tagInfoPtr->arraySize;
- newTags = (TkTextTag **) ckalloc((unsigned)
- (newSize * sizeof(TkTextTag *)));
- memcpy((VOID *) newTags, (VOID *) tagInfoPtr->tagPtrs,
+ newSize = 2 * tagInfoPtr->arraySize;
+ newTags = (TkTextTag **)
+ ckalloc((unsigned) newSize * sizeof(TkTextTag *));
+ memcpy(newTags, tagInfoPtr->tagPtrs,
tagInfoPtr->arraySize * sizeof(TkTextTag *));
ckfree((char *) tagInfoPtr->tagPtrs);
tagInfoPtr->tagPtrs = newTags;
- newCounts = (int *) ckalloc((unsigned) (newSize*sizeof(int)));
- memcpy((VOID *) newCounts, (VOID *) tagInfoPtr->counts,
+ newCounts = (int *) ckalloc((unsigned) newSize * sizeof(int));
+ memcpy(newCounts, tagInfoPtr->counts,
tagInfoPtr->arraySize * sizeof(int));
ckfree((char *) tagInfoPtr->counts);
tagInfoPtr->counts = newCounts;
@@ -3743,8 +3745,8 @@ IncCount(tagPtr, inc, tagInfoPtr)
*/
void
-TkBTreeCheck(tree)
- TkTextBTree tree; /* Tree to check. */
+TkBTreeCheck(
+ TkTextBTree tree) /* Tree to check. */
{
BTree *treePtr = (BTree *) tree;
register Summary *summaryPtr;
@@ -3769,7 +3771,7 @@ TkBTreeCheck(tree)
Tcl_Panic("TkBTreeCheck found \"%s\" with toggles (%d) but no root",
tagPtr->name, tagPtr->toggleCount);
}
- continue; /* no ranges for the tag */
+ continue; /* No ranges for the tag. */
} else if (tagPtr->toggleCount == 0) {
Tcl_Panic("TkBTreeCheck found root for \"%s\" with no toggles",
tagPtr->name);
@@ -3885,9 +3887,9 @@ TkBTreeCheck(tree)
*/
static void
-CheckNodeConsistency(nodePtr, references)
- register Node *nodePtr; /* Node whose subtree should be checked. */
- int references; /* Number of referring widgets which have
+CheckNodeConsistency(
+ register Node *nodePtr, /* Node whose subtree should be checked. */
+ int references) /* Number of referring widgets which have
* pixel counts. */
{
register Node *childNodePtr;
@@ -3902,7 +3904,7 @@ CheckNodeConsistency(nodePtr, references)
minChildren = MIN_CHILDREN;
} else if (nodePtr->level > 0) {
minChildren = 2;
- } else {
+ } else {
minChildren = 1;
}
if ((nodePtr->numChildren < minChildren)
@@ -3914,7 +3916,7 @@ CheckNodeConsistency(nodePtr, references)
numChildren = 0;
numLines = 0;
if (references > PIXEL_CLIENTS) {
- numPixels = (int*)ckalloc(sizeof(int)*references);
+ numPixels = (int *) ckalloc(sizeof(int) * references);
} else {
numPixels = pixels;
}
@@ -3950,7 +3952,7 @@ CheckNodeConsistency(nodePtr, references)
numChildren++;
numLines++;
for (i = 0; i<references; i++) {
- numPixels[i] += linePtr->pixels[2*i];
+ numPixels[i] += linePtr->pixels[2 * i];
}
}
} else {
@@ -3999,18 +4001,18 @@ CheckNodeConsistency(nodePtr, references)
for (i = 0; i<references; i++) {
if (numPixels[i] != nodePtr->numPixels[i]) {
Tcl_Panic("CheckNodeConsistency: mismatch in numPixels (%d %d) for widget (%d)",
- numPixels[i], nodePtr->numPixels[i], i);
+ numPixels[i], nodePtr->numPixels[i], i);
}
}
if (references > PIXEL_CLIENTS) {
- ckfree((char*)numPixels);
+ ckfree((char *) numPixels);
}
for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL;
summaryPtr = summaryPtr->nextPtr) {
if (summaryPtr->tagPtr->toggleCount == summaryPtr->toggleCount) {
Tcl_Panic("CheckNodeConsistency: found unpruned root for \"%s\"",
- summaryPtr->tagPtr->name);
+ summaryPtr->tagPtr->name);
}
toggleCount = 0;
if (nodePtr->level == 0) {
@@ -4023,7 +4025,7 @@ CheckNodeConsistency(nodePtr, references)
continue;
}
if (segPtr->body.toggle.tagPtr == summaryPtr->tagPtr) {
- toggleCount ++;
+ toggleCount++;
}
}
}
@@ -4073,9 +4075,9 @@ CheckNodeConsistency(nodePtr, references)
*/
static void
-Rebalance(treePtr, nodePtr)
- BTree *treePtr; /* Tree that is being rebalanced. */
- register Node *nodePtr; /* Node that may be out of balance. */
+Rebalance(
+ BTree *treePtr, /* Tree that is being rebalanced. */
+ register Node *nodePtr) /* Node that may be out of balance. */
{
/*
* Loop over the entire ancestral chain of the node, working up through
@@ -4270,8 +4272,8 @@ Rebalance(treePtr, nodePtr)
}
/*
- * The siblings can't be merged, so just divide their
- * children evenly between them.
+ * The siblings can't be merged, so just divide their children
+ * evenly between them.
*/
if (nodePtr->level == 0) {
@@ -4309,9 +4311,9 @@ Rebalance(treePtr, nodePtr)
*/
static void
-RecomputeNodeCounts(treePtr, nodePtr)
- register BTree *treePtr; /* The whole B-tree */
- register Node *nodePtr; /* Node whose tag summary information must be
+RecomputeNodeCounts(
+ register BTree *treePtr, /* The whole B-tree. */
+ register Node *nodePtr) /* Node whose tag summary information must be
* recomputed. */
{
register Summary *summaryPtr, *summaryPtr2;
@@ -4347,7 +4349,7 @@ RecomputeNodeCounts(treePtr, nodePtr)
nodePtr->numChildren++;
nodePtr->numLines++;
for (ref = 0; ref<treePtr->pixelReferences; ref++) {
- nodePtr->numPixels[ref] += linePtr->pixels[2*ref];
+ nodePtr->numPixels[ref] += linePtr->pixels[2 * ref];
}
linePtr->parentPtr = nodePtr;
for (segPtr = linePtr->segPtr; segPtr != NULL;
@@ -4430,8 +4432,8 @@ RecomputeNodeCounts(treePtr, nodePtr)
}
if (summaryPtr->toggleCount == summaryPtr->tagPtr->toggleCount) {
/*
- * A node merge has collected all the toggles under one node.
- * Push the root down to this level.
+ * A node merge has collected all the toggles under one node. Push
+ * the root down to this level.
*/
summaryPtr->tagPtr->tagRootPtr = nodePtr;
@@ -4468,9 +4470,9 @@ RecomputeNodeCounts(treePtr, nodePtr)
*/
int
-TkBTreeNumLines(tree, textPtr)
- TkTextBTree tree; /* Information about tree. */
- const TkText *textPtr; /* Relative to this client of the B-tree */
+TkBTreeNumLines(
+ TkTextBTree tree, /* Information about tree. */
+ const TkText *textPtr) /* Relative to this client of the B-tree. */
{
BTree *treePtr = (BTree *) tree;
int count;
@@ -4509,9 +4511,9 @@ TkBTreeNumLines(tree, textPtr)
*/
int
-TkBTreeNumPixels(tree, textPtr)
- TkTextBTree tree; /* The B-tree */
- const TkText *textPtr; /* Relative to this client of the B-tree */
+TkBTreeNumPixels(
+ TkTextBTree tree, /* The B-tree. */
+ const TkText *textPtr) /* Relative to this client of the B-tree. */
{
BTree *treePtr = (BTree *) tree;
return treePtr->rootPtr->numPixels[textPtr->pixelReference];
@@ -4535,9 +4537,9 @@ TkBTreeNumPixels(tree, textPtr)
*/
static TkTextSegment *
-CharSplitProc(segPtr, index)
- TkTextSegment *segPtr; /* Pointer to segment to split. */
- int index; /* Position within segment at which to
+CharSplitProc(
+ TkTextSegment *segPtr, /* Pointer to segment to split. */
+ int index) /* Position within segment at which to
* split. */
{
TkTextSegment *newPtr1, *newPtr2;
@@ -4554,7 +4556,7 @@ CharSplitProc(segPtr, index)
newPtr2->nextPtr = segPtr->nextPtr;
newPtr2->size = segPtr->size - index;
strcpy(newPtr2->body.chars, segPtr->body.chars + index);
- ckfree((char*) segPtr);
+ ckfree((char *) segPtr);
return newPtr1;
}
@@ -4578,10 +4580,10 @@ CharSplitProc(segPtr, index)
/* ARGSUSED */
static TkTextSegment *
-CharCleanupProc(segPtr, linePtr)
- TkTextSegment *segPtr; /* Pointer to first of two adjacent segments
+CharCleanupProc(
+ TkTextSegment *segPtr, /* Pointer to first of two adjacent segments
* to join. */
- TkTextLine *linePtr; /* Line containing segments (not used). */
+ TkTextLine *linePtr) /* Line containing segments (not used). */
{
TkTextSegment *segPtr2, *newPtr;
@@ -4596,8 +4598,8 @@ CharCleanupProc(segPtr, linePtr)
newPtr->size = segPtr->size + segPtr2->size;
strcpy(newPtr->body.chars, segPtr->body.chars);
strcpy(newPtr->body.chars + segPtr->size, segPtr2->body.chars);
- ckfree((char*) segPtr);
- ckfree((char*) segPtr2);
+ ckfree((char *) segPtr);
+ ckfree((char *) segPtr2);
return newPtr;
}
@@ -4619,14 +4621,14 @@ CharCleanupProc(segPtr, linePtr)
/* ARGSUSED */
static int
-CharDeleteProc(segPtr, linePtr, treeGone)
- TkTextSegment *segPtr; /* Segment to delete. */
- TkTextLine *linePtr; /* Line containing segment. */
- int treeGone; /* Non-zero means the entire tree is being
+CharDeleteProc(
+ TkTextSegment *segPtr, /* Segment to delete. */
+ TkTextLine *linePtr, /* Line containing segment. */
+ int treeGone) /* Non-zero means the entire tree is being
* deleted, so everything must get cleaned
* up. */
{
- ckfree((char*) segPtr);
+ ckfree((char *) segPtr);
return 0;
}
@@ -4649,9 +4651,9 @@ CharDeleteProc(segPtr, linePtr, treeGone)
/* ARGSUSED */
static void
-CharCheckProc(segPtr, linePtr)
- TkTextSegment *segPtr; /* Segment to check. */
- TkTextLine *linePtr; /* Line containing segment. */
+CharCheckProc(
+ TkTextSegment *segPtr, /* Segment to check. */
+ TkTextLine *linePtr) /* Line containing segment. */
{
/*
* Make sure that the segment contains the number of characters indicated
@@ -4694,10 +4696,10 @@ CharCheckProc(segPtr, linePtr)
*/
static int
-ToggleDeleteProc(segPtr, linePtr, treeGone)
- TkTextSegment *segPtr; /* Segment to check. */
- TkTextLine *linePtr; /* Line containing segment. */
- int treeGone; /* Non-zero means the entire tree is being
+ToggleDeleteProc(
+ TkTextSegment *segPtr, /* Segment to check. */
+ TkTextLine *linePtr, /* Line containing segment. */
+ int treeGone) /* Non-zero means the entire tree is being
* deleted, so everything must get cleaned
* up. */
{
@@ -4745,9 +4747,9 @@ ToggleDeleteProc(segPtr, linePtr, treeGone)
*/
static TkTextSegment *
-ToggleCleanupProc(segPtr, linePtr)
- TkTextSegment *segPtr; /* Segment to check. */
- TkTextLine *linePtr; /* Line that now contains segment. */
+ToggleCleanupProc(
+ TkTextSegment *segPtr, /* Segment to check. */
+ TkTextLine *linePtr) /* Line that now contains segment. */
{
TkTextSegment *segPtr2, *prevPtr;
int counts;
@@ -4809,9 +4811,9 @@ ToggleCleanupProc(segPtr, linePtr)
*/
static void
-ToggleLineChangeProc(segPtr, linePtr)
- TkTextSegment *segPtr; /* Segment to check. */
- TkTextLine *linePtr; /* Line that used to contain segment. */
+ToggleLineChangeProc(
+ TkTextSegment *segPtr, /* Segment to check. */
+ TkTextLine *linePtr) /* Line that used to contain segment. */
{
if (segPtr->body.toggle.inNodeCounts) {
ChangeNodeToggleCount(linePtr->parentPtr,
@@ -4838,9 +4840,9 @@ ToggleLineChangeProc(segPtr, linePtr)
*/
static void
-ToggleCheckProc(segPtr, linePtr)
- TkTextSegment *segPtr; /* Segment to check. */
- TkTextLine *linePtr; /* Line containing segment. */
+ToggleCheckProc(
+ TkTextSegment *segPtr, /* Segment to check. */
+ TkTextLine *linePtr) /* Line containing segment. */
{
register Summary *summaryPtr;
int needSummary;
@@ -4851,7 +4853,7 @@ ToggleCheckProc(segPtr, linePtr)
if (!segPtr->body.toggle.inNodeCounts) {
Tcl_Panic("ToggleCheckProc: toggle counts not updated in nodes");
}
- needSummary = (segPtr->body.toggle.tagPtr->tagRootPtr != linePtr->parentPtr);
+ needSummary = (segPtr->body.toggle.tagPtr->tagRootPtr!=linePtr->parentPtr);
for (summaryPtr = linePtr->parentPtr->summaryPtr; ;
summaryPtr = summaryPtr->nextPtr) {
if (summaryPtr == NULL) {
@@ -4869,3 +4871,11 @@ ToggleCheckProc(segPtr, linePtr)
}
}
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c
index b96542e..64e1021 100644
--- a/generic/tkTextDisp.c
+++ b/generic/tkTextDisp.c
@@ -12,7 +12,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextDisp.c,v 1.61 2007/01/11 15:35:39 dkf Exp $
+ * RCS: @(#) $Id: tkTextDisp.c,v 1.62 2007/02/22 13:56:33 dkf Exp $
*/
#include "tkPort.h"
@@ -74,44 +74,44 @@
/*
* TK_LAYOUT_WITH_BASE_CHUNKS:
*
- * With this macro set, collect all char chunks that have no holes between
- * them, that are on the same line and use the same font and font size.
- * Allocate the chars of all these chunks, the so-called "stretch", in a
- * DString in the first chunk, the so-called "base chunk". Use the base
- * chunk string for measuring and drawing, so that these actions are always
- * performed with maximum context.
+ * With this macro set, collect all char chunks that have no holes
+ * between them, that are on the same line and use the same font and font
+ * size. Allocate the chars of all these chunks, the so-called "stretch",
+ * in a DString in the first chunk, the so-called "base chunk". Use the
+ * base chunk string for measuring and drawing, so that these actions are
+ * always performed with maximum context.
*
- * This is necessary for text rendering engines that provide ligatures and
- * sub-pixel layout, like ATSU on Mac. If we don't do this, the measuring
- * will change all the time, leading to an ugly "tremble and shiver"
- * effect. This is because of the continuous splitting and re-merging of
- * chunks that goes on in a text widget, when the cursor or the selection
- * move.
+ * This is necessary for text rendering engines that provide ligatures
+ * and sub-pixel layout, like ATSU on Mac. If we don't do this, the
+ * measuring will change all the time, leading to an ugly "tremble and
+ * shiver" effect. This is because of the continuous splitting and
+ * re-merging of chunks that goes on in a text widget, when the cursor or
+ * the selection move.
*
* Side effects:
*
- * Memory management changes. Instead of attaching the character data to
- * the clientData structures of the char chunks, an additional DString is
- * used. The collection process will even lead to resizing this DString
- * for large stretches (> TCL_DSTRING_STATIC_SIZE == 200). We could reduce
- * the overall memory footprint by copying the result to a plain char array
- * after the line breaking process, but that would complicate the code and
- * make performance even worse speedwise. See also TODOs.
+ * Memory management changes. Instead of attaching the character data to
+ * the clientData structures of the char chunks, an additional DString is
+ * used. The collection process will even lead to resizing this DString
+ * for large stretches (> TCL_DSTRING_STATIC_SIZE == 200). We could
+ * reduce the overall memory footprint by copying the result to a plain
+ * char array after the line breaking process, but that would complicate
+ * the code and make performance even worse speedwise. See also TODOs.
*
* TODOs:
*
- * - Move the character collection process from the LayoutProc into
- * LayoutDLine(), so that the collection can be done before actual
- * layout. In this way measuring can look at the following text, too,
- * right from the beginning. Memory handling can also be improved with
- * this. Problem: We don't easily know which chunks are adjacent until
- * all the other chunks have calculated their width. Apparently marks
- * would return width==0. A separate char collection loop would have to
- * know these things.
- *
- * - Use a new context parameter to pass the context from LayoutDLine() to
- * the LayoutProc instead of using a global variable like now. Not
- * pressing until the previous point gets implemented.
+ * - Move the character collection process from the LayoutProc into
+ * LayoutDLine(), so that the collection can be done before actual
+ * layout. In this way measuring can look at the following text, too,
+ * right from the beginning. Memory handling can also be improved with
+ * this. Problem: We don't easily know which chunks are adjacent until
+ * all the other chunks have calculated their width. Apparently marks
+ * would return width==0. A separate char collection loop would have to
+ * know these things.
+ *
+ * - Use a new context parameter to pass the context from LayoutDLine() to
+ * the LayoutProc instead of using a global variable like now. Not
+ * pressing until the previous point gets implemented.
*/
/*
@@ -150,7 +150,7 @@ typedef struct StyleValues {
int tabStyle; /* One of TABULAR or WORDPROCESSOR. */
int underline; /* Non-zero means draw underline underneath
* text. */
- int elide; /* Zero means draw text, otherwise not */
+ int elide; /* Zero means draw text, otherwise not. */
TkWrapMode wrapMode; /* How to handle wrap-around for this tag.
* One of TEXT_WRAPMODE_CHAR,
* TEXT_WRAPMODE_NONE or TEXT_WRAPMODE_WORD.*/
@@ -429,10 +429,9 @@ typedef struct CharInfo {
* baseChars. */
int numBytes; /* Number of bytes that belong to this
* chunk. */
- const char *chars; /* UTF characters to display. Actually
- * points into the baseChars of the base
- * chunk. Only valid after
- * FinalizeBaseChunk(). */
+ const char *chars; /* UTF characters to display. Actually points
+ * into the baseChars of the base chunk. Only
+ * valid after FinalizeBaseChunk(). */
} CharInfo;
/*
@@ -444,7 +443,7 @@ typedef struct BaseCharInfo {
Tcl_DString baseChars; /* Actual characters for the stretch of text
* represented by this base chunk. */
int width; /* Width in pixels of the whole string, if
- * known, else -1. Valid during
+ * known, else -1. Valid during
* LayoutDLine(). */
} BaseCharInfo;
@@ -508,64 +507,51 @@ static void AdjustForTab(TkText *textPtr,
TkTextTabArray *tabArrayPtr, int index,
TkTextDispChunk *chunkPtr);
static void CharBboxProc(TkText *textPtr,
- TkTextDispChunk *chunkPtr,
- int index, int y, int lineHeight, int baseline,
- int *xPtr, int *yPtr, int *widthPtr,
- int *heightPtr);
-static int CharChunkMeasureChars(
- TkTextDispChunk *chunkPtr,
+ TkTextDispChunk *chunkPtr, int index, int y,
+ int lineHeight, int baseline, int *xPtr,
+ int *yPtr, int *widthPtr, int *heightPtr);
+static int CharChunkMeasureChars(TkTextDispChunk *chunkPtr,
const char *chars, int charsLen,
int start, int end, int startX, int maxX,
int flags, int *nextX);
static void CharDisplayProc(TkText *textPtr,
- TkTextDispChunk *chunkPtr,
- int x, int y, int height, int baseline,
- Display *display, Drawable dst, int screenY);
+ TkTextDispChunk *chunkPtr, int x, int y,
+ int height, int baseline, Display *display,
+ Drawable dst, int screenY);
static int CharMeasureProc(TkTextDispChunk *chunkPtr, int x);
static void CharUndisplayProc(TkText *textPtr,
TkTextDispChunk *chunkPtr);
-
-
#if TK_LAYOUT_WITH_BASE_CHUNKS
-
-static void FinalizeBaseChunk(
- TkTextDispChunk *additionalChunkPtr);
-static void FreeBaseChunk(
- TkTextDispChunk *baseChunkPtr);
-static int IsSameFGStyle(
- TextStyle *style1, TextStyle *style2);
-static void RemoveFromBaseChunk(
- TkTextDispChunk *chunkPtr);
-
+static void FinalizeBaseChunk(TkTextDispChunk *additionalChunkPtr);
+static void FreeBaseChunk(TkTextDispChunk *baseChunkPtr);
+static int IsSameFGStyle(TextStyle *style1, TextStyle *style2);
+static void RemoveFromBaseChunk(TkTextDispChunk *chunkPtr);
#endif
-
/*
* Definitions of elided procs. Compiler can't inline these since we use
- * pointers to these functions. ElideDisplayProc, ElideUndisplayProc
+ * pointers to these functions. ElideDisplayProc and ElideUndisplayProc are
* special-cased for speed, as potentially many elided DLine chunks if large,
* tag toggle-filled elided region.
*/
-
static void ElideBboxProc(TkText *textPtr,
- TkTextDispChunk *chunkPtr,
- int index, int y, int lineHeight, int baseline,
- int *xPtr, int *yPtr, int *widthPtr,
- int *heightPtr);
+ TkTextDispChunk *chunkPtr, int index, int y,
+ int lineHeight, int baseline, int *xPtr,
+ int *yPtr, int *widthPtr, int *heightPtr);
static int ElideMeasureProc(TkTextDispChunk *chunkPtr, int x);
-static void DisplayDLine(TkText *textPtr,
- DLine *dlPtr, DLine *prevPtr, Pixmap pixmap);
-static void DisplayLineBackground(TkText *textPtr,
- DLine *dlPtr, DLine *prevPtr, Pixmap pixmap);
+static void DisplayDLine(TkText *textPtr, DLine *dlPtr,
+ DLine *prevPtr, Pixmap pixmap);
+static void DisplayLineBackground(TkText *textPtr, DLine *dlPtr,
+ DLine *prevPtr, Pixmap pixmap);
static void DisplayText(ClientData clientData);
static DLine * FindDLine(DLine *dlPtr, CONST TkTextIndex *indexPtr);
static void FreeDLines(TkText *textPtr, DLine *firstPtr,
DLine *lastPtr, int action);
static void FreeStyle(TkText *textPtr, TextStyle *stylePtr);
static TextStyle * GetStyle(TkText *textPtr, CONST TkTextIndex *indexPtr);
-static void GetXView(Tcl_Interp *interp,
- TkText *textPtr, int report);
-static void GetYView(Tcl_Interp *interp,
- TkText *textPtr, int report);
+static void GetXView(Tcl_Interp *interp, TkText *textPtr,
+ int report);
+static void GetYView(Tcl_Interp *interp, TkText *textPtr,
+ int report);
static int GetYPixelCount(TkText *textPtr, DLine *dlPtr);
static DLine * LayoutDLine(TkText *textPtr,
CONST TkTextIndex *indexPtr);
@@ -768,12 +754,10 @@ GetStyle(
int numTags, isNew, i;
XGCValues gcValues;
unsigned long mask;
-
/*
* The variables below keep track of the highest-priority specification
* that has occurred for each of the various fields of the StyleValues.
*/
-
int borderPrio, borderWidthPrio, reliefPrio, bgStipplePrio;
int fgPrio, fontPrio, fgStipplePrio;
int underlinePrio, elidePrio, justifyPrio, offsetPrio;
@@ -794,7 +778,7 @@ GetStyle(
lMargin1Prio = lMargin2Prio = rMarginPrio = -1;
spacing1Prio = spacing2Prio = spacing3Prio = -1;
overstrikePrio = tabPrio = tabStylePrio = wrapPrio = -1;
- memset((VOID *) &styleValues, 0, sizeof(StyleValues));
+ memset(&styleValues, 0, sizeof(StyleValues));
styleValues.relief = TK_RELIEF_FLAT;
styleValues.fgColor = textPtr->fgColor;
styleValues.tkfont = textPtr->tkfont;
@@ -815,8 +799,8 @@ GetStyle(
/*
* If this is the selection tag, and inactiveSelBorder is NULL (the
- * default on Windows), then we need to skip it if we don't
- * have focus.
+ * default on Windows), then we need to skip it if we don't have the
+ * focus.
*/
if ((tagPtr == textPtr->selTagPtr) && !(textPtr->flags & GOT_FOCUS)) {
@@ -1116,7 +1100,7 @@ LayoutDLine(
* from the end of the line. */
int byteOffset, ascent, descent, code, elide, elidesize;
StyleValues *sValuePtr;
- TkTextElideInfo info; /* Keep track of elide state */
+ TkTextElideInfo info; /* Keep track of elide state. */
/*
* Create and initialize a new DLine structure.
@@ -1126,7 +1110,7 @@ LayoutDLine(
dlPtr->index = *indexPtr;
dlPtr->byteCount = 0;
dlPtr->y = 0;
- dlPtr->oldY = 0; /* Only set to avoid compiler warnings */
+ dlPtr->oldY = 0; /* Only set to avoid compiler warnings. */
dlPtr->height = 0;
dlPtr->baseline = 0;
dlPtr->chunkPtr = NULL;
@@ -1143,7 +1127,7 @@ LayoutDLine(
paragraphStart = (indexPtr->byteIndex == 0);
/*
- * Special case entirely elide line as there may be 1000s or more
+ * Special case entirely elide line as there may be 1000s or more.
*/
elide = TkTextIsElided(textPtr, indexPtr, &info);
@@ -1442,7 +1426,7 @@ LayoutDLine(
#if TK_LAYOUT_WITH_BASE_CHUNKS
if (baseCharChunkPtr != NULL) {
int expectedX =
- ((BaseCharInfo*) baseCharChunkPtr->clientData)->width
+ ((BaseCharInfo *) baseCharChunkPtr->clientData)->width
+ baseCharChunkPtr->x;
if ((expectedX != x) || !IsSameFGStyle(
@@ -1643,7 +1627,6 @@ LayoutDLine(
wholeLine = 0;
}
-
/*
* Make tab adjustments for the last tab stop, if there is one.
*/
@@ -2021,7 +2004,7 @@ UpdateDisplayInfo(
*/
lineNum = -1;
- bytesToCount = 0; /* Stop compiler warning */
+ bytesToCount = 0; /* Stop compiler warning. */
} else {
lineNum = TkBTreeLinesTo(textPtr,
dInfoPtr->dLinePtr->index.linePtr);
@@ -2423,8 +2406,8 @@ DisplayDLine(
}
/*
- * Don't call if elide. This tax ok since not very many visible
- * DLine's in an area, but potentially many elide ones
+ * Don't call if elide. This tax OK since not very many visible DLines
+ * in an area, but potentially many elide ones.
*/
if (chunkPtr->displayProc != NULL) {
@@ -2973,8 +2956,8 @@ AsyncUpdateLineMetrics(
int
TkTextUpdateLineMetrics(
TkText *textPtr, /* Information about widget. */
- int lineNum, /* Start at this line */
- int endLine, /* Go no further than this line */
+ int lineNum, /* Start at this line. */
+ int endLine, /* Go no further than this line. */
int doThisMuch) /* How many lines to check, or how many 10s of
* lines to recalculate. If '-1' then do
* everything in the range (which may take a
@@ -2985,7 +2968,10 @@ TkTextUpdateLineMetrics(
int totalLines = TkBTreeNumLines(textPtr->sharedTextPtr->tree, textPtr);
if (totalLines == 0) {
- /* Empty peer widget */
+ /*
+ * Empty peer widget.
+ */
+
return endLine;
}
@@ -3312,7 +3298,7 @@ TextInvalidateLineMetrics(
}
/*
- * Now re-set the current update calculations
+ * Now re-set the current update calculations.
*/
if (dInfoPtr->lineUpdateTimer == NULL) {
@@ -3746,6 +3732,7 @@ TkTextUpdateOneLine(
*/
TkTextIndex idx;
+
TkTextIndexBackChars(textPtr, indexPtr, 1, &idx, COUNT_INDICES);
if (!TkTextIsElided(textPtr, &idx, NULL)) {
/*
@@ -4071,10 +4058,9 @@ DisplayText(
*/
damageRgn = TkCreateRegion();
- if (TkScrollWindow(textPtr->tkwin, dInfoPtr->scrollGC,
- dInfoPtr->x, oldY,
- (dInfoPtr->maxX - dInfoPtr->x), height,
- 0, y - oldY, damageRgn)) {
+ if (TkScrollWindow(textPtr->tkwin, dInfoPtr->scrollGC, dInfoPtr->x,
+ oldY, dInfoPtr->maxX-dInfoPtr->x, height, 0, y-oldY,
+ damageRgn)) {
TextInvalidateRegion(textPtr, damageRgn);
}
numCopies++;
@@ -4194,7 +4180,9 @@ DisplayText(
for (prevPtr = NULL, dlPtr = textPtr->dInfoPtr->dLinePtr;
(dlPtr != NULL) && (dlPtr->y < dInfoPtr->maxY);
prevPtr = dlPtr, dlPtr = dlPtr->nextPtr) {
- if (dlPtr->chunkPtr == NULL) continue;
+ if (dlPtr->chunkPtr == NULL) {
+ continue;
+ }
if ((dlPtr->flags & OLD_Y_INVALID) || dlPtr->oldY != dlPtr->y) {
if (tkTextDebug) {
char string[TK_POS_CHARS];
@@ -4252,9 +4240,8 @@ DisplayText(
TkTextEmbWinDisplayProc(textPtr, chunkPtr, x,
dlPtr->spaceAbove,
dlPtr->height-dlPtr->spaceAbove-dlPtr->spaceBelow,
- dlPtr->baseline - dlPtr->spaceAbove,
- NULL, (Drawable) None,
- dlPtr->y + dlPtr->spaceAbove);
+ dlPtr->baseline - dlPtr->spaceAbove, NULL,
+ (Drawable) None, dlPtr->y + dlPtr->spaceAbove);
}
}
@@ -4292,14 +4279,13 @@ DisplayText(
}
dInfoPtr->topOfEof = bottomY;
- doScrollbars:
-
/*
* Update the vertical scrollbar, if there is one. Note: it's important to
* clear REDRAW_PENDING here, just in case the scroll function does
* something that requires redisplay.
*/
+ doScrollbars:
if (textPtr->flags & UPDATE_SCROLLBARS) {
textPtr->flags &= ~UPDATE_SCROLLBARS;
if (textPtr->yScrollCmd != NULL) {
@@ -4344,7 +4330,6 @@ DisplayText(
*----------------------------------------------------------------------
*/
- /* ARGSUSED */
void
TkTextEventuallyRepick(
TkText *textPtr) /* Widget record for text widget. */
@@ -4376,7 +4361,6 @@ TkTextEventuallyRepick(
*----------------------------------------------------------------------
*/
- /* ARGSUSED */
void
TkTextRedrawRegion(
TkText *textPtr, /* Widget record for text widget. */
@@ -4491,7 +4475,7 @@ TextInvalidateRegion(
void
TkTextChanged(
- TkSharedText *sharedTextPtr,/* Shared widget section, or NULL */
+ TkSharedText *sharedTextPtr,/* Shared widget section, or NULL. */
TkText *textPtr, /* Widget record for text widget, or NULL. */
CONST TkTextIndex*index1Ptr,/* Index of first character to redisplay. */
CONST TkTextIndex*index2Ptr)/* Index of character just after last one to
@@ -4590,7 +4574,7 @@ TextChanged(
void
TkTextRedrawTag(
- TkSharedText *sharedTextPtr,/* Shared widget section, or NULL */
+ TkSharedText *sharedTextPtr,/* Shared widget section, or NULL. */
TkText *textPtr, /* Widget record for text widget. */
TkTextIndex *index1Ptr, /* First character in range to consider for
* redisplay. NULL means start at beginning of
@@ -4811,7 +4795,7 @@ void
TkTextRelayoutWindow(
TkText *textPtr, /* Widget record for text widget. */
int mask) /* OR'd collection of bits showing what has
- * changed */
+ * changed. */
{
TextDInfo *dInfoPtr = textPtr->dInfoPtr;
GC newGC;
@@ -4979,7 +4963,7 @@ TkTextSetYView(
if (pickPlace == TK_TEXT_NOPIXELADJUST) {
if (textPtr->topIndex.linePtr == indexPtr->linePtr
- && textPtr->topIndex.byteIndex == indexPtr->byteIndex) {
+ && textPtr->topIndex.byteIndex == indexPtr->byteIndex) {
pickPlace = dInfoPtr->topPixelOffset;
} else {
pickPlace = 0;
@@ -5022,8 +5006,7 @@ TkTextSetYView(
dlPtr = NULL;
} else if ((dlPtr->index.linePtr == indexPtr->linePtr)
&& (dlPtr->index.byteIndex <= indexPtr->byteIndex)) {
- if (dInfoPtr->dLinePtr == dlPtr
- && dInfoPtr->topPixelOffset != 0) {
+ if (dInfoPtr->dLinePtr == dlPtr && dInfoPtr->topPixelOffset != 0) {
/*
* It is on the top line, but that line is hanging off the top
* of the screen. Change the top overlap to zero and update.
@@ -5355,7 +5338,7 @@ TkTextSeeCmd(
byteCount = index.byteIndex - dlPtr->index.byteIndex;
for (chunkPtr = dlPtr->chunkPtr; chunkPtr != NULL ;
- chunkPtr = chunkPtr->nextPtr) {
+ chunkPtr = chunkPtr->nextPtr) {
if (byteCount < chunkPtr->numBytes) {
break;
}
@@ -5652,8 +5635,8 @@ YScrollByLines(
* top window border.
*/
- TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr,
- 0, 0, &textPtr->topIndex);
+ TkTextMakeByteIndex(textPtr->sharedTextPtr->tree, textPtr, 0, 0,
+ &textPtr->topIndex);
dInfoPtr->newTopPixelOffset = 0;
} else {
/*
@@ -6028,7 +6011,7 @@ GetXView(
last = 1.0;
}
if (!report) {
- listObj = Tcl_NewListObj(0,NULL);
+ listObj = Tcl_NewListObj(0, NULL);
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(first));
Tcl_ListObjAppendElement(interp, listObj, Tcl_NewDoubleObj(last));
Tcl_SetObjResult(interp, listObj);
@@ -6093,9 +6076,10 @@ static int
GetYPixelCount(
TkText *textPtr, /* Information about text widget. */
DLine *dlPtr) /* Information about the layout of a given
- * index */
+ * index. */
{
TkTextLine *linePtr = dlPtr->index.linePtr;
+ int count;
/*
* Get the pixel count to the top of dlPtr's logical line. The rest of the
@@ -6103,7 +6087,7 @@ GetYPixelCount(
* between the top of the logical line and the display line.
*/
- int count = TkBTreePixelsTo(textPtr, linePtr);
+ count = TkBTreePixelsTo(textPtr, linePtr);
/*
* For the common case where this dlPtr is also the start of the logical
@@ -6137,10 +6121,10 @@ GetYPixelCount(
if (dlPtr->nextPtr == NULL) {
/*
* We've run out of pre-calculated display lines, so we have to
- * lay them out ourselves until the end of the logical line.
- * Here's where we could be clever and ask: what's faster, to
- * layout all lines from here to line-end, or all lines from the
- * original dlPtr to the line-start? We just assume the former.
+ * lay them out ourselves until the end of the logical line. Here
+ * is where we could be clever and ask: what's faster, to layout
+ * all lines from here to line-end, or all lines from the original
+ * dlPtr to the line-start? We just assume the former.
*/
TkTextIndex index;
@@ -6250,8 +6234,8 @@ GetYView(
while (1) {
int extra;
- count += dlPtr->height;
+ count += dlPtr->height;
extra = dlPtr->y + dlPtr->height - dInfoPtr->maxY;
if (extra > 0) {
/*
@@ -6528,9 +6512,11 @@ TkTextPixelIndex(
return;
} else {
for (dlPtr = validDlPtr = dInfoPtr->dLinePtr;
- y >= (dlPtr->y + dlPtr->height);
- dlPtr = dlPtr->nextPtr) {
- if (dlPtr->chunkPtr !=NULL) validDlPtr = dlPtr;
+ y >= (dlPtr->y + dlPtr->height);
+ dlPtr = dlPtr->nextPtr) {
+ if (dlPtr->chunkPtr != NULL) {
+ validDlPtr = dlPtr;
+ }
if (dlPtr->nextPtr == NULL) {
/*
* Y-coordinate is off the bottom of the displayed text. Use
@@ -6663,7 +6649,7 @@ void
TkTextIndexOfX(
TkText *textPtr, /* Widget record for text widget. */
int x, /* The x coordinate for which we want the
- * index */
+ * index. */
TkTextIndex *indexPtr) /* Index of display line start, which will be
* adjusted to the index under the given x
* coordinate. */
@@ -6709,7 +6695,9 @@ DlineXOfIndex(
register TkTextDispChunk *chunkPtr = dlPtr->chunkPtr;
int x;
- if (byteIndex == 0 || chunkPtr == NULL) return 0;
+ if (byteIndex == 0 || chunkPtr == NULL) {
+ return 0;
+ }
/*
* Scan through the line's chunks to find the one that contains the
@@ -6749,9 +6737,9 @@ DlineXOfIndex(
* the entity (character, window, image) at that index.
*
* Results:
- * Zero is returned if the index is on the screen. -1 means the index
- * isn't on the screen. If the return value is 0, then the bounding box
- * of the part of the index that's visible on the screen is returned to
+ * Zero is returned if the index is on the screen. -1 means the index is
+ * not on the screen. If the return value is 0, then the bounding box of
+ * the part of the index that's visible on the screen is returned to
* *xPtr, *yPtr, *widthPtr, and *heightPtr.
*
* Side effects:
@@ -6937,7 +6925,7 @@ TkTextDLineInfo(
}
/*
- * Get bounding-box information about an elided chunk
+ * Get bounding-box information about an elided chunk.
*/
static void
@@ -6965,7 +6953,7 @@ ElideBboxProc(
}
/*
- * Measure an elided chunk
+ * Measure an elided chunk.
*/
static int
@@ -7050,17 +7038,16 @@ TkTextCharLayoutProc(
#if TK_LAYOUT_WITH_BASE_CHUNKS
if (baseCharChunkPtr == NULL) {
-
baseCharChunkPtr = chunkPtr;
- bciPtr = (BaseCharInfo*) ckalloc(sizeof(BaseCharInfo));
+ bciPtr = (BaseCharInfo *) ckalloc(sizeof(BaseCharInfo));
baseString = &bciPtr->baseChars;
Tcl_DStringInit(baseString);
bciPtr->width = 0;
ciPtr = &bciPtr->ci;
} else {
- bciPtr = (BaseCharInfo*) baseCharChunkPtr->clientData;
- ciPtr = (CharInfo*) ckalloc(sizeof(CharInfo));
+ bciPtr = (BaseCharInfo *) baseCharChunkPtr->clientData;
+ ciPtr = (CharInfo *) ckalloc(sizeof(CharInfo));
baseString = &bciPtr->baseChars;
}
@@ -7076,7 +7063,7 @@ TkTextCharLayoutProc(
bytesThatFit = CharChunkMeasureChars(chunkPtr, line,
lineOffset + maxBytes, lineOffset, -1, chunkPtr->x, maxX,
TK_ISOLATE_END, &nextX);
-#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
+#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
bytesThatFit = CharChunkMeasureChars(chunkPtr, p, maxBytes, 0, -1,
chunkPtr->x, maxX, TK_ISOLATE_END, &nextX);
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
@@ -7087,13 +7074,12 @@ TkTextCharLayoutProc(
int chLen = Tcl_UtfToUniChar(p, &ch);
#if TK_LAYOUT_WITH_BASE_CHUNKS
- bytesThatFit = CharChunkMeasureChars(
- chunkPtr, line, lineOffset + chLen, lineOffset, -1,
- chunkPtr->x, -1, 0, &nextX);
-#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
- bytesThatFit = CharChunkMeasureChars(
- chunkPtr, p, chLen, 0, -1,
- chunkPtr->x, -1, 0, &nextX);
+ bytesThatFit = CharChunkMeasureChars(chunkPtr, line,
+ lineOffset+chLen, lineOffset, -1, chunkPtr->x, -1, 0,
+ &nextX);
+#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
+ bytesThatFit = CharChunkMeasureChars(chunkPtr, p, chLen, 0, -1,
+ chunkPtr->x, -1, 0, &nextX);
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
}
if ((nextX < maxX) && ((p[bytesThatFit] == ' ')
@@ -7124,7 +7110,7 @@ TkTextCharLayoutProc(
} else {
Tcl_DStringSetLength(baseString,lineOffset);
}
- ckfree((char*)ciPtr);
+ ckfree((char *) ciPtr);
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
return 0;
}
@@ -7162,7 +7148,6 @@ TkTextCharLayoutProc(
}
#if TK_LAYOUT_WITH_BASE_CHUNKS
-
/*
* Final update for the current base chunk data.
*/
@@ -7178,7 +7163,6 @@ TkTextCharLayoutProc(
if (ciPtr->numBytes > 0 && p[ciPtr->numBytes - 1] == '\t') {
FinalizeBaseChunk(chunkPtr);
}
-
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
/*
@@ -7215,21 +7199,21 @@ TkTextCharLayoutProc(
/*
*---------------------------------------------------------------------------
*
- * CharChunkMeasureChars --
+ * CharChunkMeasureChars --
*
* Determine the number of characters from a char chunk that will fit in
* the given horizontal span.
*
* This is the same as MeasureChars (which see), but in the context of a
- * char chunk, i.e. on a higher level of abstraction. Use this function
+ * char chunk, i.e. on a higher level of abstraction. Use this function
* whereever possible instead of plain MeasureChars, so that the right
* context is used automatically.
*
* Results:
- * The return value is the number of bytes from the range of start to
- * end in source that fit in the span given by startX and maxX.
- * *nextXPtr is filled in with the x-coordinate at which the first
- * character that didn't fit would be drawn, if it were to be drawn.
+ * The return value is the number of bytes from the range of start to end
+ * in source that fit in the span given by startX and maxX. *nextXPtr is
+ * filled in with the x-coordinate at which the first character that
+ * didn't fit would be drawn, if it were to be drawn.
*
* Side effects:
* None.
@@ -7241,15 +7225,15 @@ CharChunkMeasureChars(
TkTextDispChunk *chunkPtr, /* Chunk from which to measure. */
const char *chars, /* Chars to use, instead of the chunk's own.
* Used by the layoutproc during chunk setup.
- * All other callers use NULL. Not
+ * All other callers use NULL. Not
* NUL-terminated. */
int charsLen, /* Length of the "chars" parameter. */
int start, int end, /* The range of chars to measure inside the
* chunk (or inside the additional chars). */
int startX, /* Starting x coordinate where the measured
* span will begin. */
- int maxX, /* Maximum pixel width of the span. May be
- * -1 for unlimited. */
+ int maxX, /* Maximum pixel width of the span. May be -1
+ * for unlimited. */
int flags, /* Flags to pass to MeasureChars. */
int *nextXPtr) /* The function puts the newly calculated
* right border x-position of the span
@@ -7275,8 +7259,9 @@ CharChunkMeasureChars(
int fit, bstart = start, bend = end;
if (chars == NULL) {
- Tcl_DString *baseChars =
- &((BaseCharInfo *)ciPtr->baseChunkPtr->clientData)->baseChars;
+ Tcl_DString *baseChars = &((BaseCharInfo *)
+ ciPtr->baseChunkPtr->clientData)->baseChars;
+
chars = Tcl_DStringValue(baseChars);
charsLen = Tcl_DStringLength(baseChars);
bstart += ciPtr->baseOffset;
@@ -7285,16 +7270,15 @@ CharChunkMeasureChars(
} else {
bend += ciPtr->baseOffset;
}
- } else {
- if (bend == -1) {
- bend = charsLen;
- }
+ } else if (bend == -1) {
+ bend = charsLen;
}
if (bstart == ciPtr->baseOffset) {
xDisplacement = startX - chunkPtr->x;
} else {
int widthUntilStart = 0;
+
MeasureChars(tkfont, chars, charsLen, 0, bstart,
0, -1, 0, &widthUntilStart);
xDisplacement = startX - widthUntilStart - chunkPtr->x;
@@ -7352,7 +7336,7 @@ CharDisplayProc(
int numBytes, offsetBytes, offsetX;
#if TK_DRAW_IN_CONTEXT
BaseCharInfo *bciPtr;
-#endif
+#endif /* TK_DRAW_IN_CONTEXT */
if ((x + chunkPtr->width) <= 0) {
/*
@@ -7363,13 +7347,11 @@ CharDisplayProc(
}
#if TK_DRAW_IN_CONTEXT
-
- bciPtr = (BaseCharInfo*) ciPtr->baseChunkPtr->clientData;
+ bciPtr = (BaseCharInfo *) ciPtr->baseChunkPtr->clientData;
numBytes = Tcl_DStringLength(&bciPtr->baseChars);
string = Tcl_DStringValue(&bciPtr->baseChars);
#elif TK_LAYOUT_WITH_BASE_CHUNKS
-
if (ciPtr->baseChunkPtr != chunkPtr) {
/*
* Without context drawing only base chunks display their foreground.
@@ -7378,14 +7360,12 @@ CharDisplayProc(
return;
}
- numBytes = Tcl_DStringLength(&((BaseCharInfo*) ciPtr)->baseChars);
+ numBytes = Tcl_DStringLength(&((BaseCharInfo *) ciPtr)->baseChars);
string = ciPtr->chars;
#else /* !TK_LAYOUT_WITH_BASE_CHUNKS */
-
numBytes = ciPtr->numBytes;
string = ciPtr->chars;
-
#endif /* TK_LAYOUT_WITH_BASE_CHUNKS */
stylePtr = chunkPtr->stylePtr;
@@ -7410,8 +7390,8 @@ CharDisplayProc(
* Draw the text, underline, and overstrike for this chunk.
*/
- if (!sValuePtr->elide && (numBytes > offsetBytes)
- && (stylePtr->fgGC != None)) {
+ if (!sValuePtr->elide && (numBytes > offsetBytes)
+ && (stylePtr->fgGC != None)) {
#if TK_DRAW_IN_CONTEXT
int start = ciPtr->baseOffset + offsetBytes;
int len = ciPtr->numBytes - offsetBytes;
@@ -7438,7 +7418,7 @@ CharDisplayProc(
}
if (sValuePtr->overstrike) {
Tk_FontMetrics fm;
-
+
Tk_GetFontMetrics(sValuePtr->tkfont, &fm);
TkUnderlineCharsInContext(display, dst, stylePtr->fgGC,
sValuePtr->tkfont, string, numBytes,
@@ -7447,7 +7427,7 @@ CharDisplayProc(
- fm.descent - (fm.ascent * 3) / 10,
start, start+len);
}
-#else
+#else /* !TK_DRAW_IN_CONTEXT */
string += offsetBytes;
numBytes -= offsetBytes;
@@ -7473,7 +7453,7 @@ CharDisplayProc(
- fm.descent - (fm.ascent * 3) / 10,
0, numBytes);
}
-#endif
+#endif /* TK_DRAW_IN_CONTEXT */
}
}
@@ -7504,7 +7484,6 @@ CharUndisplayProc(
#if TK_LAYOUT_WITH_BASE_CHUNKS
if (chunkPtr == ciPtr->baseChunkPtr) {
-
/*
* Basechunks are undisplayed first, when DLines are freed or
* partially freed, so this makes sure we don't access their data any
@@ -7512,13 +7491,11 @@ CharUndisplayProc(
*/
FreeBaseChunk(chunkPtr);
-
} else if (ciPtr->baseChunkPtr != NULL) {
-
/*
* When other char chunks are undisplayed, drop their characters from
- * the base chunk. This usually happens, when they are last in a
- * line and need to be re-layed out.
+ * the base chunk. This usually happens, when they are last in a line
+ * and need to be re-layed out.
*/
RemoveFromBaseChunk(chunkPtr);
@@ -7559,9 +7536,8 @@ CharMeasureProc(
{
int endX;
- return CharChunkMeasureChars(
- chunkPtr, NULL, 0, 0, chunkPtr->numBytes - 1, chunkPtr->x, x, 0,
- &endX); /* CHAR OFFSET */
+ return CharChunkMeasureChars(chunkPtr, NULL, 0, 0, chunkPtr->numBytes-1,
+ chunkPtr->x, x, 0, &endX); /* CHAR OFFSET */
}
/*
@@ -7881,7 +7857,7 @@ SizeOfTab(
tabWidth = 1;
}
} else {
- tabWidth = 0; /* Avoid compiler error */
+ tabWidth = 0; /* Avoid compiler error. */
}
do {
@@ -8029,10 +8005,10 @@ NextTabStop(
* that point.
*
* Results:
- * The return value is the number of bytes from the range of start to
- * end in source that fit in the span given by startX and maxX.
- * *nextXPtr is filled in with the x-coordinate at which the first
- * character that didn't fit would be drawn, if it were to be drawn.
+ * The return value is the number of bytes from the range of start to end
+ * in source that fit in the span given by startX and maxX. *nextXPtr is
+ * filled in with the x-coordinate at which the first character that
+ * didn't fit would be drawn, if it were to be drawn.
*
* Side effects:
* None.
@@ -8095,7 +8071,7 @@ MeasureChars(
(void) maxBytes;
start += Tk_MeasureChars(tkfont, start, special - start,
maxX >= 0 ? maxX - curX : -1, flags, &width);
-#endif
+#endif /* TK_DRAW_IN_CONTEXT */
curX += width;
if (start < special) {
/*
@@ -8224,8 +8200,8 @@ TextGetScrollInfoObj(
* FinalizeBaseChunk --
*
* This procedure makes sure that all the chunks of the stretch are
- * up-to-date. It is invoked when the LayoutProc has been called for
- * all chunks and the base chunk is stable.
+ * up-to-date. It is invoked when the LayoutProc has been called for all
+ * chunks and the base chunk is stable.
*
* Results:
* None.
@@ -8239,33 +8215,32 @@ TextGetScrollInfoObj(
static void
FinalizeBaseChunk(
- TkTextDispChunk *addChunkPtr) /* An additional chunk to add to the
- * stretch, even though it may not be
- * in the linked list yet. Used by
- * the LayoutProc, otherwise NULL. */
+ TkTextDispChunk *addChunkPtr)
+ /* An additional chunk to add to the stretch,
+ * even though it may not be in the linked
+ * list yet. Used by the LayoutProc, otherwise
+ * NULL. */
{
const char *baseChars;
TkTextDispChunk *chunkPtr;
- CharInfo * ciPtr;
+ CharInfo *ciPtr;
#if TK_DRAW_IN_CONTEXT
int widthAdjust = 0;
int newwidth;
-#endif
+#endif /* TK_DRAW_IN_CONTEXT */
if (baseCharChunkPtr == NULL) {
return;
}
baseChars = Tcl_DStringValue(
- &((BaseCharInfo*) baseCharChunkPtr->clientData)->baseChars);
-
- for (chunkPtr = baseCharChunkPtr;
- chunkPtr != NULL;
- chunkPtr = chunkPtr->nextPtr) {
+ &((BaseCharInfo *) baseCharChunkPtr->clientData)->baseChars);
+ for (chunkPtr = baseCharChunkPtr; chunkPtr != NULL;
+ chunkPtr = chunkPtr->nextPtr) {
#if TK_DRAW_IN_CONTEXT
chunkPtr->x += widthAdjust;
-#endif
+#endif /* TK_DRAW_IN_CONTEXT */
if (chunkPtr->displayProc != CharDisplayProc) {
continue;
@@ -8278,27 +8253,23 @@ FinalizeBaseChunk(
#if TK_DRAW_IN_CONTEXT
newwidth = 0;
- CharChunkMeasureChars(
- chunkPtr, NULL, 0, 0, -1, 0, -1, 0, &newwidth);
+ CharChunkMeasureChars(chunkPtr, NULL, 0, 0, -1, 0, -1, 0, &newwidth);
if (newwidth != chunkPtr->width) {
widthAdjust += newwidth - chunkPtr->width;
chunkPtr->width = newwidth;
}
-#endif
-
+#endif /* TK_DRAW_IN_CONTEXT */
}
if (addChunkPtr != NULL) {
-
ciPtr = (CharInfo *)addChunkPtr->clientData;
ciPtr->chars = baseChars + ciPtr->baseOffset;
#if TK_DRAW_IN_CONTEXT
addChunkPtr->x += widthAdjust;
- CharChunkMeasureChars(
- addChunkPtr, NULL, 0, 0, -1, 0, -1, 0, &addChunkPtr->width);
-#endif
-
+ CharChunkMeasureChars(addChunkPtr, NULL, 0, 0, -1, 0, -1, 0,
+ &addChunkPtr->width);
+#endif /* TK_DRAW_IN_CONTEXT */
}
baseCharChunkPtr = NULL;
@@ -8311,7 +8282,7 @@ FinalizeBaseChunk(
*
* This procedure makes sure that all the chunks of the stretch are
* disconnected from the base chunk and the base chunk specific data is
- * freed. It is invoked from the UndisplayProc. The procedure doesn't
+ * freed. It is invoked from the UndisplayProc. The procedure doesn't
* ckfree the base chunk clientData itself, that's up to the main
* UndisplayProc.
*
@@ -8319,7 +8290,7 @@ FinalizeBaseChunk(
* None.
*
* Side effects:
- * The CharInfo.chars of all dependent chunks are set to NULL. Memory
+ * The CharInfo.chars of all dependent chunks are set to NULL. Memory
* that belongs specifically to the base chunk is freed.
*
*----------------------------------------------------------------------
@@ -8327,8 +8298,9 @@ FinalizeBaseChunk(
static void
FreeBaseChunk(
- TkTextDispChunk * baseChunkPtr) /* The base chunk of the stretch and
- * head of the linked list. */
+ TkTextDispChunk *baseChunkPtr)
+ /* The base chunk of the stretch and head of
+ * the linked list. */
{
TkTextDispChunk *chunkPtr;
CharInfo *ciPtr;
@@ -8337,10 +8309,7 @@ FreeBaseChunk(
baseCharChunkPtr = NULL;
}
- for (chunkPtr = baseChunkPtr;
- chunkPtr != NULL;
- chunkPtr = chunkPtr->nextPtr) {
-
+ for (chunkPtr=baseChunkPtr; chunkPtr!=NULL; chunkPtr=chunkPtr->nextPtr) {
if (chunkPtr->undisplayProc != CharUndisplayProc) {
continue;
}
@@ -8353,7 +8322,7 @@ FreeBaseChunk(
ciPtr->chars = NULL;
}
- Tcl_DStringFree(&((BaseCharInfo*)baseChunkPtr->clientData)->baseChars);
+ Tcl_DStringFree(&((BaseCharInfo *) baseChunkPtr->clientData)->baseChars);
}
/*
@@ -8361,9 +8330,9 @@ FreeBaseChunk(
*
* IsSameFGStyle --
*
- * Compare the foreground attributes of two styles. Specifically
- * consider: Foreground color, font, font style and font decorations,
- * elide, "offset" and foreground stipple. *Don't* consider: Background
+ * Compare the foreground attributes of two styles. Specifically must
+ * consider: foreground color, font, font style and font decorations,
+ * elide, "offset" and foreground stipple. Do *not* consider: background
* color, border, relief or background stipple.
*
* If we use TkpDrawCharsInContext(), we also don't need to check
@@ -8383,7 +8352,7 @@ FreeBaseChunk(
static int
IsSameFGStyle(
TextStyle *style1,
- TextStyle *style2)
+ TextStyle *style2)
{
StyleValues *sv1;
StyleValues *sv2;
@@ -8393,36 +8362,31 @@ IsSameFGStyle(
}
#if !TK_DRAW_IN_CONTEXT
-
if (
#ifdef MAC_OSX_TK
!TkMacOSXCompareColors(style1->fgGC->foreground,
- style2->fgGC->foreground)
+ style2->fgGC->foreground)
#else
style1->fgGC->foreground != style2->fgGC->foreground
#endif
) {
return 0;
}
-
-#endif
+#endif /* !TK_DRAW_IN_CONTEXT */
sv1 = style1->sValuePtr;
sv2 = style2->sValuePtr;
#if TK_DRAW_IN_CONTEXT
- return sv1->tkfont == sv2->tkfont
- && sv1->offset == sv2->offset
- ;
+ return sv1->tkfont == sv2->tkfont && sv1->offset == sv2->offset;
#else
- return sv1->tkfont == sv2->tkfont
- && sv1->underline == sv2->underline
- && sv1->overstrike == sv2->overstrike
- && sv1->elide == sv2->elide
- && sv1->offset == sv2->offset
- && sv1->fgStipple == sv1->fgStipple
- ;
-#endif
+ return sv1->tkfont == sv2->tkfont
+ && sv1->underline == sv2->underline
+ && sv1->overstrike == sv2->overstrike
+ && sv1->elide == sv2->elide
+ && sv1->offset == sv2->offset
+ && sv1->fgStipple == sv1->fgStipple;
+#endif /* TK_DRAW_IN_CONTEXT */
}
/*
@@ -8431,29 +8395,29 @@ IsSameFGStyle(
* RemoveFromBaseChunk --
*
* This procedure removes a chunk from the stretch as a result of
- * UndisplayProc. The chunk in question should be the last in a
- * stretch. This happens during re-layouting of the break position.
+ * UndisplayProc. The chunk in question should be the last in a stretch.
+ * This happens during re-layouting of the break position.
*
* Results:
* None.
*
* Side effects:
* The characters that belong to this chunk are removed from the base
- * chunk. It is assumed that LayoutProc and FinalizeBaseChunk are
- * called next to repair any damage that this causes to the integrity of
- * the stretch and the other chunks. For that reason the base chunk is
- * also put into baseCharChunkPtr automatically, so that LayoutProc can
- * resume correctly.
+ * chunk. It is assumed that LayoutProc and FinalizeBaseChunk are called
+ * next to repair any damage that this causes to the integrity of the
+ * stretch and the other chunks. For that reason the base chunk is also
+ * put into baseCharChunkPtr automatically, so that LayoutProc can resume
+ * correctly.
*
*----------------------------------------------------------------------
*/
static void
RemoveFromBaseChunk(
- TkTextDispChunk *chunkPtr) /* The chunk to remove from the end
- * of the stretch. */
+ TkTextDispChunk *chunkPtr) /* The chunk to remove from the end of the
+ * stretch. */
{
- CharInfo *ciPtr;
+ CharInfo *ciPtr;
BaseCharInfo *bciPtr;
if (chunkPtr->displayProc != CharDisplayProc) {
@@ -8465,14 +8429,14 @@ RemoveFromBaseChunk(
* Reinstitute this base chunk for re-layout.
*/
- ciPtr = (CharInfo*) chunkPtr->clientData;
+ ciPtr = (CharInfo *) chunkPtr->clientData;
baseCharChunkPtr = ciPtr->baseChunkPtr;
/*
* Remove the chunk data from the base chunk data.
*/
- bciPtr = (BaseCharInfo*) baseCharChunkPtr->clientData;
+ bciPtr = (BaseCharInfo *) baseCharChunkPtr->clientData;
if ((ciPtr->baseOffset + ciPtr->numBytes)
!= Tcl_DStringLength(&bciPtr->baseChars)) {
diff --git a/generic/tkTextIndex.c b/generic/tkTextIndex.c
index 970c414..511806b 100644
--- a/generic/tkTextIndex.c
+++ b/generic/tkTextIndex.c
@@ -10,7 +10,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextIndex.c,v 1.24 2005/11/17 16:21:56 dkf Exp $
+ * RCS: @(#) $Id: tkTextIndex.c,v 1.25 2007/02/22 13:56:33 dkf Exp $
*/
#include "default.h"
@@ -82,8 +82,8 @@ Tcl_ObjType tkTextIndexType = {
};
static void
-FreeTextIndexInternalRep(indexObjPtr)
- Tcl_Obj *indexObjPtr; /* TextIndex object with internal rep to
+FreeTextIndexInternalRep(
+ Tcl_Obj *indexObjPtr) /* TextIndex object with internal rep to
* free. */
{
TkTextIndex *indexPtr = GET_TEXTINDEX(indexObjPtr);
@@ -96,17 +96,18 @@ FreeTextIndexInternalRep(indexObjPtr)
ckfree((char *) (indexPtr->textPtr));
}
}
- ckfree((char*)indexPtr);
+ ckfree((char *) indexPtr);
}
static void
-DupTextIndexInternalRep(srcPtr, copyPtr)
- Tcl_Obj *srcPtr; /* TextIndex obj with internal rep to copy. */
- Tcl_Obj *copyPtr; /* TextIndex obj with internal rep to set. */
+DupTextIndexInternalRep(
+ Tcl_Obj *srcPtr, /* TextIndex obj with internal rep to copy. */
+ Tcl_Obj *copyPtr) /* TextIndex obj with internal rep to set. */
{
int epoch;
TkTextIndex *dupIndexPtr, *indexPtr;
- dupIndexPtr = (TkTextIndex*) ckalloc(sizeof(TkTextIndex));
+
+ dupIndexPtr = (TkTextIndex *) ckalloc(sizeof(TkTextIndex));
indexPtr = GET_TEXTINDEX(srcPtr);
epoch = GET_INDEXEPOCH(srcPtr);
@@ -125,8 +126,8 @@ DupTextIndexInternalRep(srcPtr, copyPtr)
*/
static void
-UpdateStringOfTextIndex(objPtr)
- Tcl_Obj *objPtr;
+UpdateStringOfTextIndex(
+ Tcl_Obj *objPtr)
{
char buffer[TK_POS_CHARS];
register int len;
@@ -141,9 +142,9 @@ UpdateStringOfTextIndex(objPtr)
}
static int
-SetTextIndexFromAny(interp, objPtr)
- Tcl_Interp *interp; /* Used for error reporting if not NULL. */
- Tcl_Obj *objPtr; /* The object to convert. */
+SetTextIndexFromAny(
+ Tcl_Interp *interp, /* Used for error reporting if not NULL. */
+ Tcl_Obj *objPtr) /* The object to convert. */
{
Tcl_AppendToObj(Tcl_GetObjResult(interp),
"can't convert value to textindex except via TkTextGetIndexFromObj API",
@@ -164,7 +165,7 @@ SetTextIndexFromAny(interp, objPtr)
* very temporary (like @0,0 or the name of a mark or tag). The mapping
* from such strings/objects to actual TkTextIndex pointers is not stable
* to minor text widget changes which we do not track (we track
- * insertions/deletions).
+ * insertions and deletions).
*
* Results:
* A pointer to an allocated TkTextIndex which will be freed
@@ -177,11 +178,11 @@ SetTextIndexFromAny(interp, objPtr)
*/
static TkTextIndex *
-MakeObjIndex(textPtr, objPtr, origPtr)
- TkText *textPtr; /* Information about text widget. */
- Tcl_Obj *objPtr; /* Object containing description of
+MakeObjIndex(
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Obj *objPtr, /* Object containing description of
* position. */
- CONST TkTextIndex *origPtr; /* Pointer to index. */
+ CONST TkTextIndex *origPtr) /* Pointer to index. */
{
TkTextIndex *indexPtr = (TkTextIndex *) ckalloc(sizeof(TkTextIndex));
@@ -201,11 +202,11 @@ MakeObjIndex(textPtr, objPtr, origPtr)
return indexPtr;
}
-CONST TkTextIndex*
-TkTextGetIndexFromObj(interp, textPtr, objPtr)
- Tcl_Interp *interp; /* Use this for error reporting. */
- TkText *textPtr; /* Information about text widget. */
- Tcl_Obj *objPtr; /* Object containing description of
+CONST TkTextIndex *
+TkTextGetIndexFromObj(
+ Tcl_Interp *interp, /* Use this for error reporting. */
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Obj *objPtr) /* Object containing description of
* position. */
{
TkTextIndex index;
@@ -245,11 +246,7 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
}
}
- if (cache) {
- return MakeObjIndex(textPtr, objPtr, &index);
- } else {
- return MakeObjIndex(NULL, objPtr, &index);
- }
+ return MakeObjIndex((cache ? textPtr : NULL), objPtr, &index);
}
/*
@@ -270,10 +267,10 @@ TkTextGetIndexFromObj(interp, textPtr, objPtr)
*---------------------------------------------------------------------------
*/
-Tcl_Obj*
-TkTextNewIndexObj(textPtr, indexPtr)
- TkText *textPtr; /* Text widget for this index */
- CONST TkTextIndex *indexPtr;/* Pointer to index. */
+Tcl_Obj *
+TkTextNewIndexObj(
+ TkText *textPtr, /* Text widget for this index */
+ CONST TkTextIndex *indexPtr)/* Pointer to index. */
{
Tcl_Obj *retVal;
@@ -326,11 +323,11 @@ TkTextNewIndexObj(textPtr, indexPtr)
*/
int
-TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
- TkText* textPtr; /* The Text Widget */
- int pixelIndex; /* Pixel-index of desired line (0 means first
+TkTextMakePixelIndex(
+ TkText *textPtr, /* The Text Widget */
+ int pixelIndex, /* Pixel-index of desired line (0 means first
* pixel of first line of text). */
- TkTextIndex *indexPtr; /* Structure to fill in. */
+ TkTextIndex *indexPtr) /* Structure to fill in. */
{
int pixelOffset = 0;
@@ -345,7 +342,7 @@ TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
/*
* 'pixelIndex' was too large, so we try again, just to find the last
- * pixel in the window
+ * pixel in the window.
*/
if (indexPtr->linePtr == NULL) {
@@ -386,14 +383,14 @@ TkTextMakePixelIndex(textPtr, pixelIndex, indexPtr)
*/
TkTextIndex *
-TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
- TkTextBTree tree; /* Tree that lineIndex and byteIndex refer
+TkTextMakeByteIndex(
+ TkTextBTree tree, /* Tree that lineIndex and byteIndex refer
* to. */
- CONST TkText *textPtr;
- int lineIndex; /* Index of desired line (0 means first line
+ CONST TkText *textPtr,
+ int lineIndex, /* Index of desired line (0 means first line
* of text). */
- int byteIndex; /* Byte index of desired character. */
- TkTextIndex *indexPtr; /* Structure to fill in. */
+ int byteIndex, /* Byte index of desired character. */
+ TkTextIndex *indexPtr) /* Structure to fill in. */
{
TkTextSegment *segPtr;
int index;
@@ -479,14 +476,14 @@ TkTextMakeByteIndex(tree, textPtr, lineIndex, byteIndex, indexPtr)
*/
TkTextIndex *
-TkTextMakeCharIndex(tree, textPtr, lineIndex, charIndex, indexPtr)
- TkTextBTree tree; /* Tree that lineIndex and charIndex refer
+TkTextMakeCharIndex(
+ TkTextBTree tree, /* Tree that lineIndex and charIndex refer
* to. */
- TkText *textPtr;
- int lineIndex; /* Index of desired line (0 means first line
+ TkText *textPtr,
+ int lineIndex, /* Index of desired line (0 means first line
* of text). */
- int charIndex; /* Index of desired character. */
- TkTextIndex *indexPtr; /* Structure to fill in. */
+ int charIndex, /* Index of desired character. */
+ TkTextIndex *indexPtr) /* Structure to fill in. */
{
register TkTextSegment *segPtr;
char *p, *start, *end;
@@ -574,9 +571,9 @@ TkTextMakeCharIndex(tree, textPtr, lineIndex, charIndex, indexPtr)
*/
TkTextSegment *
-TkTextIndexToSeg(indexPtr, offsetPtr)
- CONST TkTextIndex *indexPtr;/* Text index. */
- int *offsetPtr; /* Where to store offset within segment, or
+TkTextIndexToSeg(
+ CONST TkTextIndex *indexPtr,/* Text index. */
+ int *offsetPtr) /* Where to store offset within segment, or
* NULL if offset isn't wanted. */
{
TkTextSegment *segPtr;
@@ -612,14 +609,13 @@ TkTextIndexToSeg(indexPtr, offsetPtr)
*/
int
-TkTextSegToOffset(segPtr, linePtr)
- CONST TkTextSegment *segPtr;/* Segment whose offset is desired. */
- CONST TkTextLine *linePtr; /* Line containing segPtr. */
+TkTextSegToOffset(
+ CONST TkTextSegment *segPtr,/* Segment whose offset is desired. */
+ CONST TkTextLine *linePtr) /* Line containing segPtr. */
{
CONST TkTextSegment *segPtr2;
- int offset;
+ int offset = 0;
- offset = 0;
for (segPtr2 = linePtr->segPtr; segPtr2 != segPtr;
segPtr2 = segPtr2->nextPtr) {
offset += segPtr2->size;
@@ -645,12 +641,12 @@ TkTextSegToOffset(segPtr, linePtr)
*/
int
-TkTextGetObjIndex(interp, textPtr, idxObj, indexPtr)
- Tcl_Interp *interp; /* Use this for error reporting. */
- TkText *textPtr; /* Information about text widget. */
- Tcl_Obj *idxObj; /* Object containing textual description of
+TkTextGetObjIndex(
+ Tcl_Interp *interp, /* Use this for error reporting. */
+ TkText *textPtr, /* Information about text widget. */
+ Tcl_Obj *idxObj, /* Object containing textual description of
* position. */
- TkTextIndex *indexPtr; /* Index structure to fill in. */
+ TkTextIndex *indexPtr) /* Index structure to fill in. */
{
return GetIndex(interp, NULL, textPtr, Tcl_GetString(idxObj), indexPtr,
NULL);
@@ -674,12 +670,12 @@ TkTextGetObjIndex(interp, textPtr, idxObj, indexPtr)
*/
int
-TkTextSharedGetObjIndex(interp, sharedTextPtr, idxObj, indexPtr)
- Tcl_Interp *interp; /* Use this for error reporting. */
- TkSharedText *sharedTextPtr;/* Information about text widget. */
- Tcl_Obj *idxObj; /* Object containing textual description of
+TkTextSharedGetObjIndex(
+ Tcl_Interp *interp, /* Use this for error reporting. */
+ TkSharedText *sharedTextPtr,/* Information about text widget. */
+ Tcl_Obj *idxObj, /* Object containing textual description of
* position. */
- TkTextIndex *indexPtr; /* Index structure to fill in. */
+ TkTextIndex *indexPtr) /* Index structure to fill in. */
{
return GetIndex(interp, sharedTextPtr, NULL, Tcl_GetString(idxObj),
indexPtr, NULL);
@@ -705,11 +701,11 @@ TkTextSharedGetObjIndex(interp, sharedTextPtr, idxObj, indexPtr)
*/
int
-TkTextGetIndex(interp, textPtr, string, indexPtr)
- Tcl_Interp *interp; /* Use this for error reporting. */
- TkText *textPtr; /* Information about text widget. */
- CONST char *string; /* Textual description of position. */
- TkTextIndex *indexPtr; /* Index structure to fill in. */
+TkTextGetIndex(
+ Tcl_Interp *interp, /* Use this for error reporting. */
+ TkText *textPtr, /* Information about text widget. */
+ CONST char *string, /* Textual description of position. */
+ TkTextIndex *indexPtr) /* Index structure to fill in. */
{
return GetIndex(interp, NULL, textPtr, string, indexPtr, NULL);
}
@@ -738,13 +734,13 @@ TkTextGetIndex(interp, textPtr, string, indexPtr)
*/
static int
-GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
- Tcl_Interp *interp; /* Use this for error reporting. */
- TkSharedText *sharedPtr;
- TkText *textPtr; /* Information about text widget. */
- CONST char *string; /* Textual description of position. */
- TkTextIndex *indexPtr; /* Index structure to fill in. */
- int *canCachePtr; /* Pointer to integer to store whether we can
+GetIndex(
+ Tcl_Interp *interp, /* Use this for error reporting. */
+ TkSharedText *sharedPtr,
+ TkText *textPtr, /* Information about text widget. */
+ CONST char *string, /* Textual description of position. */
+ TkTextIndex *indexPtr, /* Index structure to fill in. */
+ int *canCachePtr) /* Pointer to integer to store whether we can
* cache the index (or NULL). */
{
char *p, *end, *endOfBase;
@@ -948,7 +944,7 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
}
/*
- * See if the base position is the name of an embedded image
+ * See if the base position is the name of an embedded image.
*/
c = *endOfBase;
@@ -1026,10 +1022,10 @@ GetIndex(interp, sharedPtr, textPtr, string, indexPtr, canCachePtr)
*/
int
-TkTextPrintIndex(textPtr, indexPtr, string)
- CONST TkText *textPtr;
- CONST TkTextIndex *indexPtr;/* Pointer to index. */
- char *string; /* Place to store the position. Must have at
+TkTextPrintIndex(
+ CONST TkText *textPtr,
+ CONST TkTextIndex *indexPtr,/* Pointer to index. */
+ char *string) /* Place to store the position. Must have at
* least TK_POS_CHARS characters. */
{
TkTextSegment *segPtr;
@@ -1090,9 +1086,9 @@ TkTextPrintIndex(textPtr, indexPtr, string)
*/
int
-TkTextIndexCmp(index1Ptr, index2Ptr)
- CONST TkTextIndex *index1Ptr; /* First index. */
- CONST TkTextIndex *index2Ptr; /* Second index. */
+TkTextIndexCmp(
+ CONST TkTextIndex*index1Ptr,/* First index. */
+ CONST TkTextIndex*index2Ptr)/* Second index. */
{
int line1, line2;
@@ -1145,12 +1141,12 @@ TkTextIndexCmp(index1Ptr, index2Ptr)
*/
static CONST char *
-ForwBack(textPtr, string, indexPtr)
- TkText *textPtr; /* Information about text widget. */
- CONST char *string; /* String to parse for additional info about
+ForwBack(
+ TkText *textPtr, /* Information about text widget. */
+ CONST char *string, /* String to parse for additional info about
* modifier (count and units). Points to "+"
* or "-" that starts modifier. */
- TkTextIndex *indexPtr; /* Index to update as specified in string. */
+ TkTextIndex *indexPtr) /* Index to update as specified in string. */
{
register CONST char *p, *units;
char *end;
@@ -1188,8 +1184,8 @@ ForwBack(textPtr, string, indexPtr)
p++;
}
length = p - units;
- if ((*units == 'd') && (strncmp(units, "display",
- (length > 7 ? 7 : length)) == 0)) {
+ if ((*units == 'd') &&
+ (strncmp(units, "display", (length > 7 ? 7 : length)) == 0)) {
modifier = TKINDEX_DISPLAY;
if (length > 7) {
p -= (length - 7);
@@ -1313,7 +1309,7 @@ ForwBack(textPtr, string, indexPtr)
while (count-- > 0) {
/*
* Go to the beginning of the line, then backward one
- * char/byte to get to the end of the previous line
+ * char/byte to get to the end of the previous line.
*/
TkTextFindDisplayLineEnd(textPtr, indexPtr, 0, NULL);
@@ -1391,12 +1387,12 @@ ForwBack(textPtr, string, indexPtr)
*/
int
-TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
- CONST TkText *textPtr;
- CONST TkTextIndex *srcPtr; /* Source index. */
- int byteCount; /* How many bytes forward to move. May be
+TkTextIndexForwBytes(
+ CONST TkText *textPtr,
+ CONST TkTextIndex *srcPtr, /* Source index. */
+ int byteCount, /* How many bytes forward to move. May be
* negative. */
- TkTextIndex *dstPtr; /* Destination index: gets modified. */
+ TkTextIndex *dstPtr) /* Destination index: gets modified. */
{
TkTextLine *linePtr;
TkTextSegment *segPtr;
@@ -1463,13 +1459,13 @@ TkTextIndexForwBytes(textPtr, srcPtr, byteCount, dstPtr)
*/
void
-TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
- CONST TkText *textPtr; /* Overall information about text widget. */
- CONST TkTextIndex *srcPtr; /* Source index. */
- int charCount; /* How many characters forward to move. May
+TkTextIndexForwChars(
+ CONST TkText *textPtr, /* Overall information about text widget. */
+ CONST TkTextIndex *srcPtr, /* Source index. */
+ int charCount, /* How many characters forward to move. May
* be negative. */
- TkTextIndex *dstPtr; /* Destination index: gets modified. */
- TkTextCountType type; /* The type of item to count */
+ TkTextIndex *dstPtr, /* Destination index: gets modified. */
+ TkTextCountType type) /* The type of item to count */
{
TkTextLine *linePtr;
TkTextSegment *segPtr;
@@ -1485,7 +1481,8 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
return;
}
if (checkElided) {
- infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo));
+ infoPtr = (TkTextElideInfo *)
+ ckalloc((unsigned) sizeof(TkTextElideInfo));
elide = TkTextIsElided(textPtr, srcPtr, infoPtr);
}
@@ -1518,7 +1515,7 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
/*
* If we do need to pay attention to the visibility of
* characters/indices, check that first. If the current segment
- * isn't visible, then we simply continue the loop
+ * isn't visible, then we simply continue the loop.
*/
if (checkElided && ((segPtr->typePtr == &tkTextToggleOffType)
@@ -1613,7 +1610,7 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
forwardCharDone:
if (infoPtr != NULL) {
TkTextFreeElideInfo(infoPtr);
- ckfree((char*) infoPtr);
+ ckfree((char *) infoPtr);
}
}
@@ -1642,22 +1639,20 @@ TkTextIndexForwChars(textPtr, srcPtr, charCount, dstPtr, type)
*/
int
-TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
- CONST TkText *textPtr; /* Overall information about text widget. */
- CONST TkTextIndex *indexPtr1;
+TkTextIndexCount(
+ CONST TkText *textPtr, /* Overall information about text widget. */
+ CONST TkTextIndex *indexPtr1,
/* Index describing location of character from
* which to count. */
- CONST TkTextIndex *indexPtr2;
+ CONST TkTextIndex *indexPtr2,
/* Index describing location of last character
* at which to stop the count. */
- TkTextCountType type; /* The kind of indices to count. */
+ TkTextCountType type) /* The kind of indices to count. */
{
TkTextLine *linePtr1;
TkTextSegment *segPtr, *seg2Ptr = NULL;
TkTextElideInfo *infoPtr = NULL;
- int byteOffset, maxBytes;
- int count = 0;
- int elide = 0;
+ int byteOffset, maxBytes, count = 0, elide = 0;
int checkElided = (type & COUNT_DISPLAY);
/*
@@ -1671,7 +1666,8 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
seg2Ptr = TkTextIndexToSeg(indexPtr2, &maxBytes);
if (checkElided) {
- infoPtr = (TkTextElideInfo*)ckalloc((unsigned)sizeof(TkTextElideInfo));
+ infoPtr = (TkTextElideInfo *)
+ ckalloc((unsigned) sizeof(TkTextElideInfo));
elide = TkTextIsElided(textPtr, indexPtr1, infoPtr);
}
@@ -1811,7 +1807,7 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
countDone:
if (infoPtr != NULL) {
TkTextFreeElideInfo(infoPtr);
- ckfree((char*) infoPtr);
+ ckfree((char *) infoPtr);
}
return count;
}
@@ -1839,12 +1835,12 @@ TkTextIndexCount(textPtr, indexPtr1, indexPtr2, type)
*/
int
-TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
- CONST TkText *textPtr;
- CONST TkTextIndex *srcPtr; /* Source index. */
- int byteCount; /* How many bytes backward to move. May be
+TkTextIndexBackBytes(
+ CONST TkText *textPtr,
+ CONST TkTextIndex *srcPtr, /* Source index. */
+ int byteCount, /* How many bytes backward to move. May be
* negative. */
- TkTextIndex *dstPtr; /* Destination index: gets modified. */
+ TkTextIndex *dstPtr) /* Destination index: gets modified. */
{
TkTextSegment *segPtr;
int lineIndex;
@@ -1909,13 +1905,13 @@ TkTextIndexBackBytes(textPtr, srcPtr, byteCount, dstPtr)
*/
void
-TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
- CONST TkText *textPtr; /* Overall information about text widget. */
- CONST TkTextIndex *srcPtr; /* Source index. */
- int charCount; /* How many characters backward to move. May
+TkTextIndexBackChars(
+ CONST TkText *textPtr, /* Overall information about text widget. */
+ CONST TkTextIndex *srcPtr, /* Source index. */
+ int charCount, /* How many characters backward to move. May
* be negative. */
- TkTextIndex *dstPtr; /* Destination index: gets modified. */
- TkTextCountType type; /* The type of item to count */
+ TkTextIndex *dstPtr, /* Destination index: gets modified. */
+ TkTextCountType type) /* The type of item to count */
{
TkTextSegment *segPtr, *oldPtr;
TkTextElideInfo *infoPtr = NULL;
@@ -1967,7 +1963,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
}
/*
- * Now segPtr points to the segment containing the starting index
+ * Now segPtr points to the segment containing the starting index.
*/
while (1) {
@@ -2095,7 +2091,7 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
backwardCharDone:
if (infoPtr != NULL) {
TkTextFreeElideInfo(infoPtr);
- ckfree((char*) infoPtr);
+ ckfree((char *) infoPtr);
}
}
@@ -2120,12 +2116,12 @@ TkTextIndexBackChars(textPtr, srcPtr, charCount, dstPtr, type)
*/
static CONST char *
-StartEnd(textPtr, string, indexPtr)
- TkText *textPtr; /* Information about text widget. */
- CONST char *string; /* String to parse for additional info about
+StartEnd(
+ TkText *textPtr, /* Information about text widget. */
+ CONST char *string, /* String to parse for additional info about
* modifier (count and units). Points to first
* character of modifer word. */
- TkTextIndex *indexPtr; /* Index to modify based on string. */
+ TkTextIndex *indexPtr) /* Index to modify based on string. */
{
CONST char *p;
size_t length;
@@ -2274,7 +2270,6 @@ StartEnd(textPtr, string, indexPtr)
segPtr->body.chars));
}
firstChar = 0;
- } else {
}
offset -= chSize;
indexPtr->byteIndex -= chSize;
@@ -2303,3 +2298,11 @@ StartEnd(textPtr, string, indexPtr)
done:
return p;
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */
diff --git a/generic/tkTextMark.c b/generic/tkTextMark.c
index e386c0a..d1b5b87 100644
--- a/generic/tkTextMark.c
+++ b/generic/tkTextMark.c
@@ -10,7 +10,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextMark.c,v 1.17 2007/01/18 23:20:37 nijtmans Exp $
+ * RCS: @(#) $Id: tkTextMark.c,v 1.18 2007/02/22 13:56:33 dkf Exp $
*/
#include "tkInt.h"
@@ -47,10 +47,9 @@ static int MarkFindPrev(Tcl_Interp *interp,
/*
- * The following structures declare the "mark" segment types.
- * There are actually two types for marks, one with left gravity
- * and one with right gravity. They are identical except for
- * their gravity property.
+ * The following structures declare the "mark" segment types. There are
+ * actually two types for marks, one with left gravity and one with right
+ * gravity. They are identical except for their gravity property.
*/
const Tk_SegType tkTextRightMarkType = {
@@ -107,16 +106,13 @@ TkTextMarkCmd(
Tcl_HashSearch search;
TkTextIndex index;
const Tk_SegType *newTypePtr;
-
int optionIndex;
-
static const char *markOptionStrings[] = {
- "gravity", "names", "next", "previous", "set",
- "unset", NULL
+ "gravity", "names", "next", "previous", "set", "unset", NULL
};
enum markOptions {
- MARK_GRAVITY, MARK_NAMES, MARK_NEXT, MARK_PREVIOUS,
- MARK_SET, MARK_UNSET
+ MARK_GRAVITY, MARK_NAMES, MARK_NEXT, MARK_PREVIOUS, MARK_SET,
+ MARK_UNSET
};
if (objc < 3) {
@@ -128,7 +124,7 @@ TkTextMarkCmd(
return TCL_ERROR;
}
- switch ((enum markOptions)optionIndex) {
+ switch ((enum markOptions) optionIndex) {
case MARK_GRAVITY: {
char c;
int length;
@@ -267,8 +263,7 @@ TkTextSetMark(
Tcl_HashEntry *hPtr = NULL;
TkTextSegment *markPtr;
TkTextIndex insertIndex;
- int isNew;
- int widgetSpecific;
+ int isNew, widgetSpecific;
if (!strcmp(name, "insert")) {
widgetSpecific = 1;
@@ -506,7 +501,6 @@ MarkCleanupProc(
*--------------------------------------------------------------
*/
- /*ARGSUSED*/
static int
MarkLayoutProc(
TkText *textPtr, /* Text widget being layed out. */
diff --git a/generic/tkTextTag.c b/generic/tkTextTag.c
index 32fa3d8..c3552c8 100644
--- a/generic/tkTextTag.c
+++ b/generic/tkTextTag.c
@@ -11,7 +11,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextTag.c,v 1.24 2007/01/03 05:06:27 nijtmans Exp $
+ * RCS: @(#) $Id: tkTextTag.c,v 1.25 2007/02/22 13:56:33 dkf Exp $
*/
#include "default.h"
@@ -31,10 +31,10 @@ static char *wrapStrings[] = {
};
/*
- * The 'TkTextTabStyle' enum in tkText.h is used to define a type for
- * the -tabstyle option of the Text widget. These values are used as
- * indices into the string table below. Tags are allowed an empty wrap
- * value, but the widget as a whole is not.
+ * The 'TkTextTabStyle' enum in tkText.h is used to define a type for the
+ * -tabstyle option of the Text widget. These values are used as indices into
+ * the string table below. Tags are allowed an empty wrap value, but the
+ * widget as a whole is not.
*/
static char *tabStyleStrings[] = {
@@ -133,20 +133,16 @@ TkTextTagCmd(
* parsed this command enough to know that
* objv[1] is "tag". */
{
- int optionIndex;
-
static CONST char *tagOptionStrings[] = {
- "add", "bind", "cget", "configure", "delete", "lower",
- "names", "nextrange", "prevrange", "raise", "ranges",
- "remove", NULL
+ "add", "bind", "cget", "configure", "delete", "lower", "names",
+ "nextrange", "prevrange", "raise", "ranges", "remove", NULL
};
enum tagOptions {
- TAG_ADD, TAG_BIND, TAG_CGET, TAG_CONFIGURE, TAG_DELETE,
- TAG_LOWER, TAG_NAMES, TAG_NEXTRANGE, TAG_PREVRANGE,
- TAG_RAISE, TAG_RANGES, TAG_REMOVE
+ TAG_ADD, TAG_BIND, TAG_CGET, TAG_CONFIGURE, TAG_DELETE, TAG_LOWER,
+ TAG_NAMES, TAG_NEXTRANGE, TAG_PREVRANGE, TAG_RAISE, TAG_RANGES,
+ TAG_REMOVE
};
-
- int i;
+ int optionIndex, i;
register TkTextTag *tagPtr;
TkTextIndex index1, index2;
@@ -306,9 +302,8 @@ TkTextTagCmd(
if (string[0] != '\0') {
return TCL_ERROR;
- } else {
- Tcl_ResetResult(interp);
}
+ Tcl_ResetResult(interp);
} else {
Tcl_SetResult(interp, (char *) command, TCL_STATIC);
}
@@ -332,10 +327,9 @@ TkTextTagCmd(
tagPtr->optionTable, objv[4], textPtr->tkwin);
if (objPtr == NULL) {
return TCL_ERROR;
- } else {
- Tcl_SetObjResult(interp, objPtr);
- return TCL_OK;
}
+ Tcl_SetObjResult(interp, objPtr);
+ return TCL_OK;
}
break;
case TAG_CONFIGURE: {
@@ -354,10 +348,9 @@ TkTextTagCmd(
if (objPtr == NULL) {
return TCL_ERROR;
- } else {
- Tcl_SetObjResult(interp, objPtr);
- return TCL_OK;
}
+ Tcl_SetObjResult(interp, objPtr);
+ return TCL_OK;
} else {
int result = TCL_OK;
@@ -594,8 +587,7 @@ TkTextTagCmd(
* for all peers.
*/
- TkTextRedrawTag(textPtr->sharedTextPtr, NULL, NULL,
- NULL, tagPtr, 1);
+ TkTextRedrawTag(textPtr->sharedTextPtr, NULL, NULL, NULL, tagPtr, 1);
break;
}
case TAG_NAMES: {
@@ -866,8 +858,7 @@ TkTextTagCmd(
* for all peers.
*/
- TkTextRedrawTag(textPtr->sharedTextPtr, NULL, NULL,
- NULL, tagPtr, 1);
+ TkTextRedrawTag(textPtr->sharedTextPtr, NULL, NULL, NULL, tagPtr, 1);
break;
}
case TAG_RANGES: {
@@ -953,10 +944,9 @@ TkTextCreateTag(
*newTag = 0;
}
return textPtr->selTagPtr;
- } else {
- if (newTag != NULL) {
- *newTag = 1;
- }
+ }
+ if (newTag != NULL) {
+ *newTag = 1;
}
name = "sel";
} else {
@@ -1138,8 +1128,7 @@ TkTextDeleteTag(
* Update the tag priorities to reflect the deletion of this tag.
*/
- ChangeTagPriority(textPtr, tagPtr,
- textPtr->sharedTextPtr->numTags-1);
+ ChangeTagPriority(textPtr, tagPtr, textPtr->sharedTextPtr->numTags-1);
textPtr->sharedTextPtr->numTags -= 1;
TkTextFreeTag(textPtr, tagPtr);
}
@@ -1265,8 +1254,7 @@ SortTags(
*tagArrayPtr = tmp;
}
} else {
- qsort((VOID *) tagArrayPtr, (unsigned) numTags, sizeof (TkTextTag *),
- TagSortProc);
+ qsort(tagArrayPtr,(unsigned)numTags,sizeof(TkTextTag *),TagSortProc);
}
}
@@ -1341,7 +1329,8 @@ ChangeTagPriority(
}
if (prio == tagPtr->priority) {
return;
- } else if (prio < tagPtr->priority) {
+ }
+ if (prio < tagPtr->priority) {
low = prio;
high = tagPtr->priority-1;
delta = 1;
@@ -1605,7 +1594,7 @@ TkTextPickCurrent(
if (numNewTags > 0) {
size = numNewTags * sizeof(TkTextTag *);
copyArrayPtr = (TkTextTag **) ckalloc((unsigned) size);
- memcpy((VOID *) copyArrayPtr, (VOID *) newArrayPtr, (size_t) size);
+ memcpy(copyArrayPtr, newArrayPtr, (size_t) size);
for (i = 0; i < textPtr->numCurTags; i++) {
for (j = 0; j < numNewTags; j++) {
if (textPtr->curTagArrayPtr[i] == copyArrayPtr[j]) {
@@ -1708,7 +1697,7 @@ TagBindEvent(
*/
if (numTags > NUM_BIND_TAGS) {
- nameArrPtr = (CONST char**) ckalloc (numTags * sizeof(CONST char*));
+ nameArrPtr = (CONST char **) ckalloc(numTags * sizeof(CONST char *));
} else {
nameArrPtr = nameArray;
}
@@ -1737,7 +1726,7 @@ TagBindEvent(
textPtr->tkwin, numTags, (ClientData *) nameArrPtr);
if (numTags > NUM_BIND_TAGS) {
- ckfree((char*)nameArrPtr);
+ ckfree((char *) nameArrPtr);
}
}
diff --git a/generic/tkTextWind.c b/generic/tkTextWind.c
index b85852a..62d8b72 100644
--- a/generic/tkTextWind.c
+++ b/generic/tkTextWind.c
@@ -11,7 +11,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tkTextWind.c,v 1.20 2007/01/18 23:20:37 nijtmans Exp $
+ * RCS: @(#) $Id: tkTextWind.c,v 1.21 2007/02/22 13:56:33 dkf Exp $
*/
#include "tk.h"
@@ -50,10 +50,9 @@ static TkTextSegment * EmbWinCleanupProc(TkTextSegment *segPtr,
static void EmbWinCheckProc(TkTextSegment *segPtr,
TkTextLine *linePtr);
static void EmbWinBboxProc(TkText *textPtr,
- TkTextDispChunk *chunkPtr,
- int index, int y, int lineHeight, int baseline,
- int *xPtr, int *yPtr, int *widthPtr,
- int *heightPtr);
+ TkTextDispChunk *chunkPtr, int index, int y,
+ int lineHeight, int baseline, int *xPtr,int *yPtr,
+ int *widthPtr, int *heightPtr);
static int EmbWinConfigure(TkText *textPtr, TkTextSegment *ewPtr,
int objc, Tcl_Obj *const objv[]);
static void EmbWinDelayedUnmap(ClientData clientData);
@@ -61,9 +60,8 @@ static int EmbWinDeleteProc(TkTextSegment *segPtr,
TkTextLine *linePtr, int treeGone);
static int EmbWinLayoutProc(TkText *textPtr,
TkTextIndex *indexPtr, TkTextSegment *segPtr,
- int offset, int maxX, int maxChars,
- int noCharsYet, TkWrapMode wrapMode,
- TkTextDispChunk *chunkPtr);
+ int offset, int maxX, int maxChars,int noCharsYet,
+ TkWrapMode wrapMode, TkTextDispChunk *chunkPtr);
static void EmbWinStructureProc(ClientData clientData,
XEvent *eventPtr);
static void EmbWinUndisplayProc(TkText *textPtr,
@@ -146,14 +144,12 @@ TkTextWindowCmd(
* objv[1] is "window". */
{
int optionIndex;
-
static const char *windOptionStrings[] = {
"cget", "configure", "create", "names", NULL
};
enum windOptions {
WIND_CGET, WIND_CONFIGURE, WIND_CREATE, WIND_NAMES
};
-
register TkTextSegment *ewPtr;
if (objc < 3) {
@@ -164,7 +160,7 @@ TkTextWindowCmd(
"window option", 0, &optionIndex) != TCL_OK) {
return TCL_ERROR;
}
- switch ((enum windOptions)optionIndex) {
+ switch ((enum windOptions) optionIndex) {
case WIND_CGET: {
TkTextIndex index;
TkTextSegment *ewPtr;
@@ -648,7 +644,7 @@ EmbWinLostSlaveProc(
}
loop->next = client->next;
}
- ckfree((char *)client);
+ ckfree((char *) client);
index.tree = ewPtr->body.ew.sharedTextPtr->tree;
index.linePtr = ewPtr->body.ew.linePtr;
@@ -765,7 +761,7 @@ EmbWinDeleteProc(
NULL);
/*
- * Free up all memory allocated
+ * Free up all memory allocated.
*/
ckfree((char *) ewPtr);
@@ -853,13 +849,10 @@ EmbWinLayoutProc(
if ((ewPtr->body.ew.tkwin == NULL) && (ewPtr->body.ew.create != NULL)) {
int code, isNew;
- Tcl_DString name;
Tk_Window ancestor;
Tcl_HashEntry *hPtr;
- const char *before;
- const char *string;
- Tcl_DString buf;
- Tcl_DString *dsPtr = NULL;
+ const char *before, *string;
+ Tcl_DString name, buf, *dsPtr = NULL;
before = ewPtr->body.ew.create;
@@ -1130,7 +1123,7 @@ TkTextEmbWinDisplayProc(
*/
EmbWinBboxProc(textPtr, chunkPtr, 0, screenY, lineHeight, baseline,
- &lineX, &windowY, &width, &height);
+ &lineX, &windowY, &width, &height);
windowX = lineX - chunkPtr->x + x;
if (textPtr->tkwin == Tk_Parent(tkwin)) {
@@ -1141,8 +1134,8 @@ TkTextEmbWinDisplayProc(
}
Tk_MapWindow(tkwin);
} else {
- Tk_MaintainGeometry(tkwin, textPtr->tkwin,
- windowX, windowY, width, height);
+ Tk_MaintainGeometry(tkwin, textPtr->tkwin, windowX, windowY,
+ width, height);
}
/*
@@ -1178,7 +1171,9 @@ EmbWinUndisplayProc(
TkTextSegment *ewPtr = (TkTextSegment*) chunkPtr->clientData;
TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr);
- if (client == NULL) return;
+ if (client == NULL) {
+ return;
+ }
client->chunkCount--;
if (client->chunkCount == 0) {
@@ -1236,7 +1231,7 @@ EmbWinBboxProc(
* pixels. */
{
Tk_Window tkwin;
- TkTextSegment *ewPtr = (TkTextSegment*) chunkPtr->clientData;
+ TkTextSegment *ewPtr = (TkTextSegment *) chunkPtr->clientData;
TkTextEmbWindowClient *client = EmbWinGetClient(textPtr, ewPtr);
if (client == NULL) {
@@ -1379,6 +1374,7 @@ EmbWinGetClient(
TkTextSegment *ewPtr) /* Segment containing embedded window. */
{
TkTextEmbWindowClient *client = ewPtr->body.ew.clients;
+
while (client != NULL) {
if (client->textPtr == textPtr) {
return client;