Fossil SCM

Further improvements to unified diff. Simplified CSS that can be used in common with split diff. Separate columns for each line number and the change mark.

drh 2021-09-01 15:38 diff-color-enhancements
Commit ce856a86148b45befe6275c5f686460c60b232f0e95ca4906b7bbce8c3478721
Parent 598d7736e75b438…
4 files changed +9 +52 +120 -62 +61 -9
~ src/blob.c ~ src/default.css ~ src/diff.c ~ src/diffcmd.c
M src/blob.c
+9
--- src/blob.c
+++ src/blob.c
@@ -347,10 +347,19 @@
347347
 void blob_copy(Blob *pTo, Blob *pFrom){
348348
 blob_is_init(pFrom);
349349
 blob_zero(pTo);
350350
 blob_append(pTo, blob_buffer(pFrom), blob_size(pFrom));
351351
 }
352
+
353
+/*
354
+** Append the second blob onto the end of the first blob and reset the
355
+** second blob.
356
+*/
357
+void blob_append_xfer(Blob *pTo, Blob *pFrom){
358
+ blob_append(pTo, blob_buffer(pFrom), blob_size(pFrom));
359
+ blob_reset(pFrom);
360
+}
352361
353362
 /*
354363
 ** Return a pointer to a null-terminated string for a blob.
355364
 */
356365
 char *blob_str(Blob *p){
357366
--- src/blob.c
+++ src/blob.c
@@ -347,10 +347,19 @@
347 void blob_copy(Blob *pTo, Blob *pFrom){
348 blob_is_init(pFrom);
349 blob_zero(pTo);
350 blob_append(pTo, blob_buffer(pFrom), blob_size(pFrom));
351 }
 
 
 
 
 
 
 
 
 
352
353 /*
354 ** Return a pointer to a null-terminated string for a blob.
355 */
356 char *blob_str(Blob *p){
357
--- src/blob.c
+++ src/blob.c
@@ -347,10 +347,19 @@
347 void blob_copy(Blob *pTo, Blob *pFrom){
348 blob_is_init(pFrom);
349 blob_zero(pTo);
350 blob_append(pTo, blob_buffer(pFrom), blob_size(pFrom));
351 }
352
353 /*
354 ** Append the second blob onto the end of the first blob and reset the
355 ** second blob.
356 */
357 void blob_append_xfer(Blob *pTo, Blob *pFrom){
358 blob_append(pTo, blob_buffer(pFrom), blob_size(pFrom));
359 blob_reset(pFrom);
360 }
361
362 /*
363 ** Return a pointer to a null-terminated string for a blob.
364 */
365 char *blob_str(Blob *p){
366
M src/default.css
+52
--- src/default.css
+++ src/default.css
@@ -606,10 +606,62 @@
606606
 pre.udifftxt del mark {
607607
 background-color: #ffc0c0;
608608
 text-decoration: none;
609609
 font-weight: bold;
610610
 }
611
+
612
+table.diff {
613
+ width: 90%;
614
+ border-spacing: 0;
615
+}
616
+td.diffln {
617
+ text-align: right;
618
+ padding: 0 0 0 1em;
619
+}
620
+td.diffsep {
621
+ padding: 0 0.5em 0 0.5em;
622
+}
623
+td.difftxt {
624
+ width: 100%;
625
+}
626
+td.diffln ins {
627
+ background-color: #a0e4b2;
628
+ text-decoration: none;
629
+}
630
+td.diffln del {
631
+ background-color: #ffc0c0;
632
+ text-decoration: none;
633
+}
634
+td.difftxt del {
635
+ background-color: #ffe8e8;
636
+ text-decoration: none;
637
+}
638
+td.difftxt del > del {
639
+ background-color: #ffc0c0;
640
+ text-decoration: none;
641
+ font-weight: bold;
642
+}
643
+td.difftxt del mark {
644
+ background-color: #c0c0ff;
645
+ text-decoration: none;
646
+ font-weight: bold;
647
+}
648
+td.difftxt ins {
649
+ background-color: #dafbe1;
650
+ text-decoration: none;
651
+}
652
+td.udifftxt ins > ins {
653
+ background-color: #a0e4b2;
654
+ text-decoration: none;
655
+ font-weight: bold;
656
+}
657
+td.udifftxt ins mark {
658
+ background-color: #c0c0ff;
659
+ text-decoration: none;
660
+ font-weight: bold;
661
+}
662
+
611663
612664
 span.modpending {
613665
 color: #b03800;
614666
 font-style: italic;
615667
 }
616668
--- src/default.css
+++ src/default.css
@@ -606,10 +606,62 @@
606 pre.udifftxt del mark {
607 background-color: #ffc0c0;
608 text-decoration: none;
609 font-weight: bold;
610 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
611
612 span.modpending {
613 color: #b03800;
614 font-style: italic;
615 }
616
--- src/default.css
+++ src/default.css
@@ -606,10 +606,62 @@
606 pre.udifftxt del mark {
607 background-color: #ffc0c0;
608 text-decoration: none;
609 font-weight: bold;
610 }
611
612 table.diff {
613 width: 90%;
614 border-spacing: 0;
615 }
616 td.diffln {
617 text-align: right;
618 padding: 0 0 0 1em;
619 }
620 td.diffsep {
621 padding: 0 0.5em 0 0.5em;
622 }
623 td.difftxt {
624 width: 100%;
625 }
626 td.diffln ins {
627 background-color: #a0e4b2;
628 text-decoration: none;
629 }
630 td.diffln del {
631 background-color: #ffc0c0;
632 text-decoration: none;
633 }
634 td.difftxt del {
635 background-color: #ffe8e8;
636 text-decoration: none;
637 }
638 td.difftxt del > del {
639 background-color: #ffc0c0;
640 text-decoration: none;
641 font-weight: bold;
642 }
643 td.difftxt del mark {
644 background-color: #c0c0ff;
645 text-decoration: none;
646 font-weight: bold;
647 }
648 td.difftxt ins {
649 background-color: #dafbe1;
650 text-decoration: none;
651 }
652 td.udifftxt ins > ins {
653 background-color: #a0e4b2;
654 text-decoration: none;
655 font-weight: bold;
656 }
657 td.udifftxt ins mark {
658 background-color: #c0c0ff;
659 text-decoration: none;
660 font-weight: bold;
661 }
662
663
664 span.modpending {
665 color: #b03800;
666 font-style: italic;
667 }
668
M src/diff.c
+120 -62
--- src/diff.c
+++ src/diff.c
@@ -1635,10 +1635,12 @@
16351635
 void (*xDelete)(DiffBuilder*,const DLine*);
16361636
 void (*xEdit)(DiffBuilder*,const DLine*,const DLine*);
16371637
 void (*xEnd)(DiffBuilder*);
16381638
 unsigned int lnLeft; /* Lines seen on the left (delete) side */
16391639
 unsigned int lnRight; /* Lines seen on the right (insert) side */
1640
+ unsigned int nPending; /* Number of pending lines */
1641
+ int eState; /* State of the output */
16401642
 Blob *pOut; /* Output blob */
16411643
 Blob aCol[5]; /* Holding blobs */
16421644
 };
16431645
16441646
 /************************* DiffBuilderDebug ********************************/
@@ -1863,115 +1865,170 @@
18631865
18641866
 /************************* DiffBuilderUnified********************************/
18651867
18661868
 /* Accumulator strategy:
18671869
 **
1868
-** * Common and Delete line numbers are output directly to p->pOut
1869
-** * Common and Delete text accumulates in p->aCol[0].
1870
-** * Pending insert lines numbers go into p->aCol[1].
1871
-** * Pending insert text goes into p->aCol[2].
1870
+** * Delete line numbers are output directly to p->pOut
1871
+** * Insert line numbers accumulate in p->aCol[0].
1872
+** * Separator marks accumulate in p->aCol[1].
1873
+** * Change text accumulates in p->aCol[2].
1874
+** * Pending insert line numbers go into p->aCol[3].
1875
+** * Pending insert text goes into p->aCol[4].
1876
+**
1877
+** eState is 1 if text has an open <del>
18721878
 */
1873
-static void dfunifiedEmitInsert(DiffBuilder *p){
1874
- if( blob_size(&p->aCol[1])==0 ) return;
1875
- blob_append(p->pOut, blob_buffer(&p->aCol[1]), blob_size(&p->aCol[1]));
1876
- blob_reset(&p->aCol[1]);
1877
- blob_append(&p->aCol[0], blob_buffer(&p->aCol[2]), blob_size(&p->aCol[2]));
1878
- blob_reset(&p->aCol[2]);
1879
+static void dfunifiedFinishDelete(DiffBuilder *p){
1880
+ if( p->eState==0 ) return;
1881
+ blob_append(p->pOut, "</del>", 6);
1882
+ blob_append(&p->aCol[2], "</del>", 6);
1883
+ p->eState = 0;
1884
+}
1885
+static void dfunifiedFinishInsert(DiffBuilder *p){
1886
+ unsigned int i;
1887
+ if( p->nPending==0 ) return;
1888
+ dfunifiedFinishDelete(p);
1889
+
1890
+ /* Blank lines for delete line numbers for each inserted line */
1891
+ for(i=0; i<p->nPending; i++) blob_append_char(p->pOut, '\n');
1892
+
1893
+ /* Insert line numbers */
1894
+ blob_append(&p->aCol[0], "<ins>", 5);
1895
+ blob_append_xfer(&p->aCol[0], &p->aCol[3]);
1896
+ blob_append(&p->aCol[0], "</ins>", 6);
1897
+
1898
+ /* "+" marks for the separator on inserted lines */
1899
+ for(i=0; i<p->nPending; i++) blob_append(&p->aCol[1], "+\n", 2);
1900
+
1901
+ /* Text of the inserted lines */
1902
+ blob_append(&p->aCol[2], "<ins>", 5);
1903
+ blob_append_xfer(&p->aCol[2], &p->aCol[4]);
1904
+ blob_append(&p->aCol[2], "</ins>", 6);
1905
+
1906
+ p->nPending = 0;
1907
+}
1908
+static void dfunifiedFinishRow(DiffBuilder *p){
1909
+ dfunifiedFinishDelete(p);
1910
+ dfunifiedFinishInsert(p);
1911
+ if( blob_size(&p->aCol[0])==0 ) return;
1912
+ blob_append(p->pOut, "</pre></td><td class=\"diffln difflnr\"><pre>\n", -1);
1913
+ blob_append_xfer(p->pOut, &p->aCol[0]);
1914
+ blob_append(p->pOut, "</pre></td><td class=\"diffsep\"><pre>\n", -1);
1915
+ blob_append_xfer(p->pOut, &p->aCol[1]);
1916
+ blob_append(p->pOut, "</pre></td><td class=\"difftxt difftxtu\"><pre>\n",-1);
1917
+ blob_append_xfer(p->pOut, &p->aCol[2]);
1918
+ blob_append(p->pOut, "</pre></td></tr>\n", -1);
1919
+}
1920
+static void dfunifiedStartRow(DiffBuilder *p){
1921
+ if( blob_size(&p->aCol[0])>0 ) return;
1922
+ blob_append(p->pOut,"<tr><td class=\"diffln difflnl\"><pre>\n", -1);
1923
+ p->eState = 0;
1924
+ p->nPending = 0;
18791925
 }
18801926
 static void dfunifiedSkip(DiffBuilder *p, unsigned int n, int isFinal){
1881
- dfunifiedEmitInsert(p);
1927
+ dfunifiedFinishRow(p);
18821928
 if( (p->lnLeft || p->lnRight) && !isFinal ){
1883
- blob_append(p->pOut,
1884
- "<span class=\"diffhr\">"
1885
- ".................."
1886
- "</span>\n",
1887
- -1);
1888
- blob_append(&p->aCol[0],
1889
- "<span class=\"diffhr\">"
1890
- "..............................................................."
1891
- "</span>\n",
1892
- -1);
1929
+ blob_append(p->pOut, "<tr><td class=\"diffskip\" colspan=\"2\">"
1930
+ "<hr></td><td></td><td></td></tr>\n", -1);
18931931
 }
18941932
 p->lnLeft += n;
18951933
 p->lnRight += n;
18961934
 }
18971935
 static void dfunifiedCommon(DiffBuilder *p, const DLine *pLine){
18981936
 int iCol = 0;
1899
- dfunifiedEmitInsert(p);
1937
+ dfunifiedStartRow(p);
1938
+ dfunifiedFinishDelete(p);
1939
+ dfunifiedFinishInsert(p);
19001940
 p->lnLeft++;
19011941
 p->lnRight++;
1902
- blob_appendf(p->pOut,"%6d %6d \n", p->lnLeft, p->lnRight);
1903
- blob_append(&p->aCol[0], " ", 2);
1904
- jsonize_to_blob(&p->aCol[0], pLine->z, (int)pLine->n, &iCol);
1905
- blob_append_char(&p->aCol[0], '\n');
1942
+ blob_appendf(p->pOut,"%d\n", p->lnLeft);
1943
+ blob_appendf(&p->aCol[0],"%d\n",p->lnRight);
1944
+ blob_append_char(&p->aCol[1], '\n');
1945
+ jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1946
+ blob_append_char(&p->aCol[2], '\n');
19061947
 }
19071948
 static void dfunifiedInsert(DiffBuilder *p, const DLine *pLine){
19081949
 int iCol = 0;
1950
+ dfunifiedStartRow(p);
19091951
 p->lnRight++;
1910
- blob_appendf(&p->aCol[1],"<ins> %6d </ins>\n", p->lnRight);
1911
- blob_append(&p->aCol[2],"<ins>+ <mark>",-1);
1912
- jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1913
- blob_append(&p->aCol[2], "</mark></ins>\n", -1);
1952
+ blob_appendf(&p->aCol[3],"%d\n", p->lnRight);
1953
+ blob_append(&p->aCol[4], "<ins>", 5);
1954
+ jsonize_to_blob(&p->aCol[4], pLine->z, (int)pLine->n, &iCol);
1955
+ blob_append(&p->aCol[4], "</ins>\n", 7);
1956
+ p->nPending++;
19141957
 }
19151958
 static void dfunifiedDelete(DiffBuilder *p, const DLine *pLine){
19161959
 int iCol = 0;
1960
+ dfunifiedStartRow(p);
1961
+ dfunifiedFinishInsert(p);
1962
+ if( p->eState==0 ){
1963
+ dfunifiedFinishInsert(p);
1964
+ blob_append(p->pOut, "<del>", 5);
1965
+ blob_append(&p->aCol[2], "<del>", 5);
1966
+ p->eState = 1;
1967
+ }
19171968
 p->lnLeft++;
1918
- blob_appendf(p->pOut,"<del>%6d </del>\n", p->lnLeft);
1919
- blob_append(&p->aCol[0],"<del>- <mark>",-1);
1920
- jsonize_to_blob(&p->aCol[0], pLine->z, (int)pLine->n, &iCol);
1921
- blob_append(&p->aCol[0], "</mark></del>\n", -1);
1969
+ blob_appendf(p->pOut,"%d\n", p->lnLeft);
1970
+ blob_append_char(&p->aCol[0],'\n');
1971
+ blob_append(&p->aCol[1],"-\n",2);
1972
+ blob_append(&p->aCol[2], "<del>", 5);
1973
+ jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1974
+ blob_append(&p->aCol[2], "</del>\n", 7);
19221975
 }
19231976
 static void dfunifiedEdit(DiffBuilder *p, const DLine *pX, const DLine *pY){
19241977
 int i;
19251978
 int x;
19261979
 int iCol;
19271980
 ChangeSpan span;
19281981
 oneLineChange(pX, pY, &span);
1982
+ dfunifiedStartRow(p);
1983
+ if( p->eState==0 ){
1984
+ dfunifiedFinishInsert(p);
1985
+ blob_append(p->pOut, "<del>", 5);
1986
+ blob_append(&p->aCol[2], "<del>", 5);
1987
+ p->eState = 1;
1988
+ }
19291989
 p->lnLeft++;
19301990
 p->lnRight++;
1931
- blob_appendf(p->pOut,"<del>%6d </del>\n", p->lnLeft);
1932
- blob_append(&p->aCol[0], "<del>- ", -1);
1991
+ blob_appendf(p->pOut,"%d\n", p->lnLeft);
1992
+ blob_append_char(&p->aCol[0], '\n');
1993
+ blob_append(&p->aCol[1], "-\n", 2);
1994
+
19331995
 for(i=x=iCol=0; i<span.n; i++){
19341996
 int ofst = span.a[i].iStart1;
19351997
 int len = span.a[i].iLen1;
19361998
 if( len ){
1937
- jsonize_to_blob(&p->aCol[0], pX->z+x, ofst - x, &iCol);
1999
+ jsonize_to_blob(&p->aCol[2], pX->z+x, ofst - x, &iCol);
19382000
 x = ofst;
1939
- blob_append(&p->aCol[0], "<mark>", 6);
1940
- jsonize_to_blob(&p->aCol[0], pX->z+x, len, &iCol);
2001
+ blob_append(&p->aCol[2], "<del>", 5);
2002
+ jsonize_to_blob(&p->aCol[2], pX->z+x, len, &iCol);
19412003
 x += len;
1942
- blob_append(&p->aCol[0], "</mark>", 7);
2004
+ blob_append(&p->aCol[2], "</del>", 6);
19432005
 }
19442006
 }
1945
- if( x<pX->n ) jsonize_to_blob(&p->aCol[0], pX->z+x, pX->n - x, &iCol);
1946
- blob_append(&p->aCol[0], "</del>\n", -1);
1947
- blob_appendf(&p->aCol[1],"<ins> %6d </ins>\n", p->lnRight);
1948
- blob_append(&p->aCol[2], "<ins>+ ", -1);
2007
+ if( x<pX->n ) jsonize_to_blob(&p->aCol[2], pX->z+x, pX->n - x, &iCol);
2008
+ blob_append_char(&p->aCol[2], '\n');
2009
+
2010
+ blob_appendf(&p->aCol[3],"%d\n", p->lnRight);
19492011
 for(i=x=iCol=0; i<span.n; i++){
19502012
 int ofst = span.a[i].iStart2;
19512013
 int len = span.a[i].iLen2;
19522014
 if( len ){
1953
- jsonize_to_blob(&p->aCol[2], pY->z+x, ofst - x, &iCol);
2015
+ jsonize_to_blob(&p->aCol[4], pY->z+x, ofst - x, &iCol);
19542016
 x = ofst;
1955
- blob_append(&p->aCol[2], "<mark>", 6);
1956
- jsonize_to_blob(&p->aCol[2], pY->z+x, len, &iCol);
2017
+ blob_append(&p->aCol[4], "<ins>", 5);
2018
+ jsonize_to_blob(&p->aCol[4], pY->z+x, len, &iCol);
19572019
 x += len;
1958
- blob_append(&p->aCol[2], "</mark>", 7);
2020
+ blob_append(&p->aCol[4], "</ins>", 6);
19592021
 }
19602022
 }
1961
- if( x<pY->n ) jsonize_to_blob(&p->aCol[2], pY->z+x, pY->n - x, &iCol);
1962
- blob_append(&p->aCol[2], "</ins>\n", -1);
2023
+ if( x<pY->n ) jsonize_to_blob(&p->aCol[4], pY->z+x, pY->n - x, &iCol);
2024
+ blob_append_char(&p->aCol[4], '\n');
2025
+ p->nPending++;
19632026
 }
19642027
 static void dfunifiedEnd(DiffBuilder *p){
1965
- dfunifiedEmitInsert(p);
1966
- blob_append(p->pOut,
1967
- "</pre></td>\n"
1968
- "<td class=\"udifftxt\" width=\"100%\"><pre class=\"udifftxt\">\n",
1969
- -1);
1970
- blob_append(p->pOut, blob_buffer(&p->aCol[0]), blob_size(&p->aCol[0]));
1971
- blob_reset(&p->aCol[0]);
1972
- blob_append(p->pOut, "</pre></td></tr>\n</table>\n", -1);
2028
+ dfunifiedFinishRow(p);
2029
+ blob_append(p->pOut, "</table>\n",-1);
19732030
 fossil_free(p);
19742031
 }
19752032
 static DiffBuilder *dfunifiedNew(Blob *pOut){
19762033
 DiffBuilder *p = fossil_malloc(sizeof(*p));
19772034
 p->xSkip = dfunifiedSkip;
@@ -1979,18 +2036,19 @@
19792036
 p->xInsert = dfunifiedInsert;
19802037
 p->xDelete = dfunifiedDelete;
19812038
 p->xEdit = dfunifiedEdit;
19822039
 p->xEnd = dfunifiedEnd;
19832040
 p->lnLeft = p->lnRight = 0;
2041
+ p->eState = 0;
2042
+ p->nPending = 0;
19842043
 p->pOut = pOut;
1985
- blob_append(pOut,
1986
- "<table class=\"sbsdiffcols\">\n"
1987
- "<tr><td class=\"udiffln\"><pre class=\"udiffln\">\n",
1988
- -1);
2044
+ blob_append(pOut, "<table class=\"diff\">\n", -1);
19892045
 blob_init(&p->aCol[0], 0, 0);
19902046
 blob_init(&p->aCol[1], 0, 0);
19912047
 blob_init(&p->aCol[2], 0, 0);
2048
+ blob_init(&p->aCol[3], 0, 0);
2049
+ blob_init(&p->aCol[4], 0, 0);
19922050
 return p;
19932051
 }
19942052
 /****************************************************************************/
19952053
19962054
 /*
19972055
--- src/diff.c
+++ src/diff.c
@@ -1635,10 +1635,12 @@
1635 void (*xDelete)(DiffBuilder*,const DLine*);
1636 void (*xEdit)(DiffBuilder*,const DLine*,const DLine*);
1637 void (*xEnd)(DiffBuilder*);
1638 unsigned int lnLeft; /* Lines seen on the left (delete) side */
1639 unsigned int lnRight; /* Lines seen on the right (insert) side */
 
 
1640 Blob *pOut; /* Output blob */
1641 Blob aCol[5]; /* Holding blobs */
1642 };
1643
1644 /************************* DiffBuilderDebug ********************************/
@@ -1863,115 +1865,170 @@
1863
1864 /************************* DiffBuilderUnified********************************/
1865
1866 /* Accumulator strategy:
1867 **
1868 ** * Common and Delete line numbers are output directly to p->pOut
1869 ** * Common and Delete text accumulates in p->aCol[0].
1870 ** * Pending insert lines numbers go into p->aCol[1].
1871 ** * Pending insert text goes into p->aCol[2].
 
 
 
 
1872 */
1873 static void dfunifiedEmitInsert(DiffBuilder *p){
1874 if( blob_size(&p->aCol[1])==0 ) return;
1875 blob_append(p->pOut, blob_buffer(&p->aCol[1]), blob_size(&p->aCol[1]));
1876 blob_reset(&p->aCol[1]);
1877 blob_append(&p->aCol[0], blob_buffer(&p->aCol[2]), blob_size(&p->aCol[2]));
1878 blob_reset(&p->aCol[2]);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1879 }
1880 static void dfunifiedSkip(DiffBuilder *p, unsigned int n, int isFinal){
1881 dfunifiedEmitInsert(p);
1882 if( (p->lnLeft || p->lnRight) && !isFinal ){
1883 blob_append(p->pOut,
1884 "<span class=\"diffhr\">"
1885 ".................."
1886 "</span>\n",
1887 -1);
1888 blob_append(&p->aCol[0],
1889 "<span class=\"diffhr\">"
1890 "..............................................................."
1891 "</span>\n",
1892 -1);
1893 }
1894 p->lnLeft += n;
1895 p->lnRight += n;
1896 }
1897 static void dfunifiedCommon(DiffBuilder *p, const DLine *pLine){
1898 int iCol = 0;
1899 dfunifiedEmitInsert(p);
 
 
1900 p->lnLeft++;
1901 p->lnRight++;
1902 blob_appendf(p->pOut,"%6d %6d \n", p->lnLeft, p->lnRight);
1903 blob_append(&p->aCol[0], " ", 2);
1904 jsonize_to_blob(&p->aCol[0], pLine->z, (int)pLine->n, &iCol);
1905 blob_append_char(&p->aCol[0], '\n');
 
1906 }
1907 static void dfunifiedInsert(DiffBuilder *p, const DLine *pLine){
1908 int iCol = 0;
 
1909 p->lnRight++;
1910 blob_appendf(&p->aCol[1],"<ins> %6d </ins>\n", p->lnRight);
1911 blob_append(&p->aCol[2],"<ins>+ <mark>",-1);
1912 jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1913 blob_append(&p->aCol[2], "</mark></ins>\n", -1);
 
1914 }
1915 static void dfunifiedDelete(DiffBuilder *p, const DLine *pLine){
1916 int iCol = 0;
 
 
 
 
 
 
 
 
1917 p->lnLeft++;
1918 blob_appendf(p->pOut,"<del>%6d </del>\n", p->lnLeft);
1919 blob_append(&p->aCol[0],"<del>- <mark>",-1);
1920 jsonize_to_blob(&p->aCol[0], pLine->z, (int)pLine->n, &iCol);
1921 blob_append(&p->aCol[0], "</mark></del>\n", -1);
 
 
1922 }
1923 static void dfunifiedEdit(DiffBuilder *p, const DLine *pX, const DLine *pY){
1924 int i;
1925 int x;
1926 int iCol;
1927 ChangeSpan span;
1928 oneLineChange(pX, pY, &span);
 
 
 
 
 
 
 
1929 p->lnLeft++;
1930 p->lnRight++;
1931 blob_appendf(p->pOut,"<del>%6d </del>\n", p->lnLeft);
1932 blob_append(&p->aCol[0], "<del>- ", -1);
 
 
1933 for(i=x=iCol=0; i<span.n; i++){
1934 int ofst = span.a[i].iStart1;
1935 int len = span.a[i].iLen1;
1936 if( len ){
1937 jsonize_to_blob(&p->aCol[0], pX->z+x, ofst - x, &iCol);
1938 x = ofst;
1939 blob_append(&p->aCol[0], "<mark>", 6);
1940 jsonize_to_blob(&p->aCol[0], pX->z+x, len, &iCol);
1941 x += len;
1942 blob_append(&p->aCol[0], "</mark>", 7);
1943 }
1944 }
1945 if( x<pX->n ) jsonize_to_blob(&p->aCol[0], pX->z+x, pX->n - x, &iCol);
1946 blob_append(&p->aCol[0], "</del>\n", -1);
1947 blob_appendf(&p->aCol[1],"<ins> %6d </ins>\n", p->lnRight);
1948 blob_append(&p->aCol[2], "<ins>+ ", -1);
1949 for(i=x=iCol=0; i<span.n; i++){
1950 int ofst = span.a[i].iStart2;
1951 int len = span.a[i].iLen2;
1952 if( len ){
1953 jsonize_to_blob(&p->aCol[2], pY->z+x, ofst - x, &iCol);
1954 x = ofst;
1955 blob_append(&p->aCol[2], "<mark>", 6);
1956 jsonize_to_blob(&p->aCol[2], pY->z+x, len, &iCol);
1957 x += len;
1958 blob_append(&p->aCol[2], "</mark>", 7);
1959 }
1960 }
1961 if( x<pY->n ) jsonize_to_blob(&p->aCol[2], pY->z+x, pY->n - x, &iCol);
1962 blob_append(&p->aCol[2], "</ins>\n", -1);
 
1963 }
1964 static void dfunifiedEnd(DiffBuilder *p){
1965 dfunifiedEmitInsert(p);
1966 blob_append(p->pOut,
1967 "</pre></td>\n"
1968 "<td class=\"udifftxt\" width=\"100%\"><pre class=\"udifftxt\">\n",
1969 -1);
1970 blob_append(p->pOut, blob_buffer(&p->aCol[0]), blob_size(&p->aCol[0]));
1971 blob_reset(&p->aCol[0]);
1972 blob_append(p->pOut, "</pre></td></tr>\n</table>\n", -1);
1973 fossil_free(p);
1974 }
1975 static DiffBuilder *dfunifiedNew(Blob *pOut){
1976 DiffBuilder *p = fossil_malloc(sizeof(*p));
1977 p->xSkip = dfunifiedSkip;
@@ -1979,18 +2036,19 @@
1979 p->xInsert = dfunifiedInsert;
1980 p->xDelete = dfunifiedDelete;
1981 p->xEdit = dfunifiedEdit;
1982 p->xEnd = dfunifiedEnd;
1983 p->lnLeft = p->lnRight = 0;
 
 
1984 p->pOut = pOut;
1985 blob_append(pOut,
1986 "<table class=\"sbsdiffcols\">\n"
1987 "<tr><td class=\"udiffln\"><pre class=\"udiffln\">\n",
1988 -1);
1989 blob_init(&p->aCol[0], 0, 0);
1990 blob_init(&p->aCol[1], 0, 0);
1991 blob_init(&p->aCol[2], 0, 0);
 
 
1992 return p;
1993 }
1994 /****************************************************************************/
1995
1996 /*
1997
--- src/diff.c
+++ src/diff.c
@@ -1635,10 +1635,12 @@
1635 void (*xDelete)(DiffBuilder*,const DLine*);
1636 void (*xEdit)(DiffBuilder*,const DLine*,const DLine*);
1637 void (*xEnd)(DiffBuilder*);
1638 unsigned int lnLeft; /* Lines seen on the left (delete) side */
1639 unsigned int lnRight; /* Lines seen on the right (insert) side */
1640 unsigned int nPending; /* Number of pending lines */
1641 int eState; /* State of the output */
1642 Blob *pOut; /* Output blob */
1643 Blob aCol[5]; /* Holding blobs */
1644 };
1645
1646 /************************* DiffBuilderDebug ********************************/
@@ -1863,115 +1865,170 @@
1865
1866 /************************* DiffBuilderUnified********************************/
1867
1868 /* Accumulator strategy:
1869 **
1870 ** * Delete line numbers are output directly to p->pOut
1871 ** * Insert line numbers accumulate in p->aCol[0].
1872 ** * Separator marks accumulate in p->aCol[1].
1873 ** * Change text accumulates in p->aCol[2].
1874 ** * Pending insert line numbers go into p->aCol[3].
1875 ** * Pending insert text goes into p->aCol[4].
1876 **
1877 ** eState is 1 if text has an open <del>
1878 */
1879 static void dfunifiedFinishDelete(DiffBuilder *p){
1880 if( p->eState==0 ) return;
1881 blob_append(p->pOut, "</del>", 6);
1882 blob_append(&p->aCol[2], "</del>", 6);
1883 p->eState = 0;
1884 }
1885 static void dfunifiedFinishInsert(DiffBuilder *p){
1886 unsigned int i;
1887 if( p->nPending==0 ) return;
1888 dfunifiedFinishDelete(p);
1889
1890 /* Blank lines for delete line numbers for each inserted line */
1891 for(i=0; i<p->nPending; i++) blob_append_char(p->pOut, '\n');
1892
1893 /* Insert line numbers */
1894 blob_append(&p->aCol[0], "<ins>", 5);
1895 blob_append_xfer(&p->aCol[0], &p->aCol[3]);
1896 blob_append(&p->aCol[0], "</ins>", 6);
1897
1898 /* "+" marks for the separator on inserted lines */
1899 for(i=0; i<p->nPending; i++) blob_append(&p->aCol[1], "+\n", 2);
1900
1901 /* Text of the inserted lines */
1902 blob_append(&p->aCol[2], "<ins>", 5);
1903 blob_append_xfer(&p->aCol[2], &p->aCol[4]);
1904 blob_append(&p->aCol[2], "</ins>", 6);
1905
1906 p->nPending = 0;
1907 }
1908 static void dfunifiedFinishRow(DiffBuilder *p){
1909 dfunifiedFinishDelete(p);
1910 dfunifiedFinishInsert(p);
1911 if( blob_size(&p->aCol[0])==0 ) return;
1912 blob_append(p->pOut, "</pre></td><td class=\"diffln difflnr\"><pre>\n", -1);
1913 blob_append_xfer(p->pOut, &p->aCol[0]);
1914 blob_append(p->pOut, "</pre></td><td class=\"diffsep\"><pre>\n", -1);
1915 blob_append_xfer(p->pOut, &p->aCol[1]);
1916 blob_append(p->pOut, "</pre></td><td class=\"difftxt difftxtu\"><pre>\n",-1);
1917 blob_append_xfer(p->pOut, &p->aCol[2]);
1918 blob_append(p->pOut, "</pre></td></tr>\n", -1);
1919 }
1920 static void dfunifiedStartRow(DiffBuilder *p){
1921 if( blob_size(&p->aCol[0])>0 ) return;
1922 blob_append(p->pOut,"<tr><td class=\"diffln difflnl\"><pre>\n", -1);
1923 p->eState = 0;
1924 p->nPending = 0;
1925 }
1926 static void dfunifiedSkip(DiffBuilder *p, unsigned int n, int isFinal){
1927 dfunifiedFinishRow(p);
1928 if( (p->lnLeft || p->lnRight) && !isFinal ){
1929 blob_append(p->pOut, "<tr><td class=\"diffskip\" colspan=\"2\">"
1930 "<hr></td><td></td><td></td></tr>\n", -1);
 
 
 
 
 
 
 
 
1931 }
1932 p->lnLeft += n;
1933 p->lnRight += n;
1934 }
1935 static void dfunifiedCommon(DiffBuilder *p, const DLine *pLine){
1936 int iCol = 0;
1937 dfunifiedStartRow(p);
1938 dfunifiedFinishDelete(p);
1939 dfunifiedFinishInsert(p);
1940 p->lnLeft++;
1941 p->lnRight++;
1942 blob_appendf(p->pOut,"%d\n", p->lnLeft);
1943 blob_appendf(&p->aCol[0],"%d\n",p->lnRight);
1944 blob_append_char(&p->aCol[1], '\n');
1945 jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1946 blob_append_char(&p->aCol[2], '\n');
1947 }
1948 static void dfunifiedInsert(DiffBuilder *p, const DLine *pLine){
1949 int iCol = 0;
1950 dfunifiedStartRow(p);
1951 p->lnRight++;
1952 blob_appendf(&p->aCol[3],"%d\n", p->lnRight);
1953 blob_append(&p->aCol[4], "<ins>", 5);
1954 jsonize_to_blob(&p->aCol[4], pLine->z, (int)pLine->n, &iCol);
1955 blob_append(&p->aCol[4], "</ins>\n", 7);
1956 p->nPending++;
1957 }
1958 static void dfunifiedDelete(DiffBuilder *p, const DLine *pLine){
1959 int iCol = 0;
1960 dfunifiedStartRow(p);
1961 dfunifiedFinishInsert(p);
1962 if( p->eState==0 ){
1963 dfunifiedFinishInsert(p);
1964 blob_append(p->pOut, "<del>", 5);
1965 blob_append(&p->aCol[2], "<del>", 5);
1966 p->eState = 1;
1967 }
1968 p->lnLeft++;
1969 blob_appendf(p->pOut,"%d\n", p->lnLeft);
1970 blob_append_char(&p->aCol[0],'\n');
1971 blob_append(&p->aCol[1],"-\n",2);
1972 blob_append(&p->aCol[2], "<del>", 5);
1973 jsonize_to_blob(&p->aCol[2], pLine->z, (int)pLine->n, &iCol);
1974 blob_append(&p->aCol[2], "</del>\n", 7);
1975 }
1976 static void dfunifiedEdit(DiffBuilder *p, const DLine *pX, const DLine *pY){
1977 int i;
1978 int x;
1979 int iCol;
1980 ChangeSpan span;
1981 oneLineChange(pX, pY, &span);
1982 dfunifiedStartRow(p);
1983 if( p->eState==0 ){
1984 dfunifiedFinishInsert(p);
1985 blob_append(p->pOut, "<del>", 5);
1986 blob_append(&p->aCol[2], "<del>", 5);
1987 p->eState = 1;
1988 }
1989 p->lnLeft++;
1990 p->lnRight++;
1991 blob_appendf(p->pOut,"%d\n", p->lnLeft);
1992 blob_append_char(&p->aCol[0], '\n');
1993 blob_append(&p->aCol[1], "-\n", 2);
1994
1995 for(i=x=iCol=0; i<span.n; i++){
1996 int ofst = span.a[i].iStart1;
1997 int len = span.a[i].iLen1;
1998 if( len ){
1999 jsonize_to_blob(&p->aCol[2], pX->z+x, ofst - x, &iCol);
2000 x = ofst;
2001 blob_append(&p->aCol[2], "<del>", 5);
2002 jsonize_to_blob(&p->aCol[2], pX->z+x, len, &iCol);
2003 x += len;
2004 blob_append(&p->aCol[2], "</del>", 6);
2005 }
2006 }
2007 if( x<pX->n ) jsonize_to_blob(&p->aCol[2], pX->z+x, pX->n - x, &iCol);
2008 blob_append_char(&p->aCol[2], '\n');
2009
2010 blob_appendf(&p->aCol[3],"%d\n", p->lnRight);
2011 for(i=x=iCol=0; i<span.n; i++){
2012 int ofst = span.a[i].iStart2;
2013 int len = span.a[i].iLen2;
2014 if( len ){
2015 jsonize_to_blob(&p->aCol[4], pY->z+x, ofst - x, &iCol);
2016 x = ofst;
2017 blob_append(&p->aCol[4], "<ins>", 5);
2018 jsonize_to_blob(&p->aCol[4], pY->z+x, len, &iCol);
2019 x += len;
2020 blob_append(&p->aCol[4], "</ins>", 6);
2021 }
2022 }
2023 if( x<pY->n ) jsonize_to_blob(&p->aCol[4], pY->z+x, pY->n - x, &iCol);
2024 blob_append_char(&p->aCol[4], '\n');
2025 p->nPending++;
2026 }
2027 static void dfunifiedEnd(DiffBuilder *p){
2028 dfunifiedFinishRow(p);
2029 blob_append(p->pOut, "</table>\n",-1);
 
 
 
 
 
 
2030 fossil_free(p);
2031 }
2032 static DiffBuilder *dfunifiedNew(Blob *pOut){
2033 DiffBuilder *p = fossil_malloc(sizeof(*p));
2034 p->xSkip = dfunifiedSkip;
@@ -1979,18 +2036,19 @@
2036 p->xInsert = dfunifiedInsert;
2037 p->xDelete = dfunifiedDelete;
2038 p->xEdit = dfunifiedEdit;
2039 p->xEnd = dfunifiedEnd;
2040 p->lnLeft = p->lnRight = 0;
2041 p->eState = 0;
2042 p->nPending = 0;
2043 p->pOut = pOut;
2044 blob_append(pOut, "<table class=\"diff\">\n", -1);
 
 
 
2045 blob_init(&p->aCol[0], 0, 0);
2046 blob_init(&p->aCol[1], 0, 0);
2047 blob_init(&p->aCol[2], 0, 0);
2048 blob_init(&p->aCol[3], 0, 0);
2049 blob_init(&p->aCol[4], 0, 0);
2050 return p;
2051 }
2052 /****************************************************************************/
2053
2054 /*
2055
M src/diffcmd.c
+61 -9
--- src/diffcmd.c
+++ src/diffcmd.c
@@ -186,11 +186,11 @@
186186
 @ <html>
187187
 @ <head>
188188
 @ <meta charset="UTF-8">
189189
 @ <style>
190190
 @ table.sbsdiffcols {
191
-@ width: 90%%;
191
+@ width: 90%;
192192
 @ border-spacing: 0;
193193
 @ }
194194
 @ table.sbsdiffcols td {
195195
 @ padding: 0;
196196
 @ vertical-align: top;
@@ -212,19 +212,19 @@
212212
 @ div.diffmkrcol {
213213
 @ padding: 0 1em;
214214
 @ }
215215
 @ span.diffchng {
216216
 @ background-color: #c0c0ff;
217
-@ text-weight: bold;
217
+@ font-weight: bold;
218218
 @ }
219219
 @ span.diffadd {
220220
 @ background-color: #c0ffc0;
221
-@ text-weight: bold;
221
+@ font-weight: bold;
222222
 @ }
223223
 @ span.diffrm {
224224
 @ background-color: #ffc8c8;
225
-@ text-weight: bold;
225
+@ font-weight: bold;
226226
 @ }
227227
 @ span.diffhr {
228228
 @ display: inline-block;
229229
 @ margin: .5em 0 1em;
230230
 @ color: #0000ff;
@@ -231,11 +231,11 @@
231231
 @ }
232232
 @ span.diffln {
233233
 @ color: #a0a0a0;
234234
 @ }
235235
 @ table.udiff {
236
-@ width: 90%%;
236
+@ width: 90%;
237237
 @ border-spacing: 0;
238238
 @ }
239239
 @ pre.udiffln {
240240
 @ color: #a0a0a0;
241241
 @ }
@@ -256,20 +256,72 @@
256256
 @ text-decoration: none;
257257
 @ }
258258
 @ pre.udifftxt ins mark {
259259
 @ background-color: #a0e4b2;
260260
 @ text-decoration: none;
261
-@ text-weight: bold;
261
+@ font-weight: bold;
262262
 @ }
263263
 @ pre.udifftxt del mark {
264264
 @ background-color: #ffc0c0;
265265
 @ text-decoration: none;
266
-@ text-weight: bold;
266
+@ font-weight: bold;
267267
 @ }
268268
 @ h1 {
269
-@ font-size: 150%%;
269
+@ font-size: 150%;
270
+@ }
271
+@
272
+@ table.diff {
273
+@ width: 90%;
274
+@ border-spacing: 0;
275
+@ }
276
+@ td.diffln {
277
+@ text-align: right;
278
+@ padding: 0 0 0 1em;
279
+@ }
280
+@ td.diffsep {
281
+@ padding: 0 0.5em 0 0.5em;
282
+@ }
283
+@ td.difftxt {
284
+@ width: 100%;
285
+@ }
286
+@ td.diffln ins {
287
+@ background-color: #a0e4b2;
288
+@ text-decoration: none;
289
+@ }
290
+@ td.diffln del {
291
+@ background-color: #ffc0c0;
292
+@ text-decoration: none;
293
+@ }
294
+@ td.difftxt del {
295
+@ background-color: #ffe8e8;
296
+@ text-decoration: none;
297
+@ }
298
+@ td.difftxt del > del {
299
+@ background-color: #ffc0c0;
300
+@ text-decoration: none;
301
+@ font-weight: bold;
302
+@ }
303
+@ td.difftxt del mark {
304
+@ background-color: #c0c0ff;
305
+@ text-decoration: none;
306
+@ font-weight: bold;
307
+@ }
308
+@ td.difftxt ins {
309
+@ background-color: #dafbe1;
310
+@ text-decoration: none;
311
+@ }
312
+@ td.difftxt ins > ins {
313
+@ background-color: #a0e4b2;
314
+@ text-decoration: none;
315
+@ font-weight: bold;
316
+@ }
317
+@ td.difftxt ins mark {
318
+@ background-color: #c0c0ff;
319
+@ text-decoration: none;
320
+@ font-weight: bold;
270321
 @ }
322
+@
271323
 @ </style>
272324
 @ </head>
273325
 @ <body>
274326
 ;
275327
 const char zWebpageEnd[] =
@@ -331,11 +383,11 @@
331383
 #else
332384
 SetConsoleCtrlHandler(diff_console_ctrl_handler, TRUE);
333385
 #endif
334386
 }
335387
 if( (diffFlags & DIFF_WEBPAGE)!=0 ){
336
- fossil_print(zWebpageHdr/*works-like:""*/);
388
+ fossil_print("%s",zWebpageHdr);
337389
 fflush(stdout);
338390
 }
339391
 }
340392
341393
 /* Do any final output required by a diff and complete the diff
342394
--- src/diffcmd.c
+++ src/diffcmd.c
@@ -186,11 +186,11 @@
186 @ <html>
187 @ <head>
188 @ <meta charset="UTF-8">
189 @ <style>
190 @ table.sbsdiffcols {
191 @ width: 90%%;
192 @ border-spacing: 0;
193 @ }
194 @ table.sbsdiffcols td {
195 @ padding: 0;
196 @ vertical-align: top;
@@ -212,19 +212,19 @@
212 @ div.diffmkrcol {
213 @ padding: 0 1em;
214 @ }
215 @ span.diffchng {
216 @ background-color: #c0c0ff;
217 @ text-weight: bold;
218 @ }
219 @ span.diffadd {
220 @ background-color: #c0ffc0;
221 @ text-weight: bold;
222 @ }
223 @ span.diffrm {
224 @ background-color: #ffc8c8;
225 @ text-weight: bold;
226 @ }
227 @ span.diffhr {
228 @ display: inline-block;
229 @ margin: .5em 0 1em;
230 @ color: #0000ff;
@@ -231,11 +231,11 @@
231 @ }
232 @ span.diffln {
233 @ color: #a0a0a0;
234 @ }
235 @ table.udiff {
236 @ width: 90%%;
237 @ border-spacing: 0;
238 @ }
239 @ pre.udiffln {
240 @ color: #a0a0a0;
241 @ }
@@ -256,20 +256,72 @@
256 @ text-decoration: none;
257 @ }
258 @ pre.udifftxt ins mark {
259 @ background-color: #a0e4b2;
260 @ text-decoration: none;
261 @ text-weight: bold;
262 @ }
263 @ pre.udifftxt del mark {
264 @ background-color: #ffc0c0;
265 @ text-decoration: none;
266 @ text-weight: bold;
267 @ }
268 @ h1 {
269 @ font-size: 150%%;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
270 @ }
 
271 @ </style>
272 @ </head>
273 @ <body>
274 ;
275 const char zWebpageEnd[] =
@@ -331,11 +383,11 @@
331 #else
332 SetConsoleCtrlHandler(diff_console_ctrl_handler, TRUE);
333 #endif
334 }
335 if( (diffFlags & DIFF_WEBPAGE)!=0 ){
336 fossil_print(zWebpageHdr/*works-like:""*/);
337 fflush(stdout);
338 }
339 }
340
341 /* Do any final output required by a diff and complete the diff
342
--- src/diffcmd.c
+++ src/diffcmd.c
@@ -186,11 +186,11 @@
186 @ <html>
187 @ <head>
188 @ <meta charset="UTF-8">
189 @ <style>
190 @ table.sbsdiffcols {
191 @ width: 90%;
192 @ border-spacing: 0;
193 @ }
194 @ table.sbsdiffcols td {
195 @ padding: 0;
196 @ vertical-align: top;
@@ -212,19 +212,19 @@
212 @ div.diffmkrcol {
213 @ padding: 0 1em;
214 @ }
215 @ span.diffchng {
216 @ background-color: #c0c0ff;
217 @ font-weight: bold;
218 @ }
219 @ span.diffadd {
220 @ background-color: #c0ffc0;
221 @ font-weight: bold;
222 @ }
223 @ span.diffrm {
224 @ background-color: #ffc8c8;
225 @ font-weight: bold;
226 @ }
227 @ span.diffhr {
228 @ display: inline-block;
229 @ margin: .5em 0 1em;
230 @ color: #0000ff;
@@ -231,11 +231,11 @@
231 @ }
232 @ span.diffln {
233 @ color: #a0a0a0;
234 @ }
235 @ table.udiff {
236 @ width: 90%;
237 @ border-spacing: 0;
238 @ }
239 @ pre.udiffln {
240 @ color: #a0a0a0;
241 @ }
@@ -256,20 +256,72 @@
256 @ text-decoration: none;
257 @ }
258 @ pre.udifftxt ins mark {
259 @ background-color: #a0e4b2;
260 @ text-decoration: none;
261 @ font-weight: bold;
262 @ }
263 @ pre.udifftxt del mark {
264 @ background-color: #ffc0c0;
265 @ text-decoration: none;
266 @ font-weight: bold;
267 @ }
268 @ h1 {
269 @ font-size: 150%;
270 @ }
271 @
272 @ table.diff {
273 @ width: 90%;
274 @ border-spacing: 0;
275 @ }
276 @ td.diffln {
277 @ text-align: right;
278 @ padding: 0 0 0 1em;
279 @ }
280 @ td.diffsep {
281 @ padding: 0 0.5em 0 0.5em;
282 @ }
283 @ td.difftxt {
284 @ width: 100%;
285 @ }
286 @ td.diffln ins {
287 @ background-color: #a0e4b2;
288 @ text-decoration: none;
289 @ }
290 @ td.diffln del {
291 @ background-color: #ffc0c0;
292 @ text-decoration: none;
293 @ }
294 @ td.difftxt del {
295 @ background-color: #ffe8e8;
296 @ text-decoration: none;
297 @ }
298 @ td.difftxt del > del {
299 @ background-color: #ffc0c0;
300 @ text-decoration: none;
301 @ font-weight: bold;
302 @ }
303 @ td.difftxt del mark {
304 @ background-color: #c0c0ff;
305 @ text-decoration: none;
306 @ font-weight: bold;
307 @ }
308 @ td.difftxt ins {
309 @ background-color: #dafbe1;
310 @ text-decoration: none;
311 @ }
312 @ td.difftxt ins > ins {
313 @ background-color: #a0e4b2;
314 @ text-decoration: none;
315 @ font-weight: bold;
316 @ }
317 @ td.difftxt ins mark {
318 @ background-color: #c0c0ff;
319 @ text-decoration: none;
320 @ font-weight: bold;
321 @ }
322 @
323 @ </style>
324 @ </head>
325 @ <body>
326 ;
327 const char zWebpageEnd[] =
@@ -331,11 +383,11 @@
383 #else
384 SetConsoleCtrlHandler(diff_console_ctrl_handler, TRUE);
385 #endif
386 }
387 if( (diffFlags & DIFF_WEBPAGE)!=0 ){
388 fossil_print("%s",zWebpageHdr);
389 fflush(stdout);
390 }
391 }
392
393 /* Do any final output required by a diff and complete the diff
394

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button