summaryrefslogtreecommitdiff
path: root/office/Ted/docSectProperties.c
diff options
context:
space:
mode:
Diffstat (limited to 'office/Ted/docSectProperties.c')
-rw-r--r--office/Ted/docSectProperties.c1105
1 files changed, 1105 insertions, 0 deletions
diff --git a/office/Ted/docSectProperties.c b/office/Ted/docSectProperties.c
new file mode 100644
index 0000000000..e85ae188e3
--- /dev/null
+++ b/office/Ted/docSectProperties.c
@@ -0,0 +1,1105 @@
+/************************************************************************/
+/* */
+/* Manipulate iten properties in a document. */
+/* */
+/************************************************************************/
+
+# include "docBaseConfig.h"
+
+# include <stdlib.h>
+
+# include <appDebugon.h>
+
+# include <utilPropMask.h>
+
+# include "docPropVal.h"
+# include "docSectProperties.h"
+
+# define MIN_COL_WIDE ( 20* 36 )
+# define MIN_GAP_WIDE ( 20* 12 )
+
+# define DEF_GAP_WIDE ( 20* 36 )
+
+/************************************************************************/
+/* */
+/* Translate section property numbers to notes property numbers. */
+/* */
+/************************************************************************/
+
+const int DOCsectNOTE_PROP_MAP[FEPprop_COUNT]=
+{
+ SPpropFOOTNOTE_STARTNR,
+ SPpropFOOTNOTE_JUSTIFICATION,
+ -1, /* No SPpropFOOTNOTE_PLACEMENT, */
+ SPpropFOOTNOTE_RESTART,
+ SPpropFOOTNOTE_STYLE,
+
+ SPpropENDNOTE_STARTNR,
+ -1, /* No SPpropENDNOTE_JUSTIFICATION, */
+ -1, /* No SPpropENDNOTE_PLACEMENT, */
+ SPpropENDNOTE_RESTART,
+ SPpropENDNOTE_STYLE,
+};
+
+const int * const DOCsectFOOTNOTE_PROP_MAP= DOCsectNOTE_PROP_MAP;
+const int * const DOCsectENDNOTE_PROP_MAP= DOCsectNOTE_PROP_MAP+ NOTESprop_COUNT;
+
+static const int DocSectIntProps[]=
+ {
+ DGpropPAGE_WIDTH,
+ DGpropPAGE_HEIGHT,
+ DGpropLEFT_MARGIN,
+ DGpropRIGHT_MARGIN,
+ DGpropTOP_MARGIN,
+ DGpropBOTTOM_MARGIN,
+ DGpropHEADER_POSITION,
+ DGpropFOOTER_POSITION,
+ DGpropGUTTER,
+ DGpropMARGMIR,
+ SPpropSTYLE,
+ SPpropTITLEPG,
+ SPpropBREAK_KIND,
+ SPpropNUMBER_STYLE,
+ SPpropNUMBER_HYPHEN,
+ SPpropPAGE_RESTART,
+ SPpropSTART_PAGE,
+ SPpropCOLUMN_COUNT,
+ SPpropCOLUMN_SPACING,
+ SPpropLINEBETCOL,
+ SPpropFOOTNOTE_STARTNR,
+ SPpropFOOTNOTE_JUSTIFICATION,
+ /* No SPpropFOOTNOTE_PLACEMENT, */
+ SPpropFOOTNOTE_RESTART,
+ SPpropFOOTNOTE_STYLE,
+ SPpropENDNOTE_STARTNR,
+ /* No SPpropENDNOTE_JUSTIFICATION, */
+ /* No SPpropENDNOTE_PLACEMENT, */
+ SPpropENDNOTE_RESTART,
+ SPpropENDNOTE_STYLE,
+ };
+
+static const int DocSectIntPropCount= sizeof(DocSectIntProps)/sizeof(int);
+
+/************************************************************************/
+/* */
+/* Fill a mask with notes properties that are relevant for a section. */
+/* I.E: Set those section properties that are a note property. */
+/* */
+/************************************************************************/
+
+void docFillSectNotesMask( PropertyMask * spMask )
+ {
+ int i;
+
+ for ( i= 0; i < FEPprop_COUNT; i++ )
+ {
+ if ( DOCsectNOTE_PROP_MAP[i] >= 0 )
+ { PROPmaskADD( spMask, DOCsectNOTE_PROP_MAP[i] ); }
+ }
+ }
+
+/************************************************************************/
+/* */
+/* Make sure all column width are zero, or that none of them is. */
+/* */
+/************************************************************************/
+
+static void docSectCheckFixedColumnWidth( SectionProperties * sp )
+ {
+ if ( sp->spColumnCount > 1 )
+ {
+ int haveZero= 0;
+ int haveWidth= 0;
+ int col;
+ SectionColumn * sc;
+
+ sc= sp->spColumns;
+ for ( col= 0; col < sp->spColumnCount; sc++, col++ )
+ {
+ if ( sc->scColumnWidthTwips == 0 )
+ { haveZero++; }
+ else{ haveWidth++; }
+ }
+
+ if ( haveZero && haveWidth )
+ {
+ sc= sp->spColumns;
+ for ( col= 0; col < sp->spColumnCount; sc++, col++ )
+ { sc->scColumnWidthTwips= 0; }
+ }
+ }
+
+ return;
+ }
+
+/************************************************************************/
+/* */
+/* Change section properties and tell what has been changed. */
+/* */
+/************************************************************************/
+
+int docUpdSectProperties( PropertyMask * pSpDoneMask,
+ SectionProperties * spTo,
+ const PropertyMask * spSetMask,
+ const SectionProperties * spSet )
+ {
+ PropertyMask doneMask;
+ int p;
+
+ utilPropMaskClear( &doneMask );
+
+ for ( p= 0; p < DocSectIntPropCount; p++ )
+ {
+ int prop= DocSectIntProps[p];
+ int oval;
+ int nval;
+
+ if ( ! PROPmaskISSET( spSetMask, prop ) )
+ { continue; }
+
+ oval= docGetSectionProperty( spTo, prop );
+ nval= docGetSectionProperty( spSet, prop );
+
+ if ( oval == nval )
+ { continue; }
+
+ if ( docSetSectionProperty( spTo, prop, nval ) )
+ { LLDEB(prop,nval); return -1; }
+
+ PROPmaskADD( &doneMask, prop );
+ }
+
+ if ( PROPmaskISSET( spSetMask, SPpropCOLUMN_COUNT ) )
+ {
+ if ( spTo->spColumnCount != spSet->spColumnCount )
+ {
+ if ( docSectionPropertiesSetColumnCount( spTo,
+ spSet->spColumnCount ) )
+ { LDEB(spSet->spColumnCount); return -1; }
+
+ PROPmaskADD( &doneMask, SPpropCOLUMN_COUNT );
+ }
+ }
+
+ if ( PROPmaskISSET( spSetMask, SPpropCOLUMNS ) )
+ {
+ int count;
+
+ if ( spTo->spColumnCount < spSet->spColumnCount )
+ { count= spTo->spColumnCount; }
+ else{ count= spSet->spColumnCount; }
+
+ if ( count > 1 )
+ {
+ const SectionColumn * scFrom= spSet->spColumns;
+ SectionColumn * scTo= spTo->spColumns;
+ int col;
+
+ for ( col= 0; col < count- 1; scTo++, scFrom++, col++ )
+ {
+ if ( scTo->scColumnWidthTwips != scFrom->scColumnWidthTwips )
+ {
+ scTo->scColumnWidthTwips= scFrom->scColumnWidthTwips;
+ PROPmaskADD( &doneMask, SPpropCOLUMNS );
+ }
+ if ( scTo->scSpaceToRightTwips != scFrom->scSpaceToRightTwips )
+ {
+ scTo->scSpaceToRightTwips= scFrom->scSpaceToRightTwips;
+ PROPmaskADD( &doneMask, SPpropCOLUMNS );
+ }
+ }
+ if ( scTo->scColumnWidthTwips != scFrom->scColumnWidthTwips )
+ {
+ scTo->scColumnWidthTwips= scFrom->scColumnWidthTwips;
+ PROPmaskADD( &doneMask, SPpropCOLUMNS );
+ }
+ }
+ }
+
+ docSectCheckFixedColumnWidth( spTo );
+
+ if ( pSpDoneMask )
+ { *pSpDoneMask= doneMask; }
+
+ return 0;
+ }
+
+void docSectPropertyDifference( PropertyMask * pDiffMask,
+ const SectionProperties * sp1,
+ const PropertyMask * cmpMask,
+ const SectionProperties * sp2 )
+ {
+ PropertyMask diffMask;
+ int p;
+
+ utilPropMaskClear( &diffMask );
+
+ for ( p= 0; p < DocSectIntPropCount; p++ )
+ {
+ int prop= DocSectIntProps[p];
+ int oval;
+ int nval;
+
+ if ( ! PROPmaskISSET( cmpMask, prop ) )
+ { continue; }
+
+ oval= docGetSectionProperty( sp1, prop );
+ nval= docGetSectionProperty( sp2, prop );
+
+ if ( oval == nval )
+ { continue; }
+
+ PROPmaskADD( &diffMask, prop );
+ }
+
+ if ( PROPmaskISSET( cmpMask, SPpropCOLUMNS ) )
+ {
+ int count;
+
+ if ( sp1->spColumnCount < sp2->spColumnCount )
+ { count= sp1->spColumnCount; }
+ else{ count= sp2->spColumnCount; }
+
+ if ( count > 1 )
+ {
+ const SectionColumn * sc1= sp1->spColumns;
+ const SectionColumn * sc2= sp2->spColumns;
+ int col;
+
+ for ( col= 0; col < count- 1; sc1++, sc2++, col++ )
+ {
+ if ( sc1->scColumnWidthTwips != sc2->scColumnWidthTwips )
+ { PROPmaskADD( &diffMask, SPpropCOLUMNS ); }
+ if ( sc1->scSpaceToRightTwips != sc2->scSpaceToRightTwips )
+ { PROPmaskADD( &diffMask, SPpropCOLUMNS ); }
+ }
+ if ( sc1->scColumnWidthTwips != sc2->scColumnWidthTwips )
+ { PROPmaskADD( &diffMask, SPpropCOLUMNS ); }
+ }
+ }
+
+ *pDiffMask= diffMask;
+ return;
+ }
+
+/************************************************************************/
+/* */
+/* Clean, Initialize section properties. */
+/* */
+/************************************************************************/
+
+void docCleanSectionProperties( SectionProperties * sp )
+ {
+ if ( sp->spColumns )
+ { free( sp->spColumns ); }
+
+ return;
+ }
+
+void docInitSectionProperties( SectionProperties * sp )
+ {
+ utilInitDocumentGeometry( &(sp->spDocumentGeometry) );
+
+ sp->spStyle= 0;
+
+ sp->spColumnSpacingTwips= DEF_GAP_WIDE;
+ sp->spLineBetweenColumns= 0;
+
+ sp->spHasTitlePage= 0;
+ sp->spBreakKind= DOCibkPAGE;
+ sp->spPageNumberStyle= DOCpgnDEC;
+ sp->spPageNumberHyphen= DOCpgnhPGNHNSH;
+ sp->spRestartPageNumbers= 0;
+
+ sp->spColumnCount= 1;
+ sp->spColumns= (SectionColumn *)0;
+
+ sp->spStartPageNumber= 0;
+
+ docInitFootEndNotesProperties( &(sp->spNotesProperties) );
+
+ return;
+ }
+
+int docSectionPropertiesSetColumnCount( SectionProperties * sp,
+ int n )
+ {
+ if ( n > 1 && sp->spColumnCount < n )
+ {
+ SectionColumn * sc= (SectionColumn *)realloc( sp->spColumns,
+ n* sizeof(SectionColumn) );
+ if ( ! sc )
+ { LXDEB(n,sc); return -1; }
+
+ sp->spColumns= sc;
+
+ if ( sp->spColumnCount == 1 )
+ {
+ sc->scSpaceToRightTwips= 0;
+ sc->scColumnWidthTwips= 0;
+ }
+
+ sc= sp->spColumns+ sp->spColumnCount;
+ while( sp->spColumnCount < n )
+ {
+ sc->scSpaceToRightTwips= 0;
+ sc->scColumnWidthTwips= 0;
+
+ sc++; sp->spColumnCount++;
+ }
+ }
+
+ sp->spColumnCount= n;
+ return 0;
+ }
+
+/************************************************************************/
+/* */
+/* Copy SectionProperties. */
+/* */
+/* NOTE that the headers and footers are not copied. */
+/* */
+/************************************************************************/
+
+int docCopySectionProperties( SectionProperties * to,
+ const SectionProperties * from )
+ {
+ int i;
+
+ if ( docSectionPropertiesSetColumnCount( to, from->spColumnCount ) )
+ { LDEB(from->spColumnCount); return -1; }
+
+ to->spDocumentGeometry= from->spDocumentGeometry;
+
+ to->spStyle= from->spStyle;
+
+ to->spColumnSpacingTwips= from->spColumnSpacingTwips;
+ to->spLineBetweenColumns= from->spLineBetweenColumns;
+
+ to->spHasTitlePage= from->spHasTitlePage;
+ to->spBreakKind= from->spBreakKind;
+ to->spPageNumberStyle= from->spPageNumberStyle;
+ to->spPageNumberHyphen= from->spPageNumberHyphen;
+ to->spRestartPageNumbers= from->spRestartPageNumbers;
+
+ to->spStartPageNumber= from->spStartPageNumber;
+
+ /* docSectionPropertiesSetColumnCount() has allocated the memory */
+ if ( from->spColumnCount > 1 )
+ {
+ for ( i= 0; i < from->spColumnCount; i++ )
+ { to->spColumns[i]= from->spColumns[i]; }
+ }
+
+ to->spNotesProperties= from->spNotesProperties;
+
+ docSectCheckFixedColumnWidth( to );
+
+ return 0;
+ }
+
+int docSectSetEqualColumnWidth( SectionProperties * sp )
+ {
+ int col;
+ SectionColumn * sc;
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+ int colWide;
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ if ( sp->spColumnCount < 2 )
+ { return pageWide; }
+
+ colWide= ( pageWide- ( sp->spColumnCount- 1 )*
+ sp->spColumnSpacingTwips )/ sp->spColumnCount;
+
+ sc= sp->spColumns;
+ for ( col= 0; col < sp->spColumnCount; sc++, col++ )
+ {
+ sc->scColumnWidthTwips= 0;
+ sc->scSpaceToRightTwips= 0;
+ }
+
+ return colWide;
+ }
+
+int docSectSetExplicitColumnWidth( SectionProperties * sp )
+ {
+ int col;
+ SectionColumn * sc;
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+ int colWide;
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ if ( sp->spColumnCount < 2 )
+ { LDEB(sp->spColumnCount); return -1; }
+
+ colWide= ( pageWide- ( sp->spColumnCount- 1 )*
+ sp->spColumnSpacingTwips )/ sp->spColumnCount;
+
+ if ( colWide < MIN_COL_WIDE )
+ { LLDEB(colWide,MIN_COL_WIDE); return -1; }
+
+ sc= sp->spColumns;
+ for ( col= 0; col < sp->spColumnCount; sc++, col++ )
+ {
+ sc->scColumnWidthTwips= colWide;
+ sc->scSpaceToRightTwips= sp->spColumnSpacingTwips;
+ }
+
+ return 0;
+ }
+
+/************************************************************************/
+/* */
+/* Determine the column margins. */
+/* */
+/* Because of gutters and/or mirrored margins, the page geometry is */
+/* not necessarily identical to that in the section properties. */
+/* */
+/************************************************************************/
+
+void docSectGetColumnX( int * pXLine,
+ int * pX0,
+ int * pX1,
+ const SectionProperties * sp,
+ const DocumentGeometry * dgPage,
+ int column )
+ {
+ int x0= dgPage->dgLeftMarginTwips;
+ int col;
+
+ if ( sp->spColumnCount < 2 )
+ {
+ *pX0= dgPage->dgLeftMarginTwips;
+ *pX1= dgPage->dgPageWideTwips- dgPage->dgRightMarginTwips;
+ return;
+ }
+
+ for ( col= 0; col < column; col++ )
+ {
+ if ( sp->spColumns[col].scColumnWidthTwips == 0 )
+ { break; }
+
+ x0 += sp->spColumns[col].scColumnWidthTwips;
+ x0 += sp->spColumns[col].scSpaceToRightTwips;
+ }
+
+ if ( col < column || sp->spColumns[column].scColumnWidthTwips == 0 )
+ {
+ int pageWide;
+ int colWide;
+
+ pageWide= dgPage->dgPageWideTwips-
+ dgPage->dgLeftMarginTwips- dgPage->dgRightMarginTwips;
+
+ colWide= ( pageWide- ( sp->spColumnCount- 1 )*
+ sp->spColumnSpacingTwips )/ sp->spColumnCount;
+
+ x0= dgPage->dgLeftMarginTwips+
+ column* ( colWide+ sp->spColumnSpacingTwips );
+
+ *pXLine= x0- sp->spColumnSpacingTwips/ 2;
+ *pX0= x0;
+ *pX1= x0+ colWide;
+ }
+ else{
+ if ( column == 0 )
+ {
+ *pXLine= x0- sp->spColumnSpacingTwips/ 2;
+ }
+ else{
+ *pXLine= x0- sp->spColumns[column-1].scSpaceToRightTwips/ 2;
+ }
+
+ *pX0= x0;
+ *pX1= x0+ sp->spColumns[column].scColumnWidthTwips;
+ }
+
+ return;
+ }
+
+/************************************************************************/
+/* */
+/* Set a section property. */
+/* */
+/************************************************************************/
+
+int docSetSectionProperty( SectionProperties * sp,
+ int prop,
+ int arg )
+ {
+ DocumentGeometry * dg= &(sp->spDocumentGeometry);
+
+ switch( prop )
+ {
+ case DGpropPAGE_WIDTH:
+ dg->dgPageWideTwips= arg;
+ break;
+ case DGpropPAGE_HEIGHT:
+ dg->dgPageHighTwips= arg;
+ break;
+
+ case DGpropLEFT_MARGIN:
+ dg->dgLeftMarginTwips= arg;
+ break;
+ case DGpropRIGHT_MARGIN:
+ dg->dgRightMarginTwips= arg;
+ break;
+ case DGpropTOP_MARGIN:
+ dg->dgTopMarginTwips= arg;
+ break;
+ case DGpropBOTTOM_MARGIN:
+ dg->dgBottomMarginTwips= arg;
+ break;
+
+ case DGpropHEADER_POSITION:
+ if ( arg != 0 )
+ { dg->dgHeaderPositionTwips= arg; }
+ break;
+ case DGpropFOOTER_POSITION:
+ if ( arg != 0 )
+ { dg->dgFooterPositionTwips= arg; }
+ break;
+
+ case DGpropGUTTER:
+ dg->dgGutterTwips= arg;
+ break;
+ case DGpropMARGMIR:
+ dg->dgMirrorMargins= arg != 0;
+ break;
+
+ case SPpropSTYLE:
+ sp->spStyle= arg;
+ break;
+
+ case SPpropTITLEPG:
+ sp->spHasTitlePage= ( arg != 0 );
+ break;
+
+ case SPpropBREAK_KIND:
+ sp->spBreakKind= arg;
+ break;
+
+ case SPpropNUMBER_STYLE:
+ sp->spPageNumberStyle= arg;
+ break;
+
+ case SPpropNUMBER_HYPHEN:
+ sp->spPageNumberHyphen= arg;
+ break;
+
+ case SPpropPAGE_RESTART:
+ sp->spRestartPageNumbers= arg;
+ break;
+
+ case SPpropSTART_PAGE:
+ sp->spStartPageNumber= arg;
+ break;
+
+ case SPpropCOLUMN_COUNT:
+ if ( docSectionPropertiesSetColumnCount( sp, arg ) )
+ { LDEB(arg); return -1; }
+ break;
+
+ case SPpropCOLUMN_SPACING:
+ sp->spColumnSpacingTwips= arg;
+ break;
+ case SPpropLINEBETCOL:
+ sp->spLineBetweenColumns= ( arg != 0 );
+ break;
+
+ /* FOOTNOTE */
+ case SPpropFOOTNOTE_STARTNR:
+ docSetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropSTARTNR, arg );
+ return 0;
+ case SPpropFOOTNOTE_JUSTIFICATION:
+ docSetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropJUSTIFICATION, arg );
+ return 0;
+ /* No
+ case SPpropFOOTNOTE_PLACEMENT:
+ docSetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropPLACEMENT, arg );
+ return 0;
+ */
+ case SPpropFOOTNOTE_RESTART:
+ docSetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropRESTART, arg );
+ return 0;
+ case SPpropFOOTNOTE_STYLE:
+ docSetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropSTYLE, arg );
+ return 0;
+
+ /* ENDNOTE */
+ case SPpropENDNOTE_STARTNR:
+ docSetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropSTARTNR, arg );
+ return 0;
+ /* No
+ case SPpropENDNOTE_JUSTIFICATION:
+ docSetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropJUSTIFICATION, arg );
+ return 0;
+ */
+ /* No
+ case SPpropENDNOTE_PLACEMENT:
+ docSetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropPLACEMENT, arg );
+ return 0;
+ */
+ case SPpropENDNOTE_RESTART:
+ docSetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropRESTART, arg );
+ return 0;
+ case SPpropENDNOTE_STYLE:
+ docSetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropSTYLE, arg );
+ return 0;
+
+
+ default:
+ LLDEB(prop,arg); return -1;
+ }
+
+ return 0;
+ }
+
+/************************************************************************/
+/* */
+/* Get a section property. */
+/* */
+/************************************************************************/
+
+int docGetSectionProperty( const SectionProperties * sp,
+ int prop )
+ {
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+
+ switch( prop )
+ {
+ case DGpropPAGE_WIDTH:
+ return dg->dgPageWideTwips;
+ case DGpropPAGE_HEIGHT:
+ return dg->dgPageHighTwips;
+
+ case DGpropLEFT_MARGIN:
+ return dg->dgLeftMarginTwips;
+ case DGpropRIGHT_MARGIN:
+ return dg->dgRightMarginTwips;
+ case DGpropTOP_MARGIN:
+ return dg->dgTopMarginTwips;
+ case DGpropBOTTOM_MARGIN:
+ return dg->dgBottomMarginTwips;
+
+ case DGpropHEADER_POSITION:
+ return dg->dgHeaderPositionTwips;
+ case DGpropFOOTER_POSITION:
+ return dg->dgFooterPositionTwips;
+
+ case DGpropGUTTER:
+ return dg->dgGutterTwips;
+ case DGpropMARGMIR:
+ return dg->dgMirrorMargins;
+
+ case SPpropSTYLE:
+ return sp->spStyle;
+
+ case SPpropTITLEPG:
+ return sp->spHasTitlePage;
+
+ case SPpropBREAK_KIND:
+ return sp->spBreakKind;
+
+ case SPpropNUMBER_STYLE:
+ return sp->spPageNumberStyle;
+
+ case SPpropNUMBER_HYPHEN:
+ return sp->spPageNumberHyphen;
+
+ case SPpropPAGE_RESTART:
+ return sp->spRestartPageNumbers;
+
+ case SPpropSTART_PAGE:
+ return sp->spStartPageNumber;
+
+ case SPpropCOLUMN_COUNT:
+ return sp->spColumnCount;
+
+ case SPpropCOLUMN_SPACING:
+ return sp->spColumnSpacingTwips;
+ break;
+ case SPpropLINEBETCOL:
+ return sp->spLineBetweenColumns;
+ break;
+
+ /* FOOTNOTE */
+ case SPpropFOOTNOTE_STARTNR:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropSTARTNR );
+ return 0;
+ case SPpropFOOTNOTE_JUSTIFICATION:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropJUSTIFICATION );
+ return 0;
+ /* No
+ case SPpropFOOTNOTE_PLACEMENT:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropPLACEMENT );
+ return 0;
+ */
+ case SPpropFOOTNOTE_RESTART:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropRESTART );
+ return 0;
+ case SPpropFOOTNOTE_STYLE:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepFootnotesProps),
+ NOTESpropSTYLE );
+ return 0;
+
+ /* ENDNOTE */
+ case SPpropENDNOTE_STARTNR:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropSTARTNR );
+ return 0;
+ /* No
+ case SPpropENDNOTE_JUSTIFICATION:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropJUSTIFICATION );
+ return 0;
+ */
+ /* No
+ case SPpropENDNOTE_PLACEMENT:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropPLACEMENT );
+ return 0;
+ */
+ case SPpropENDNOTE_RESTART:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropRESTART );
+ return 0;
+ case SPpropENDNOTE_STYLE:
+ return docGetNotesProperty( &(sp->spNotesProperties.fepEndnotesProps),
+ NOTESpropSTYLE );
+ return 0;
+
+
+ default:
+ LDEB(prop); return -1;
+ }
+
+ return 0;
+ }
+/************************************************************************/
+/* */
+/* Return the sum of the other widths in a section with explicit */
+/* column layout. Additionally, assign a victim whose column width can */
+/* be narrowed to allocate extra space. */
+/* */
+/* The maximum value is the value that leaves MIN_COL_WIDE as the */
+/* column width of the victim. */
+/* */
+/************************************************************************/
+
+static int docSectColsSumOthers( int * pVictim,
+ int * pMaxValue,
+ const SectionProperties * sp,
+ int col,
+ int colOther )
+ {
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+
+ int sumOthers= 0;
+ int i;
+
+ int victim;
+ int left;
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ for ( i= 0; i < sp->spColumnCount- 1; i++ )
+ {
+ if ( i == col )
+ { continue; }
+
+ sumOthers += sp->spColumns[i].scColumnWidthTwips;
+ sumOthers += sp->spColumns[i].scSpaceToRightTwips;
+ }
+
+ if ( i != col )
+ { sumOthers += sp->spColumns[i].scColumnWidthTwips; }
+
+ sumOthers += colOther;
+
+ if ( col == sp->spColumnCount- 1 )
+ { victim= sp->spColumnCount-2; }
+ else{ victim= sp->spColumnCount-1; }
+
+ left= sp->spColumns[victim].scColumnWidthTwips- MIN_COL_WIDE;
+
+ if ( pVictim )
+ { *pVictim= victim; }
+ if ( pMaxValue )
+ { *pMaxValue= pageWide- sumOthers+ left; }
+
+ return sumOthers;
+ }
+
+/************************************************************************/
+/* */
+/* Claim extra space by subtracting it from the column width of the */
+/* victim. Applies for explicit column layout only. */
+/* */
+/************************************************************************/
+
+static int docSectReserveWidth( SectionProperties * sp,
+ int victim,
+ int sumValues )
+ {
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ if ( sumValues > pageWide )
+ {
+ int narrowed;
+
+ narrowed= pageWide- sumValues+ sp->spColumns[victim].scColumnWidthTwips;
+ if ( narrowed < MIN_COL_WIDE )
+ { LDEB(narrowed); return -1; }
+
+ sp->spColumns[victim].scColumnWidthTwips= narrowed;
+ }
+
+ return 0;
+ }
+
+/************************************************************************/
+
+static void docSectGetEqualWidths(
+ int * pColWide,
+ int * pGapWide,
+ int * pMaxColWide,
+ int * pMaxGapWide,
+ const SectionProperties * sp )
+ {
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+
+ int colWide;
+ int maxColWide;
+ int gapWide;
+ int maxGapWide;
+
+ int ncol= sp->spColumnCount;
+ int ngap= sp->spColumnCount- 1;
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ colWide= ( pageWide- ngap* sp->spColumnSpacingTwips )/ ncol;
+ maxColWide= ( pageWide- ngap* MIN_GAP_WIDE )/ ncol;
+
+ gapWide= sp->spColumnSpacingTwips;
+ if ( ngap == 0 )
+ { maxGapWide= 0; }
+ else{ maxGapWide= ( pageWide- ncol* MIN_COL_WIDE )/ ngap; }
+
+ if ( pColWide )
+ { *pColWide= colWide; }
+ if ( pGapWide )
+ { *pGapWide= gapWide; }
+ if ( pMaxColWide )
+ { *pMaxColWide= maxColWide; }
+ if ( pMaxGapWide )
+ { *pMaxGapWide= maxGapWide; }
+
+ return;
+ }
+
+/************************************************************************/
+/* */
+/* Get the spacing right of a column. */
+/* */
+/************************************************************************/
+
+int docSectGetColumnSpacing( int * pMinValue,
+ int * pMaxValue,
+ const SectionProperties * sp,
+ int col )
+ {
+ int value;
+ int maxValue;
+
+ int haveFixedWidth;
+
+ haveFixedWidth= docSectPropsFixedWidthColumns( sp );
+
+ if ( haveFixedWidth )
+ { docSectGetEqualWidths( (int *)0, &value, (int *)0, &maxValue, sp ); }
+ else{
+ docSectColsSumOthers( (int *)0, &maxValue,
+ sp, col, sp->spColumns[col].scColumnWidthTwips );
+
+ value= sp->spColumns[col].scSpaceToRightTwips;
+ }
+
+ if ( pMaxValue )
+ { *pMaxValue= maxValue; }
+ if ( pMinValue )
+ { *pMinValue= MIN_GAP_WIDE; }
+
+ return value;
+ }
+
+/************************************************************************/
+/* */
+/* Set the spacing right of a column. */
+/* */
+/************************************************************************/
+
+int docSectSetColumnSpacing( SectionProperties * sp,
+ int col,
+ int newValue )
+ {
+ int maxValue;
+ int haveFixedWidth;
+
+ haveFixedWidth= docSectPropsFixedWidthColumns( sp );
+
+ if ( haveFixedWidth )
+ {
+ if ( col > 0 )
+ { LLLDEB(haveFixedWidth,col,newValue); return -1; }
+
+ docSectGetEqualWidths( (int *)0, (int *)0, (int *)0, &maxValue, sp );
+ if ( newValue < MIN_GAP_WIDE || newValue > maxValue )
+ { LLDEB(newValue,maxValue); return -1; }
+
+ sp->spColumnSpacingTwips= newValue;
+ }
+ else{
+ int victim;
+ int sumOthers;
+
+ sumOthers= docSectColsSumOthers( &victim, &maxValue,
+ sp, col, sp->spColumns[col].scColumnWidthTwips );
+
+ if ( newValue < MIN_GAP_WIDE || newValue > maxValue )
+ { LLDEB(newValue,maxValue); return -1; }
+ if ( victim == col )
+ { LLDEB(victim,col); return -1; }
+
+ if ( docSectReserveWidth( sp, victim, sumOthers+ newValue ) )
+ { LLDEB(sumOthers,newValue); return -1; }
+
+ sp->spColumns[col].scSpaceToRightTwips= newValue;
+ }
+
+ return 0;
+ }
+
+/************************************************************************/
+/* */
+/* Get the spacing right of a column. */
+/* */
+/************************************************************************/
+
+int docSectGetColumnWidth( int * pMinValue,
+ int * pMaxValue,
+ const SectionProperties * sp,
+ int col )
+ {
+ int value;
+ int maxValue;
+
+ int haveFixedWidth;
+
+ haveFixedWidth= docSectPropsFixedWidthColumns( sp );
+
+ if ( haveFixedWidth )
+ {
+ docSectGetEqualWidths( &value, (int *)0, &maxValue, (int *)0, sp );
+ }
+ else{
+ docSectColsSumOthers( (int *)0, &maxValue,
+ sp, col, sp->spColumns[col].scSpaceToRightTwips );
+
+ value= sp->spColumns[col].scColumnWidthTwips;
+ }
+
+ if ( pMinValue )
+ { *pMinValue= MIN_COL_WIDE; }
+ if ( pMaxValue )
+ { *pMaxValue= maxValue; }
+
+ return value;
+ }
+
+/************************************************************************/
+/* */
+/* Set the spacing right of a column. */
+/* */
+/************************************************************************/
+
+int docSectSetColumnWidth( SectionProperties * sp,
+ int col,
+ int newValue )
+ {
+ int maxValue;
+ int haveFixedWidth;
+
+ haveFixedWidth= docSectPropsFixedWidthColumns( sp );
+
+ if ( haveFixedWidth )
+ {
+ const DocumentGeometry * dg= &(sp->spDocumentGeometry);
+ int pageWide;
+ int gapWide;
+
+ docSectGetEqualWidths( (int *)0, &gapWide, &maxValue, (int *)0, sp );
+
+ if ( newValue < MIN_COL_WIDE || newValue > maxValue )
+ { LLDEB(newValue,maxValue); return -1; }
+
+ pageWide= dg->dgPageWideTwips-
+ dg->dgLeftMarginTwips- dg->dgRightMarginTwips;
+
+ gapWide= ( pageWide- ( sp->spColumnCount* newValue ) )/
+ ( sp->spColumnCount- 1 );
+ if ( gapWide < MIN_GAP_WIDE )
+ { LLDEB(gapWide,MIN_GAP_WIDE); gapWide= MIN_GAP_WIDE; }
+
+ sp->spColumnSpacingTwips= gapWide;
+ }
+ else{
+ int victim;
+ int sumOthers;
+
+ sumOthers= docSectColsSumOthers( &victim, &maxValue,
+ sp, col, sp->spColumns[col].scSpaceToRightTwips );
+
+ if ( newValue < MIN_COL_WIDE || newValue > maxValue )
+ { LLDEB(newValue,maxValue); return -1; }
+ if ( victim == col )
+ { LLDEB(victim,col); return -1; }
+
+ if ( docSectReserveWidth( sp, victim, sumOthers+ newValue ) )
+ { LLDEB(sumOthers,newValue); return -1; }
+
+ sp->spColumns[col].scColumnWidthTwips= newValue;
+ }
+
+ return 0;
+ }