| blob | 928bf832cc47eb88fd0dbba59313aa68757bc239 |
2 /*******************************************************************************
3 * *
4 * textDisp.c - Display text from a text buffer *
5 * *
6 * Copyright (C) 1999 Mark Edel *
7 * *
8 * This is free software; you can redistribute it and/or modify it under the *
9 * terms of the GNU General Public License as published by the Free Software *
10 * Foundation; either version 2 of the License, or (at your option) any later *
11 * version. In addition, you may distribute version of this program linked to *
12 * Motif or Open Motif. See README for details. *
13 * *
14 * This software is distributed in the hope that it will be useful, but WITHOUT *
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. *
18 * *
19 * You should have received a copy of the GNU General Public License along with *
20 * software; if not, write to the Free Software Foundation, Inc., 59 Temple *
21 * Place, Suite 330, Boston, MA 02111-1307 USA *
22 * *
23 * Nirvana Text Editor *
24 * June 15, 1995 *
25 * *
26 * Written by Mark Edel *
27 * *
28 *******************************************************************************/
30 #ifdef HAVE_CONFIG_H
32 #endif
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <limits.h>
47 #ifdef VMS
49 #else
50 #ifndef __MVS__
51 #include <sys/param.h>
52 #endif
55 #include <Xm/Xm.h>
56 #include <Xm/ScrolledW.h>
57 #include <Xm/ScrollBar.h>
58 #include <Xm/Label.h>
59 #include <X11/Shell.h>
61 #ifdef HAVE_DEBUG_H
63 #endif
65 /* Masks for text drawing methods. These are or'd together to form an
66 integer which describes what drawing calls to use to draw a string */
67 #define FILL_SHIFT 8
68 #define SECONDARY_SHIFT 9
69 #define PRIMARY_SHIFT 10
70 #define HIGHLIGHT_SHIFT 11
71 #define STYLE_LOOKUP_SHIFT 0
72 #define BACKLIGHT_SHIFT 12
74 #define FILL_MASK (1 << FILL_SHIFT)
75 #define SECONDARY_MASK (1 << SECONDARY_SHIFT)
76 #define PRIMARY_MASK (1 << PRIMARY_SHIFT)
77 #define HIGHLIGHT_MASK (1 << HIGHLIGHT_SHIFT)
78 #define STYLE_LOOKUP_MASK (0xff << STYLE_LOOKUP_SHIFT)
79 #define BACKLIGHT_MASK (0xff << BACKLIGHT_SHIFT)
81 #define RANGESET_SHIFT (20)
82 #define RANGESET_MASK (0x3F << RANGESET_SHIFT)
84 /* If you use both 32-Bit Style mask layout:
85 Bits +----------------+----------------+----------------+----------------+
86 hex |1F1E1D1C1B1A1918|1716151413121110| F E D C B A 9 8| 7 6 5 4 3 2 1 0|
87 dec |3130292827262524|2322212019181716|151413121110 9 8| 7 6 5 4 3 2 1 0|
88 +----------------+----------------+----------------+----------------+
89 Type | r r| r r r r b b b b| b b b b H 1 2 F| s s s s s s s s|
90 +----------------+----------------+----------------+----------------+
91 where: s - style lookup value (8 bits)
92 F - fill (1 bit)
93 2 - secondary selection (1 bit)
94 1 - primary selection (1 bit)
95 H - highlight (1 bit)
96 b - backlighting index (8 bits)
97 r - rangeset index (6 bits)
98 This leaves 6 "unused" bits */
100 /* Maximum displayable line length (how many characters will fit across the
101 widest window). This amount of memory is temporarily allocated from the
102 stack in the redisplayLine routine for drawing strings */
103 #define MAX_DISP_LINE_LEN 1000
105 /* Macro for getting the TextPart from a textD */
106 #define TEXT_OF_TEXTD(t) (((TextWidget)((t)->w))->text)
191 {
193 XGCValues gcValues;
266 /* Attach an event handler to the widget so we can know the visibility
267 (used for choosing the fastest drawing method) */
271 /* Attach the callback to the text buffer for receiving modification
272 information */
276 }
278 /* Initialize the scroll bars and attach movement callbacks */
285 }
293 }
295 /* Update the display to reflect the contents of the buffer */
299 /* Decide if the horizontal scroll bar needs to be visible */
303 }
305 /*
306 ** Free a text display and release its associated memory. Note, the text
307 ** BUFFER that the text display displays is a separate entity and is not
308 ** freed, nor are the style buffer or style table.
309 */
311 {
323 }
327 }
329 /*
330 ** Attach a text buffer to display, replacing the current buffer (if any)
331 */
333 {
334 /* If the text display is already displaying a buffer, clear it off
335 of the display and remove our callback from it */
340 }
342 /* Add the buffer to the display, and attach a callback to the buffer for
343 receiving modification information when the buffer contents change */
348 /* Update the display */
350 }
352 /*
353 ** Attach (or remove) highlight information in text display and redisplay.
354 ** Highlighting information consists of a style buffer which parallels the
355 ** normal text buffer, but codes font and color information for the display;
356 ** a style table which translates style buffer codes (indexed by buffer
357 ** character - 65 (ASCII code for 'A')) into fonts and colors; and a callback
358 ** mechanism for as-needed highlighting, triggered by a style buffer entry of
359 ** "unfinishedStyle". Style buffer can trigger additional redisplay during
360 ** a normal buffer modification if the buffer contains a primary selection
361 ** (see extendRangeForStyleMods for more information on this protocol).
362 **
363 ** Style buffers, tables and their associated memory are managed by the caller.
364 */
368 {
376 /* Call TextDSetFont to combine font information from style table and
377 primary font, adjust font-related parameters, and then redisplay */
379 }
382 /* Change the (non syntax-highlit) colors */
386 {
387 XGCValues values;
390 /* Update the stored pixels */
409 /* Change the cursor GC (the cursor GC is not shared). */
413 /* Redisplay */
417 }
419 /*
420 ** Change the (non highlight) font
421 */
423 {
429 XGCValues values;
432 /* If font size changes, cursor will be redrawn in a new position */
435 /* If there is a (syntax highlighting) style table in use, find the new
436 maximum font height for this text display */
443 }
447 /* If all of the current fonts are fixed and match in width, compute */
458 }
459 }
462 /* Don't let the height dip below one line, or bad things can happen */
466 /* Change the font. In most cases, this means re-allocating the
467 affected GCs (they are shared with other widgets, and if the primary
468 font changes, must be re-allocated to change it). Unfortunately,
469 this requres recovering all of the colors from the existing GCs */
492 /* Do a full resize to force recalculation of font related parameters */
498 /* if the shell window doesn't get resized, and the new fonts are
499 of smaller sizes, sometime we get some residual text on the
500 blank space at the bottom part of text area. Clear it here. */
505 /* Redisplay */
509 /* Clean up line number area in case spacing has changed */
511 }
514 {
523 }
524 }
525 }
527 }
530 {
539 }
540 }
541 }
543 }
545 /*
546 ** Change the size of the displayed text area
547 */
549 {
560 /* In continuous wrap mode, a change in width affects the total number of
561 lines in the buffer, and can leave the top line number incorrect, and
562 the top character no longer pointing at a valid line start */
566 True);
571 }
573 /* reallocate and update the line starts array, which may have changed
574 size and/or contents. (contents can change in continuous wrap mode
575 when the width changes, even without a change in height) */
579 }
584 /* if the window became shorter, there may be partially drawn
585 text left at the bottom edge, which must be cleaned up */
591 /* if the window became taller, there may be an opportunity to display
592 more text by scrolling down */
599 /* Update the scroll bar page increment size (as well as other scroll
600 bar parameters. If updating the horizontal range caused scrolling,
601 redraw */
606 /* If a full redraw is needed */
611 /* Decide if the horizontal scroll bar needs to be visible */
614 /* Refresh the line number display to draw more line numbers, or
615 erase extras */
618 /* Redraw the calltip */
620 }
622 /*
623 ** Refresh a rectangle of the text display. left and top are in coordinates of
624 ** the text drawing window
625 */
628 {
631 /* find the line number range of the display */
636 /* If the graphics contexts are shared using XtAllocateGC, their
637 clipping rectangles may have changed since the last use */
640 /* draw the lines of text */
644 /* draw the line numbers if exposed area includes them */
647 }
649 /*
650 ** Refresh all of the text between buffer positions "start" and "end"
651 ** not including the character at the position "end".
652 ** If end points beyond the end of the buffer, refresh the whole display
653 ** after pos, including blank lines which are not technically part of
654 ** any range of characters.
655 */
657 {
660 /* If the range is outside of the displayed text, just return */
665 /* Clean up the starting and ending values */
671 /* Get the starting and ending lines */
674 }
678 }
684 /* shouldn't happen */
686 }
687 }
689 /* Get the starting and ending positions within the lines */
694 {
695 /* Request to redisplay beyond textD->lastChar, so tell
696 redisplayLine() to display everything to infy. */
699 {
700 /* Here, lastLine is determined by posToVisibleLineNum() (see
701 if/else above) but deemed to be out of display according to
702 textD->lineStarts. */
705 {
707 }
709 /* Reset the clipping rectangles for the drawing GCs which are shared
710 using XtAllocateGC, and may have changed since the last use */
713 /* If the starting and ending lines are the same, redisplay the single
714 line between "start" and "end" */
718 }
720 /* Redisplay the first line from "start" */
723 /* Redisplay the lines in between at their full width */
727 /* Redisplay the last line to "end" */
729 }
731 /*
732 ** Set the scroll position of the text display vertically by line number and
733 ** horizontally by pixel offset from the left margin
734 */
736 {
740 /* Limit the requested scroll position to allowable values */
745 vPadding)))
756 }
758 /*
759 ** Get the current scroll position for the text display, in terms of line
760 ** number of the top line and horizontal pixel offset from the left margin
761 */
763 {
766 }
768 /*
769 ** Set the position of the text insertion cursor for text display "textD"
770 */
772 {
773 /* make sure new position is ok, do nothing if it hasn't changed */
779 /* cursor movement cancels vertical cursor motion column */
782 /* erase the cursor at it's previous position */
785 /* draw it at its new position */
789 }
792 {
799 }
802 {
806 }
807 }
810 {
815 }
816 }
819 {
823 /* wrapping can change change the total number of lines, re-count */
826 /* changing wrap margins wrap or changing from wrapped mode to non-wrapped
827 can leave the character at the top no longer at a line start, and/or
828 change the line number */
833 /* update the line starts array */
837 /* Update the scroll bar page increment size (as well as other scroll
838 bar parameters) */
842 /* Decide if the horizontal scroll bar needs to be visible */
845 /* Do a full redraw */
848 }
851 {
853 }
855 /*
856 ** Insert "text" at the current cursor location. This has the same
857 ** effect as inserting the text into the buffer using BufInsert and
858 ** then moving the insert position after the newly inserted text, except
859 ** that it's optimized to do less redrawing.
860 */
862 {
868 }
870 /*
871 ** Insert "text" (which must not contain newlines), overstriking the current
872 ** cursor location.
873 */
875 {
883 /* determine how many displayed character positions are covered */
890 /* find which characters to remove, and if necessary generate additional
891 padding to make up for removed control characters at the end */
901 p++;
905 p++;
911 }
913 }
914 }
921 }
923 /*
924 ** Translate window coordinates to the nearest text cursor position.
925 */
927 {
929 }
931 /*
932 ** Translate window coordinates to the nearest character cell.
933 */
935 {
937 }
939 /*
940 ** Translate window coordinates to the nearest row and column number for
941 ** positioning the cursor. This, of course, makes no sense when the font
942 ** is proportional, since there are no absolute columns.
943 */
946 {
948 }
950 /*
951 ** Translate line and column to the nearest row and column number for
952 ** positioning the cursor. This, of course, makes no sense when the font
953 ** is proportional, since there are no absolute columns.
954 */
956 {
961 /* Count lines */
968 }
970 /* If line is beyond end of buffer, position at last character in buffer */
973 }
975 /* Start character index at zero */
978 /* Only have to count columns if column isn't zero (or negative) */
980 /* Count columns, expanding each character */
989 }
991 /* If the column is in the middle of an expanded character, put cursor
992 * in front of character if in first half of character, and behind
993 * character if in last half of character
994 */
996 charIndex++;
998 /* If we are beyond the end of the line, back up one space */
1000 }
1002 /* Position is the start of the line plus the index into line buffer */
1004 }
1006 /*
1007 ** Translate a buffer text position to the XY location where the center
1008 ** of the cursor would be positioned to point to that character. Returns
1009 ** False if the position is not displayed because it is VERTICALLY out
1010 ** of view. If the position is horizontally out of view, returns the
1011 ** x coordinate where the position would be if it were visible.
1012 */
1014 {
1019 /* If position is not displayed, return false */
1024 /* Calculate y coordinate */
1030 /* Get the text, length, and buffer position of the line. If the position
1031 is beyond the end of the buffer and should be at the first position on
1032 the first empty line, don't try to get or scan the text */
1037 }
1041 /* Step through character positions from the beginning of the line
1042 to "pos" to calculate the x coordinate */
1052 }
1056 }
1058 /*
1059 ** If the text widget is maintaining a line number count appropriate to "pos"
1060 ** return the line and column numbers of pos, otherwise return False. If
1061 ** continuous wrap mode is on, returns the absolute line number (as opposed to
1062 ** the wrapped line number which is used for scrolling). THIS ROUTINE ONLY
1063 ** WORKS FOR DISPLAYED LINES AND, IN CONTINUOUS WRAP MODE, ONLY WHEN THE
1064 ** ABSOLUTE LINE NUMBER IS BEING MAINTAINED. Otherwise, it returns False.
1065 */
1067 {
1070 /* In continuous wrap mode, the absolute (non-wrapped) line count is
1071 maintained separately, as needed. Only return it if we're actually
1072 keeping track of it and pos is in the displayed text */
1081 }
1083 /* Only return the data if pos is within the displayed text */
1089 }
1091 /*
1092 ** Return True if position (x, y) is inside of the primary selection
1093 */
1095 {
1103 }
1105 /*
1106 ** Correct a column number based on an unconstrained position (as returned by
1107 ** TextDXYToUnconstrainedPosition) to be relative to the last actual newline
1108 ** in the buffer before the row and column position given, rather than the
1109 ** last line start created by line wrapping. This is an adapter
1110 ** for rectangular selections and code written before continuous wrap mode,
1111 ** which thinks that the unconstrained column is the number of characters
1112 ** from the last newline. Obviously this is time consuming, because it
1113 ** invloves character re-counting.
1114 */
1116 {
1126 }
1128 /*
1129 ** Correct a row number from an unconstrained position (as returned by
1130 ** TextDXYToUnconstrainedPosition) to a straight number of newlines from the
1131 ** top line of the display. Because rectangular selections are based on
1132 ** newlines, rather than display wrapping, and anywhere a rectangular selection
1133 ** needs a row, it needs it in terms of un-wrapped lines.
1134 */
1136 {
1141 }
1143 /*
1144 ** Scroll the display to bring insertion cursor into view.
1145 **
1146 ** Note: it would be nice to be able to do this without counting lines twice
1147 ** (setScroll counts them too) and/or to count from the most efficient
1148 ** starting point, but the efficiency of this routine is not as important to
1149 ** the overall performance of the text display.
1150 */
1152 {
1161 /* Don't do padding if this is a mouse operation */
1165 /* Find the new top line number */
1168 /* linesFromTop = 0; */
1176 topLine++;
1179 /* Avoid extra counting if cursorVPadding is disabled */
1183 }
1187 }
1190 /* Keep the cursor away from the top or bottom of screen. */
1199 }
1200 }
1202 /* Find the new setting for horizontal offset (this is a bit ungraceful).
1203 If the line is visible, just use TextDPositionToXY to get the position
1204 to scroll to, otherwise, do the vertical scrolling first, then the
1205 horizontal */
1210 }
1216 /* Do the scroll */
1218 }
1220 /*
1221 ** Return the current preferred column along with the current
1222 ** visible line index (-1 if not visible) and the lineStartPos
1223 ** of the current insert position.
1224 */
1226 {
1229 /* Find the position of the start of the line. Use the line starts array
1230 if possible, to avoid unbounded line-counting in continuous wrap mode */
1233 }
1237 }
1239 /* Decide what column to move to, if there's a preferred column use that */
1244 }
1246 /*
1247 ** Return the insert position of the requested column given
1248 ** the lineStartPos.
1249 */
1251 {
1257 }
1259 }
1261 /*
1262 ** Cursor movement functions
1263 */
1265 {
1270 }
1273 {
1278 }
1281 {
1284 /* Find the position of the start of the line. Use the line starts array
1285 if possible, to avoid unbounded line-counting in continuous wrap mode */
1294 }
1298 /* Decide what column to move to, if there's a preferred column use that */
1303 /* count forward from the start of the previous line to reach the column */
1310 }
1316 /* move the cursor */
1319 /* if a preferred column wasn't aleady established, establish it */
1323 }
1326 {
1331 }
1341 }
1349 else
1356 }
1362 }
1364 /*
1365 ** Same as BufCountLines, but takes in to account wrapping if wrapping is
1366 ** turned on. If the caller knows that startPos is at a line start, it
1367 ** can pass "startPosIsLineStart" as True to make the call more efficient
1368 ** by avoiding the additional step of scanning back to the last newline.
1369 */
1372 {
1375 /* If we're not wrapping use simple (and more efficient) BufCountLines */
1383 }
1385 /*
1386 ** Same as BufCountForwardNLines, but takes in to account line breaks when
1387 ** wrapping is turned on. If the caller knows that startPos is at a line start,
1388 ** it can pass "startPosIsLineStart" as True to make the call more efficient
1389 ** by avoiding the additional step of scanning back to the last newline.
1390 */
1393 {
1396 /* if we're not wrapping use more efficient BufCountForwardNLines */
1400 /* wrappedLineCounter can't handle the 0 lines case */
1404 /* use the common line counting routine to count forward */
1409 }
1411 /*
1412 ** Same as BufEndOfLine, but takes in to account line breaks when wrapping
1413 ** is turned on. If the caller knows that startPos is at a line start, it
1414 ** can pass "startPosIsLineStart" as True to make the call more efficient
1415 ** by avoiding the additional step of scanning back to the last newline.
1416 **
1417 ** Note that the definition of the end of a line is less clear when continuous
1418 ** wrap is on. With continuous wrap off, it's just a pointer to the newline
1419 ** that ends the line. When it's on, it's the character beyond the last
1420 ** DISPLAYABLE character on the line, where a whitespace character which has
1421 ** been "converted" to a newline for wrapping is not considered displayable.
1422 ** Also note that, a line can be wrapped at a non-whitespace character if the
1423 ** line had no whitespace. In this case, this routine returns a pointer to
1424 ** the start of the next line. This is also consistent with the model used by
1425 ** visLineLength.
1426 */
1429 {
1432 /* If we're not wrapping use more efficient BufEndOfLine */
1442 }
1444 /*
1445 ** Same as BufStartOfLine, but returns the character after last wrap point
1446 ** rather than the last newline.
1447 */
1449 {
1452 /* If we're not wrapping, use the more efficient BufStartOfLine */
1460 }
1462 /*
1463 ** Same as BufCountBackwardNLines, but takes in to account line breaks when
1464 ** wrapping is turned on.
1465 */
1467 {
1471 /* If we're not wrapping, use the more efficient BufCountBackwardNLines */
1482 True);
1488 }
1489 }
1491 /*
1492 ** Callback attached to the text buffer to receive delete information before
1493 ** the modifications are actually made.
1494 */
1496 {
1500 /* Note: we must perform this measurement, even if there is not a
1501 single character deleted; the number of "deleted" lines is the
1502 number of visual lines spanned by the real line in which the
1503 modification takes place.
1504 Also, a modification of the tab distance requires the same
1505 kind of calculations in advance, even if the font width is "fixed",
1506 because when the width of the tab characters changes, the layout
1507 of the text may be completely different. */
1509 else
1511 }
1513 /*
1514 ** Callback attached to the text buffer to receive modification information
1515 */
1518 {
1526 /* buffer modification cancels vertical cursor motion column */
1530 /* Count the number of lines inserted and deleted, and in the case
1531 of continuous wrap mode, how much has changed */
1539 }
1541 /* Update the line starts and topLineNum */
1550 }
1554 /* If we're counting non-wrapped lines as well, maintain the absolute
1555 (non-wrapped) line number of the text displayed */
1562 }
1564 /* Update the line count for the whole buffer */
1567 /* Update the scroll bar ranges (and value if the value changed). Note
1568 that updating the horizontal scroll bar range requires scanning the
1569 entire displayed text, however, it doesn't seem to hurt performance
1570 much. Note also, that the horizontal scroll bar update routine is
1571 allowed to re-adjust horizOffset if there is blank space to the right
1572 of all lines of text. */
1576 /* Update the cursor position */
1583 else
1585 }
1587 /* If the changes caused scrolling, re-paint everything and we're done. */
1595 }
1597 }
1599 /* If the changes didn't cause scrolling, decide the range of characters
1600 that need to be re-painted. Also if the cursor position moved, be
1601 sure that the redisplay range covers the old cursor position so the
1602 old cursor gets erased, and erase the bits of the cursor which extend
1603 beyond the left and right edges of the text. */
1616 }
1617 /* If more than one line is inserted/deleted, a line break may have
1618 been inserted or removed in between, and the line numbers may
1619 have changed. If only one line is altered, line numbers cannot
1620 be affected (the insertion or removal of a line break always
1621 results in at least two lines being redrawn). */
1628 }
1630 /* If there is a style buffer, check if the modification caused additional
1631 changes that need to be redisplayed. (Redisplaying separately would
1632 cause double-redraw on almost every modification involving styled
1633 text). Extend the redraw range to incorporate style changes */
1637 /* Redisplay computed range */
1639 }
1641 /*
1642 ** In continuous wrap mode, internal line numbers are calculated after
1643 ** wrapping. A separate non-wrapped line count is maintained when line
1644 ** numbering is turned on. There is some performance cost to maintaining this
1645 ** line count, so normally absolute line numbers are not tracked if line
1646 ** numbering is off. This routine allows callers to specify that they still
1647 ** want this line count maintained (for use via TextDPosToLineAndCol).
1648 ** More specifically, this allows the line number reported in the statistics
1649 ** line to be calibrated in absolute lines, rather than post-wrapped lines.
1650 */
1652 {
1655 }
1657 /*
1658 ** Returns the absolute (non-wrapped) line number of the first line displayed.
1659 ** Returns 0 if the absolute top line number is not being maintained.
1660 */
1662 {
1668 }
1670 /*
1671 ** Re-calculate absolute top line number for a change in scroll position.
1672 */
1674 {
1679 else
1682 }
1683 }
1685 /*
1686 ** Return true if a separate absolute top line number is being maintained
1687 ** (for displaying line numbers or showing in the statistics line).
1688 */
1690 {
1693 }
1695 /*
1696 ** Count lines from the beginning of the buffer to reestablish the
1697 ** absolute (non-wrapped) top line number. If mode is not continuous wrap,
1698 ** or the number is not being maintained, does nothing.
1699 */
1701 {
1704 }
1706 /*
1707 ** Find the line number of position "pos" relative to the first line of
1708 ** displayed text. Returns False if the line is not displayed.
1709 */
1711 {
1722 }
1727 }
1728 }
1730 }
1736 }
1737 }
1740 }
1742 /*
1743 ** Redisplay the text on a single line represented by "visLineNum" (the
1744 ** number of lines down from the top of the display), limited by
1745 ** "leftClip" and "rightClip" window coordinates and "leftCharIndex" and
1746 ** "rightCharIndex" character positions (not including the character at
1747 ** position "rightCharIndex").
1748 **
1749 ** The cursor is also drawn if it appears on the line.
1750 */
1753 {
1763 /* If line is not displayed, skip it */
1767 /* Shrink the clipping range to the active display area */
1773 }
1775 /* Calculate y coordinate of the string to draw */
1779 /* Get the text, length, and buffer position of the line to display */
1787 }
1789 /* Space beyond the end of the line is still counted in units of characters
1790 of a standardized character width (this is done mostly because style
1791 changes based on character position can still occur in this region due
1792 to rectangular selections). stdCharWidth must be non-zero to prevent a
1793 potential infinite loop if x does not advance */
1799 }
1801 /* Rectangular selections are based on "real" line starts (after a newline
1802 or start of buffer). Calculate the difference between the last newline
1803 position and the line start we're using. Since scanning back to find a
1804 newline is expensive, only do so if there's actually a rectangular
1805 selection which needs it */
1816 /* Step through character positions from the beginning of the line (even if
1817 that's off the left edge of the displayed area) to find the first
1818 character position that's not clipped, and the x coordinate for drawing
1819 that character */
1832 ? stdCharWidth
1840 }
1843 }
1845 /* Scan character positions from the beginning of the clipping range, and
1846 draw parts whenever the style changes (also note if the cursor is on
1847 this line, and where it should be drawn to take advantage of the x
1848 position which we've gone to so much trouble to calculate) */
1862 }
1863 }
1864 }
1877 }
1884 }
1891 }
1893 outPtr++;
1895 outIndex++;
1896 }
1901 }
1902 }
1904 /* Draw the remaining style segment */
1907 /* Draw the cursor if part of it appeared on the redisplayed part of
1908 this line. Also check for the cases which are not caught as the
1909 line is scanned above: when the cursor appears at the very end
1910 of the redisplayed section. */
1923 }
1924 }
1927 }
1928 }
1930 /* If the y position of the cursor has changed, redraw the calltip */
1935 }
1937 /*
1938 ** Draw a string or blank area according to parameter "style", using the
1939 ** appropriate colors and drawing method for that style, with top left
1940 ** corner at x, y. If style says to draw text, use "string" as source of
1941 ** characters, and draw "nChars", if style is FILL, erase
1942 ** rectangle where text would have drawn from x to toX and from y to
1943 ** the maximum y extent of the current font(s).
1944 */
1947 {
1949 XGCValues gcValues;
1955 /* Don't draw if widget isn't realized */
1959 /* select a GC */
1962 }
1966 }
1970 }
1973 }
1976 /* we have work to do */
1978 /* Set font, color, and gc depending on style. For normal text, GCs
1979 for normal drawing, or drawing within a selection or highlight are
1980 pre-allocated and pre-configured. For syntax highlighting, GCs are
1981 configured here, on the fly. */
1988 /* here you could pick up specific select and highlight fground */
1989 }
1994 }
1995 /* Background color priority order is:
1996 1 Primary(Selection), 2 Highlight(Parens),
1997 3 Rangeset, 4 SyntaxHighlightStyle,
1998 5 Backlight (if NOT fill), 6 DefaultBackground */
1999 bground =
2005 bground) :
2012 /* set up gc for clearing using the foreground color entry */
2016 }
2018 /* Draw blank area rather than text, if that was the request */
2020 /* wipes out to right hand edge of widget */
2025 }
2027 /* If any space around the character remains unfilled (due to use of
2028 different sized fonts for highlighting), fill in above or below
2029 to erase previously drawn characters */
2036 /* set up gc for writing text (set foreground properly) */
2040 }
2042 /* Draw the string using gc and font set above */
2046 /* Underline if style is secondary selection */
2048 {
2049 /* restore foreground in GC (was set to background by clearRect()) */
2053 /* draw underline */
2056 }
2057 }
2059 /*
2060 ** Clear a rectangle with the appropriate background color for "style"
2061 */
2064 {
2065 /* A width of zero means "clear to end of window" to XClearArea */
2072 }
2076 }
2077 }
2079 /*
2080 ** Draw a cursor with top center at x, y.
2081 */
2083 {
2094 /* For cursors other than the block, make them around 2/3 of a character
2095 width, rounded to an even number of pixels so that X will draw an
2096 odd number centered on the stem at x. */
2101 /* Create segments and draw cursor */
2134 }
2138 /* Save the last position drawn */
2141 }
2143 /*
2144 ** Determine the drawing method to use to draw a specific character from "buf".
2145 ** "lineStartPos" gives the character index where the line begins, "lineIndex",
2146 ** the number of characters past the beginning of the line, and "dispIndex",
2147 ** the number of displayed characters past the beginning of the line. Passing
2148 ** lineStartPos of -1 returns the drawing style for "no text".
2149 **
2150 ** Why not just: styleOfPos(textD, pos)? Because style applies to blank areas
2151 ** of the window beyond the text boundaries, and because this routine must also
2152 ** decide whether a position is inside of a rectangular selection, and do so
2153 ** efficiently, without re-counting character positions from the start of the
2154 ** line.
2155 **
2156 ** Note that style is a somewhat incorrect name, drawing method would
2157 ** be more appropriate.
2158 */
2161 {
2176 /* encountered "unfinished" style, trigger parsing */
2179 }
2180 }
2187 /* store in the RANGESET_MASK portion of style the rangeset index for pos */
2191 }
2192 /* store in the BACKLIGHT_MASK portion of style the background color class
2193 of the character thisChar */
2195 {
2197 }
2199 }
2201 /*
2202 ** Find the width of a string in the font of a particular style
2203 */
2206 {
2211 else
2214 }
2216 /*
2217 ** Return true if position "pos" with indentation "dispIndex" is in
2218 ** selection "sel"
2219 */
2221 {
2228 }
2230 /*
2231 ** Translate window coordinates to the nearest (insert cursor or character
2232 ** cell) text position. The parameter posType specifies how to interpret the
2233 ** position: CURSOR_POS means translate the coordinates to the nearest cursor
2234 ** position, and CHARACTER_POS means return the position of the character
2235 ** closest to (x, y).
2236 */
2238 {
2243 /* Find the visible line number corresponding to the y coordinate */
2251 /* Find the position at the start of the line */
2254 /* If the line start was empty, return the last position in the buffer */
2258 /* Get the line text and its length */
2262 /* Step through character positions from the beginning of the line
2263 to find the character position corresponding to the x coordinate */
2275 }
2278 }
2280 /* If the x position was beyond the end of the line, return the position
2281 of the newline at the end of the line */
2284 }
2286 /*
2287 ** Translate window coordinates to the nearest row and column number for
2288 ** positioning the cursor. This, of course, makes no sense when the font is
2289 ** proportional, since there are no absolute columns. The parameter posType
2290 ** specifies how to interpret the position: CURSOR_POS means translate the
2291 ** coordinates to the nearest position between characters, and CHARACTER_POS
2292 ** means translate the position to the nearest character cell.
2293 */
2296 {
2300 /* Find the visible line number corresponding to the y coordinate */
2307 }
2309 /*
2310 ** Offset the line starts array, topLineNum, firstChar and lastChar, for a new
2311 ** vertical scroll position given by newTopLineNum. If any currently displayed
2312 ** lines will still be visible, salvage the line starts values, otherwise,
2313 ** count lines from the nearest known line start (start or end of buffer, or
2314 ** the closest value in the lineStarts array)
2315 */
2317 {
2326 /* If there was no offset, nothing needs to be changed */
2330 /* { int i;
2331 printf("Scroll, lineDelta %d\n", lineDelta);
2332 printf("lineStarts Before: ");
2333 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2334 printf("\n");
2335 } */
2337 /* Find the new value for firstChar by counting lines from the nearest
2338 known line start (start or end of buffer, or the closest value in the
2339 lineStarts array) */
2343 True);
2344 /* printf("counting forward %d lines from start\n", newTopLineNum-1);*/
2348 /* printf("counting backward %d lines from firstChar\n", -lineDelta);*/
2351 /* printf("taking new start from lineStarts[%d]\n",
2352 newTopLineNum - oldTopLineNum); */
2356 /* printf("counting forward %d lines from start of last line\n",
2357 newTopLineNum - lastLineNum); */
2361 /* printf("counting backward %d lines from end\n",
2362 textD->nBufferLines - newTopLineNum + 1); */
2363 }
2365 /* Fill in the line starts array */
2377 /* Set lastChar and topLineNum */
2381 /* If we're numbering lines or being asked to maintain an absolute line
2382 number, re-calculate the absolute line number */
2385 /* { int i;
2386 printf("lineStarts After: ");
2387 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2388 printf("\n");
2389 } */
2390 }
2392 /*
2393 ** Update the line starts array, topLineNum, firstChar and lastChar for text
2394 ** display "textD" after a modification to the text buffer, given by the
2395 ** position where the change began "pos", and the nmubers of characters
2396 ** and lines inserted and deleted.
2397 */
2400 {
2406 /* { int i;
2407 printf("linesDeleted %d, linesInserted %d, charsInserted %d, charsDeleted %d\n",
2408 linesDeleted, linesInserted, charsInserted, charsDeleted);
2409 printf("lineStarts Before: ");
2410 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2411 printf("\n");
2412 } */
2413 /* If all of the changes were before the displayed text, the display
2414 doesn't change, just update the top line num and offset the line
2415 start entries and first and last characters */
2420 /* { int i;
2421 printf("lineStarts after delete doesn't touch: ");
2422 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2423 printf("\n");
2424 } */
2429 }
2431 /* The change began before the beginning of the displayed text, but
2432 part or all of the displayed text was deleted */
2434 /* If some text remains in the window, anchor on that */
2440 /* Otherwise anchor on original line number and recount everything */
2448 }
2450 /* { int i;
2451 printf("lineStarts after delete encroaches: ");
2452 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2453 printf("\n");
2454 } */
2455 /* calculate lastChar by finding the end of the last displayed line */
2459 }
2461 /* If the change was in the middle of the displayed text (it usually is),
2462 salvage as much of the line starts array as possible by moving and
2463 offsetting the entries after the changed area, and re-counting the
2464 added lines or the lines beyond the salvaged part of the line starts
2465 array */
2467 /* find line on which the change began */
2469 /* salvage line starts after the changed area */
2481 }
2482 /* { int i;
2483 printf("lineStarts after salvage: ");
2484 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2485 printf("\n");
2486 } */
2487 /* fill in the missing line starts */
2492 /* { int i;
2493 printf("lineStarts after recalculation: ");
2494 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2495 printf("\n");
2496 } */
2497 /* calculate lastChar by finding the end of the last displayed line */
2501 }
2503 /* Change was past the end of the displayed text, but displayable by virtue
2504 of being an insert at the end of the buffer into visible blank lines */
2509 /* { int i;
2510 printf("lineStarts after insert at end: ");
2511 for(i=0; i<nVisLines; i++) printf("%d ", lineStarts[i]);
2512 printf("\n");
2513 } */
2516 }
2518 /* Change was beyond the end of the buffer and not visible, do nothing */
2520 }
2522 /*
2523 ** Scan through the text in the "textD"'s buffer and recalculate the line
2524 ** starts array values beginning at index "startLine" and continuing through
2525 ** (including) "endLine". It assumes that the line starts entry preceding
2526 ** "startLine" (or textD->firstChar if startLine is 0) is good, and re-counts
2527 ** newlines to fill in the requested entries. Out of range values for
2528 ** "startLine" and "endLine" are acceptable.
2529 */
2531 {
2536 /* Clean up (possibly) messy input parameters */
2545 /* Find the last known good line number -> position mapping */
2549 }
2552 /* If the starting position is already past the end of the text,
2553 fill in -1's (means no text on line) and return */
2558 }
2560 /* Loop searching for ends of lines and storing the positions of the
2561 start of the next line in lineStarts */
2566 /* If the buffer ends with a newline or line break, put
2567 buf->length in the next line start position (instead of
2568 a -1 which is the normal marker for an empty line) to
2569 indicate that the cursor may safely be displayed there */
2573 line++;
2574 }
2576 }
2578 }
2580 /* Set any entries beyond the end of the text to -1 */
2583 }
2585 /*
2586 ** Given a textDisp with a complete, up-to-date lineStarts array, update
2587 ** the lastChar entry to point to the last buffer position displayed.
2588 */
2590 {
2596 }
2599 {
2605 }
2606 }
2607 }
2610 {
2616 }
2618 }
2620 void TextDTranlateGraphicExposeQueue(textDisp *textD, int xOffset, int yOffset, Boolean appendEntry)
2621 {
2624 newGEQEntry = (graphicExposeTranslationEntry *)XtMalloc(sizeof(graphicExposeTranslationEntry));
2628 }
2635 }
2638 }
2639 }
2643 }
2644 }
2645 }
2649 {
2657 /* Do nothing if scroll position hasn't actually changed or there's no
2658 window to draw in yet */
2663 /* If part of the cursor is protruding beyond the text clipping region,
2664 clear it off */
2667 /* If the vertical scroll position has changed, update the line
2668 starts array and related counters in the text display */
2671 /* Just setting textD->horizOffset is enough information for redisplay */
2674 /* Update the scroll bar positions if requested, note: updating the
2675 horizontal scroll bars can have the further side-effect of changing
2676 the horizontal scroll position, textD->horizOffset */
2679 }
2682 }
2684 /* Redisplay everything if the window is partially obscured (since
2685 it's too hard to tell what displayed areas are salvageable) or
2686 if there's nothing to recover because the scroll distance is large */
2695 /* If the window is not obscured, paint most of the window using XCopyArea
2696 from existing displayed text, and redraw only what's necessary */
2697 /* Recover the useable window areas by moving to the proper location */
2708 /* redraw the un-recoverable parts */
2712 }
2716 }
2720 }
2724 }
2725 /* Restore protruding parts of the cursor */
2727 }
2729 /* Refresh line number/calltip display if its up and we've scrolled
2730 vertically */
2734 }
2737 }
2739 /*
2740 ** Update the minimum, maximum, slider size, page increment, and value
2741 ** for vertical scroll bar.
2742 */
2744 {
2750 /* The Vert. scroll bar value and slider size directly represent the top
2751 line number, and the number of visible lines respectively. The scroll
2752 bar maximum value is chosen to generally represent the size of the whole
2753 buffer, with minor adjustments to keep the scroll bar widget happy */
2764 }
2766 /*
2767 ** Update the minimum, maximum, slider size, page increment, and value
2768 ** for the horizontal scroll bar. If scroll position is such that there
2769 ** is blank space to the right of all lines of text, scroll back (adjust
2770 ** horizOffset but don't redraw) to take up the slack and position the
2771 ** right edge of the text at the right edge of the display.
2772 **
2773 ** Note, there is some cost to this routine, since it scans the whole range
2774 ** of displayed text, particularly since it's usually called for each typed
2775 ** character!
2776 */
2778 {
2785 /* Scan all the displayed lines to find the width of the longest line */
2789 /* If the scroll position is beyond what's necessary to keep all lines
2790 in view, scroll to the left to bring the end of the longest line to
2791 the right margin */
2795 /* Readjust the scroll bar */
2804 /* Return True if scroll position was changed */
2806 }
2808 /*
2809 ** Define area for drawing line numbers. A width of 0 disables line
2810 ** number drawing.
2811 */
2814 {
2823 }
2825 /*
2826 ** Refresh the line number area. If clearAll is False, writes only over
2827 ** the character cell areas. Setting clearAll to True will clear out any
2828 ** stray marks outside of the character cell area, which might have been
2829 ** left from before a resize or font change.
2830 */
2832 {
2837 XRectangle clipRect;
2840 /* Don't draw if lineNumWidth == 0 (line numbers are hidden), or widget is
2841 not yet realized */
2845 /* Make sure we reset the clipping range for the line numbers GC, because
2846 the GC may be shared (eg, if the line numbers and text have the same
2847 color) and therefore the clipping ranges may be invalid. */
2855 /* Erase the previous contents of the line number area, if requested */
2860 /* Draw the line numbers, aligned to the text */
2872 line++;
2878 line++;
2879 }
2881 }
2882 }
2884 /*
2885 ** Callbacks for drag or valueChanged on scroll bars
2886 */
2888 {
2896 }
2898 {
2905 }
2909 {
2910 /* Record whether the window is fully visible or not. This information
2911 is used for choosing the scrolling methodology for optimal performance,
2912 if the window is partially obscured, XCopyArea may not work */
2914 }
2917 {
2919 }
2922 {
2924 }
2926 /*
2927 ** Count the number of newlines in a null-terminated text string;
2928 */
2930 {
2939 }
2941 /*
2942 ** Return the width in pixels of the displayed line pointed to by "visLineNum"
2943 */
2945 {
2956 }
2964 len);
2966 }
2967 }
2969 }
2971 /*
2972 ** Return true if there are lines visible with no corresponding buffer text
2973 */
2975 {
2978 }
2980 /*
2981 ** When the cursor is at the left or right edge of the text, part of it
2982 ** sticks off into the clipped region beyond the text. Normal redrawing
2983 ** can not overwrite this protruding part of the cursor, so it must be
2984 ** erased independently by calling this routine.
2985 */
2987 {
3005 }
3007 /*
3008 ** Allocate shared graphics contexts used by the widget, which must be
3009 ** re-allocated on a font change.
3010 */
3014 {
3019 GCArcMode);
3024 GCArcMode);
3030 }
3032 /*
3033 ** X11R4 does not have the XtAllocateGC function for sharing graphics contexts
3034 ** with changeable fields. Unfortunately the R4 call for creating shared
3035 ** graphics contexts (XtGetGC) is rarely useful because most widgets need
3036 ** to be able to set and change clipping, and that makes the GC unshareable.
3037 **
3038 ** This function allocates and returns a gc, using XtAllocateGC if possible,
3039 ** or XCreateGC on X11R4 systems where XtAllocateGC is not available.
3040 */
3044 {
3045 XGCValues gcValues;
3050 #if defined(XlibSpecificationRelease) && XlibSpecificationRelease > 4
3052 dontCareMask);
3053 #else
3056 #endif
3057 }
3059 /*
3060 ** Release a gc allocated with allocateGC above
3061 */
3063 {
3064 #if defined(XlibSpecificationRelease) && XlibSpecificationRelease > 4
3066 #else
3068 #endif
3069 }
3071 /*
3072 ** resetClipRectangles sets the clipping rectangles for GCs which clip
3073 ** at the text boundary (as opposed to the window boundary). These GCs
3074 ** are shared such that the drawing styles are constant, but the clipping
3075 ** rectangles are allowed to change among different users of the GCs (the
3076 ** GCs were created with XtAllocGC). This routine resets them so the clipping
3077 ** rectangles are correct for this text display.
3078 */
3080 {
3081 XRectangle clipRect;
3102 }
3104 /*
3105 ** Return the length of a line (number of displayable characters) by examining
3106 ** entries in the line starts array rather than by scanning for newlines
3107 */
3109 {
3122 }
3124 /*
3125 ** When continuous wrap is on, and the user inserts or deletes characters,
3126 ** wrapping can happen before and beyond the changed position. This routine
3127 ** finds the extent of the changes, and counts the deleted and inserted lines
3128 ** over that range. It also attempts to minimize the size of the range to
3129 ** what has to be counted and re-displayed, so the results can be useful
3130 ** both for delimiting where the line starts need to be recalculated, and
3131 ** for deciding what part of the text to redisplay.
3132 */
3136 {
3144 /*
3145 ** Determine where to begin searching: either the previous newline, or
3146 ** if possible, limit to the start of the (original) previous displayed
3147 ** line, using information from the existing line starts array
3148 */
3162 /*
3163 ** Move forward through the (new) text one line at a time, counting
3164 ** displayed lines, and looking for either a real newline, or for the
3165 ** line starts to re-sync with the original line starts array
3166 */
3171 /* advance to the next line. If the line ended in a real newline
3172 or the end of the buffer, that's far enough */
3179 nLines++;
3183 nLines++;
3189 }
3191 /* Don't try to resync in continuous wrap mode with non-fixed font
3192 sizes; it would result in a chicken-and-egg dependency between
3193 the calculations for the inserted and the deleted lines.
3194 If we're in that mode, the number of deleted lines is calculated in
3195 advance, without resynchronization, so we shouldn't resynchronize
3196 for the inserted lines either. */
3200 /* check for synchronization with the original line starts array
3201 before pos, if so, the modified range can begin later */
3204 visLineNum++;
3210 else
3214 }
3216 /* check for synchronization with the original line starts array
3217 after pos, if so, the modified range can end early */
3221 visLineNum++;
3227 }
3228 }
3229 }
3233 /* Count deleted lines between countFrom and countTo as the text existed
3234 before the modification (that is, as if the text between pos and
3235 pos+nInserted were replaced by "deletedText"). This extra context is
3236 necessary because wrapping can occur outside of the modified region
3237 as a result of adding or deleting text in the region. This is done by
3238 creating a textBuffer containing the deleted text and the necessary
3239 additional context, and calling the wrappedLineCounter on it.
3241 NOTE: This must not be done in continuous wrap mode when the font
3242 width is not fixed. In that case, the calculation would try
3243 to access style information that is no longer available (deleted
3244 text), or out of date (updated highlighting), possibly leading
3245 to completely wrong calculations and/or even crashes eventually.
3246 (This is not theoretical; it really happened.)
3248 In that case, the calculation of the number of deleted lines
3249 has happened before the buffer was modified (only in that case,
3250 because resynchronization of the line starts is impossible
3251 in that case, which makes the whole calculation less efficient).
3252 */
3257 }
3268 /* Note that we need to take into account an offset for the style buffer:
3269 the deletedTextBuf can be out of sync with the style buffer. */
3275 }
3277 /*
3278 ** This is a stripped-down version of the findWrapRange() function above,
3279 ** intended to be used to calculate the number of "deleted" lines during
3280 ** a buffer modification. It is called _before_ the modification takes place.
3281 **
3282 ** This function should only be called in continuous wrap mode with a
3283 ** non-fixed font width. In that case, it is impossible to calculate
3284 ** the number of deleted lines, because the necessary style information
3285 ** is no longer available _after_ the modification. In other cases, we
3286 ** can still perform the calculation afterwards (possibly even more
3287 ** efficiently).
3288 */
3290 {
3297 /*
3298 ** Determine where to begin searching: either the previous newline, or
3299 ** if possible, limit to the start of the (original) previous displayed
3300 ** line, using information from the existing line starts array
3301 */
3313 /*
3314 ** Move forward through the (new) text one line at a time, counting
3315 ** displayed lines, and looking for either a real newline, or for the
3316 ** line starts to re-sync with the original line starts array
3317 */
3320 /* advance to the next line. If the line ended in a real newline
3321 or the end of the buffer, that's far enough */
3326 nLines++;
3330 nLines++;
3334 }
3336 /* Unlike in the findWrapRange() function above, we don't try to
3337 resync with the line starts, because we don't know the length
3338 of the inserted text yet, nor the updated style information.
3340 Because of that, we also shouldn't resync with the line starts
3341 after the modification either, because we must perform the
3342 calculations for the deleted and inserted lines in the same way.
3344 This can result in some unnecessary recalculation and redrawing
3345 overhead, and therefore we should only use this two-phase mode
3346 of calculation when it's really needed (continuous wrap + variable
3347 font width). */
3348 }
3351 }
3353 /*
3354 ** Count forward from startPos to either maxPos or maxLines (whichever is
3355 ** reached first), and return all relevant positions and line count.
3356 ** The provided textBuffer may differ from the actual text buffer of the
3357 ** widget. In that case it must be a (partial) copy of the actual text buffer
3358 ** and the styleBufOffset argument must indicate the starting position of the
3359 ** copy, to take into account the correct style information.
3360 **
3361 ** Returned values:
3362 **
3363 ** retPos: Position where counting ended. When counting lines, the
3364 ** position returned is the start of the line "maxLines"
3365 ** lines beyond "startPos".
3366 ** retLines: Number of line breaks counted
3367 ** retLineStart: Start of the line where counting ended
3368 ** retLineEnd: End position of the last line traversed
3369 */
3374 {
3381 /* If the font is fixed, or there's a wrap margin set, it's more efficient
3382 to measure in columns, than to count pixels. Determine if we can count
3383 in columns (countPixels == False) or must count pixels (countPixels ==
3384 True), and set the wrap target for either pixels or columns */
3394 }
3396 /* Find the start of the line if the start pos is not marked as a
3397 line start. */
3400 else
3403 /*
3404 ** Loop until position exceeds maxPos or line count exceeds maxLines.
3405 ** (actually, contines beyond maxPos to end of line containing maxPos,
3406 ** in case later characters cause a word wrap back before maxPos)
3407 */
3413 /* If the character was a newline, count the line and start over,
3414 otherwise, add it to the width and column counts */
3422 }
3423 nLines++;
3430 }
3438 }
3440 /* If character exceeded wrap margin, find the break point
3441 and wrap there */
3455 colNum++;
3456 }
3461 }
3462 }
3468 }
3473 newLineStart;
3476 }
3477 nLines++;
3484 }
3486 }
3487 }
3489 /* reached end of buffer before reaching pos or line target */
3494 }
3496 /*
3497 ** Measure the width in pixels of a character "c" at a particular column
3498 ** "colNum" and buffer position "pos". This is for measuring characters in
3499 ** proportional or mixed-width highlighting fonts.
3500 **
3501 ** A note about proportional and mixed-width fonts: the mixed width and
3502 ** proportional font code in nedit does not get much use in general editing,
3503 ** because nedit doesn't allow per-language-mode fonts, and editing programs
3504 ** in a proportional font is usually a bad idea, so very few users would
3505 ** choose a proportional font as a default. There are still probably mixed-
3506 ** width syntax highlighting cases where things don't redraw properly for
3507 ** insertion/deletion, though static display and wrapping and resizing
3508 ** should now be solid because they are now used for online help display.
3509 */
3512 {
3524 /* encountered "unfinished" style, trigger parsing */
3527 }
3528 }
3530 }
3532 /*
3533 ** Finds both the end of the current line and the start of the next line. Why?
3534 ** In continuous wrap mode, if you need to know both, figuring out one from the
3535 ** other can be expensive or error prone. The problem comes when there's a
3536 ** trailing space or tab just before the end of the buffer. To translate an
3537 ** end of line value to or from the next lines start value, you need to know
3538 ** whether the trailing space or tab is being used as a line break or just a
3539 ** normal character, and to find that out would otherwise require counting all
3540 ** the way back to the beginning of the line.
3541 */
3544 {
3547 /* if we're not wrapping use more efficient BufEndOfLine */
3552 }
3554 /* use the wrapped line counter routine to count forward one line */
3559 }
3561 /*
3562 ** Line breaks in continuous wrap mode usually happen at newlines or
3563 ** whitespace. This line-terminating character is not included in line
3564 ** width measurements and has a special status as a non-visible character.
3565 ** However, lines with no whitespace are wrapped without the benefit of a
3566 ** line terminating character, and this distinction causes endless trouble
3567 ** with all of the text display code which was originally written without
3568 ** continuous wrap mode and always expects to wrap at a newline character.
3569 **
3570 ** Given the position of the end of the line, as returned by TextDEndOfLine
3571 ** or BufEndOfLine, this returns true if there is a line terminating
3572 ** character, and false if there's not. On the last character in the
3573 ** buffer, this function can't tell for certain whether a trailing space was
3574 ** used as a wrap point, and just guesses that it wasn't. So if an exact
3575 ** accounting is necessary, don't use this function.
3576 */
3578 {
3587 }
3589 /*
3590 ** Decide whether the user needs (or may need) a horizontal scroll bar,
3591 ** and manage or unmanage the scroll bar widget accordingly. The H.
3592 ** scroll bar is only hidden in continuous wrap mode when it's absolutely
3593 ** certain that the user will not need it: when wrapping is set
3594 ** to the window edge, or when the wrap margin is strictly less than
3595 ** the longest possible line.
3596 */
3598 {
3602 else
3604 }
3606 /*
3607 ** Return true if the selection "sel" is rectangular, and touches a
3608 ** buffer position withing "rangeStart" to "rangeEnd"
3609 */
3611 {
3614 }
3616 /*
3617 ** Extend the range of a redraw request (from *start to *end) with additional
3618 ** redraw requests resulting from changes to the attached style buffer (which
3619 ** contains auxiliary information for coloring or styling text).
3620 */
3622 {
3626 /* The peculiar protocol used here is that modifications to the style
3627 buffer are marked by selecting them with the buffer's primary selection.
3628 The style buffer is usually modified in response to a modify callback on
3629 the text buffer BEFORE textDisp.c's modify callback, so that it can keep
3630 the style buffer in step with the text buffer. The style-update
3631 callback can't just call for a redraw, because textDisp hasn't processed
3632 the original text changes yet. Anyhow, to minimize redrawing and to
3633 avoid the complexity of scheduling redraws later, this simple protocol
3634 tells the text display's buffer modify callback to extend it's redraw
3635 range to show the text color/and font changes as well. */
3640 }
3644 }
3645 }
3647 /* If the selection was extended due to a style change, and some of the
3648 fonts don't match in spacing, extend redraw area to end of line to
3649 redraw characters exposed by possible font size changes */
3652 }
3654 /********************** Backlight Functions ******************************/
3655 /*
3656 ** Allocate a read-only (shareable) colormap cell for a named color, from the
3657 ** the default colormap of the screen on which the widget (w) is displayed. If
3658 ** the colormap is full and there's no suitable substitute, print an error on
3659 ** stderr, and return the widget's background color as a backup.
3660 */
3662 {
3666 }
3669 {
3672 Pixel color;
3677 ind--;
3687 }
3690 }
3691 }
3693 }
3695 /*
3696 ** Read the background color class specification string in str, allocating the
3697 ** necessary colors, and allocating and setting up the character->class_no and
3698 ** class_no->pixel map arrays, returned via *pp_bgClass and *pp_bgClassPixel
3699 ** respectively.
3700 ** Note: the allocation of class numbers could be more intelligent: there can
3701 ** never be more than 256 of these (one per character); but I don't think
3702 ** there'll be a pressing need. I suppose the scanning of the specification
3703 ** could be better too, but then, who cares!
3704 */
3707 {
3727 /* default for all chars is class number zero, for standard background */
3731 /* since class no == 0 in a "style" has no set bits in BACKLIGHT_MASK
3732 (see styleOfPos()), when drawString() is called for text with a
3733 backlight class no of zero, bgClassPixel[0] is never consulted, and
3734 the default background color is chosen. */
3736 /* The format of the class string s is:
3737 low[-high]{,low[-high]}:color{;low-high{,low[-high]}:color}
3738 eg
3739 32-255:#f0f0f0;1-31,127:red;128-159:orange;9-13:#e5e5e5
3740 where low and high represent a character range between ordinal
3741 ASCII values. Using strtol() allows automatic octal, dec and hex
3742 reading of low and high. The example format sets backgrounds as follows:
3743 char 1 - 8 colored red (control characters)
3744 char 9 - 13 colored #e5e5e5 (isspace() control characters)
3745 char 14 - 31 colored red (control characters)
3746 char 32 - 126 colored #f0f0f0
3747 char 127 colored red (delete character)
3748 char 128 - 159 colored orange ("shifted" control characters)
3749 char 160 - 255 colored #f0f0f0
3750 Notice that some of the later ranges overwrite the class values defined
3751 for earlier ones (eg the first clause, 32-255:#f0f0f0 sets the DEL
3752 character background color to #f0f0f0; it is then set to red by the
3753 clause 1-31,127:red). */
3762 }
3764 /* loop over ranges before the color spec, assigning the characters
3765 in the ranges to the current class number */
3767 is_good;
3777 }
3781 }
3783 /* complain? this class spec clause (in string s) was faulty */
3784 }
3786 /* end of loop iterator clauses */
3790 }
3792 /* when we get here, we've set up our class table and class-to-pixel table
3793 in local variables: now put them into the "real thing" */
3801 }
3804 }