able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/richedit/lssrc/warichu.c

4520 lines
123 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/* ---------------------------------------------------------------
: LineServices 3.0
:
: WARICHU ("Two lines in one" in Winword)
:
: Object Handler Routines
:
: Contact: AntonS
:
------------------------------------------------------------------ */
#include "lsmem.h"
#include "limits.h"
#include "warichu.h"
#include "objhelp.h"
#include "lsesc.h"
#include "lscbk.h"
#include "lsdevres.h"
#include "pdobj.h"
#include "objdim.h"
#include "plssubl.h"
#include "plsdnode.h"
#include "pilsobj.h"
#include "lscrsubl.h"
#include "lssubset.h"
#include "lsdnset.h"
#include "zqfromza.h"
#include "lstfset.h"
#include "lsdocinf.h"
#include "fmti.h"
#include "posichnk.h"
#include "locchnk.h"
#include "lsdnfin.h"
#include "brko.h"
#include "lspap.h"
#include "plspap.h"
#include "lsqsubl.h"
#include "dispi.h"
#include "lsdssubl.h"
#include "dispmisc.h"
#include "lstfset.h"
#include "brkkind.h"
#include "lschp.h"
/* REVIEW (antons):
- Assert that FormatUntilCpBreak fSuccessful
- Assimetry between Prev and Next BreakWarichuDobj: it looks like
right margin as input to Next break may also optimize truncation.
- In ForceBreak it may happen that dur < 0: What is the correct thing to do?
- Invalid pdobj.wlayout when wwhole is not finished: dur must be
set correctly.
- Can I assert that if subline was stopped at fmtrExceededMargin,
dur > RM.
- Should ForceBreak return correct previous break if possible?
- I rely on the following axiom:
If Warichu returned fmtrExceedMargin, it must be broken
inside (brkkind != brkkindImposedAfter)
- Mod width: check method(s); should I count m-w in Warichu Truncation / Breaking
- Optimization of allocating WBRKREC
- To have function GetDcpWarichu (additionally to GetCpLimOfWLayout)
- Do something with FOpenBraceWLayout
- Queries: callback to client saying where to snap?
- Sergey: Assert in AdjustText & submitted sublines.
*/
/**********************************/
/* */
/* WARICHU Array of break records */
/* */
/**********************************/
typedef struct wbrkarray
{
DWORD nBreakRec; /* Actual number of break records in the array */
DWORD nBreakRecMax; /* Size of allocated array */
BREAKREC * rgBreakRec; /* Ls array of break records */
/* Note: Field nBreakRec is maintained by clients of this structure
and it must be <= nBreakRecMax. nBreakRecMax and rgBreakRec
are set during allocation */
} WBRKARRAY;
typedef WBRKARRAY *PWBRKARRAY;
/****************************/
/* */
/* WARICHU Installed LS Obj */
/* */
/****************************/
typedef struct ilsobj
{
POLS pols;
struct lscbk lscbk;
PLSC plsc;
DWORD idobj;
LSDEVRES lsdevres;
LSESC lsescBraceOpen;
LSESC lsescText;
LSESC lsescBraceClose;
WARICHUCBK warichucbk; /* Callbacks to client application */
BOOL fContiguousFetch; /* This flag was added to fix Word 9 bug */
} ILSOBJ;
/****************************/
/* */
/* WARICHU Internal Subline */
/* */
/****************************/
typedef struct wsubline
{
PLSSUBL plssubl; /* Pointer to LS Subline */
OBJDIM objdim; /* Dimensions of this subline */
LSCP cpFirst; /* cp where formatting of this subline started */
LSCP cpLim; /* cp-lim after formatting */
/* Note: One exception when objdim & cpLim does not correspond to the
dimensions of the subline is the second subline in the Broken Warichu
before SetBreak. We lie putting objdim & cpLim of
already broken subline. Durig Warichu SetBreak we call
LsSetBreakSubline (plssubl...) and the lie turnes into the truth
*/
} WSUBLINE;
typedef WSUBLINE *PWSUBLINE;
/****************************/
/* */
/* WARICHU Formatted Brace */
/* */
/****************************/
typedef struct wbrace
{
PLSSUBL plssubl; /* Pointer to Ls subline with brace */
OBJDIM objdim; /* Dimensions of the subline */
LSCP cpFirst; /* cp-start formatting */
LSCP cpLim; /* cp-lim after formatting */
LSCP cpLimAfterEsc; /* cp-lim after brace ESC character (in our case cpLim + 1) */
} WBRACE;
typedef WBRACE *PBRACE;
/**********************/
/* */
/* WARICHU Dimensions */
/* */
/**********************/
typedef struct wdim
{
OBJDIM objdimAll; /* Dimensions of the whole Warichu */
long dvpDescentReserved; /* Received from client together with objdimAll */
/* REVIEW (antons): Clean this logic of calculating
relative positions of warichu sublines */
} WDIM;
/************************/
/* */
/* WARICHU Layout */
/* */
/************************/
typedef struct wlayout
{
WSUBLINE wsubline1; /* First subline in the layout (NULL if layout not valid) */
WSUBLINE wsubline2; /* Second subline in the layout (NULL if no second line) */
BOOL fBroken; /* Broken or whole Warichu? */
BRKKIND brkkind; /* Kind of break to set at the end of second line if "Broken" */
/* Note: Although the following fields can be calculated using above data
and DOBJ, it is filled by FinishObjDimLayout and nobody has the right
to recalc it on his own way after it has been set.
*/
WDIM wdim; /* Dimensions of the whole Warichu */
} WLAYOUT;
typedef WLAYOUT *PWLAYOUT;
/****************************/
/* */
/* WARICHU Kind of break */
/* */
/****************************/
typedef enum wbreaktype
{
wbreaktypeInside,
wbreaktypeAfter,
wbreaktypeInvalid
} WBREAKTYPE;
/******************************************/
/* */
/* Presentation Data for Warichu sublines */
/* */
/******************************************/
typedef struct wdispsubl
{
long dup; /* Dup of subline */
POINTUV duvStart; /* Relative (from object start) position of subline */
/* (in lstflow of the parent) */
} WDISPSUBL;
typedef WDISPSUBL *PWDISPSUBL;
/******************************************/
/* */
/* Presentation Data for Warichu braces */
/* */
/******************************************/
typedef WDISPSUBL WDISPBRACE; /* Same as display information for sublines */
typedef WDISPBRACE *PWDISPBRACE;
/*****************************/
/* */
/* WARICHU Presentation Data */
/* */
/*****************************/
typedef struct wdisplay
{
WDISPSUBL wdispsubl1; /* Display information about Warichu first subline */
WDISPSUBL wdispsubl2; /* Display information about Warichu second subline */
WDISPBRACE wdispbraceOpen; /* Display information about Open brace */
WDISPBRACE wdispbraceClose; /* Display information about Closing brace */
long dvpBetween; /* REVIEW (antons): Do I need to store this? ;-) */
long dupAll; /* REVIEW (antons): Do I need to store this? ;-) */
} WDISPLAY;
/****************************/
/* */
/* WARICHU Whole subline */
/* */
/****************************/
typedef struct wwhole
{
PLSSUBL plssubl; /* Whole formatted subline */
LSCP cpFirst; /* Cp first of the subline */
LSCP cpLim; /* Cp lim of the subline */
OBJDIM objdim; /* Dimensions of the formatted subline */
long urColumnMax; /* Column Max until we formatted the WHOLE line */
/* REVIEW (antons): Do we need this? */
BOOL fFinished; /* If we have reached ESC character during formatting */
/* REVIEW (antons): It seems now I can leave without cpTruncate at all */
LSCP cpTruncate; /* Truncation point at urColumnMax if fFinished = FALSE */
LSCP cpLimAfterEsc; /* First character after ESC if fFinished = TRUE */
BOOL fJisRangeKnown; /* Did we calculate cpJisRangeFirst & cpJisRangeLim? */
/* The following two variables are valid only when "fJisRangeKnown == TRUE" */
LSCP cpJisRangeFirst; /* 4-th cpBreak break from the start of the WWhole subline */
LSCP cpJisRangeLim; /* 4-th cpBreak break from the end of WWhole subline */
/* Note 1: Jis Range empty when cpJisRangeFirst >= cpJisRangeLim */
/* Note 2: Jis Range defines possible set of Warichu breaks according
to JIS rule about 4 break opportunities before / after break.
If cp belong to JisRange (cpJisRangeFirst <= cp < cpJisRangeLim)
it means that there are 4 break opportunities before / after cp. */
/* Note 3: Jis Range is calculated only when neccesary (during breaking). After
formatting fJisRangeKnown==FALSE. When someone need Jis Range during
breaking, he should call CalcJisRange().
*/
} WWHOLE;
typedef WWHOLE *PWWHOLE;
/***************************/
/* */
/* WARICHU DOBJ structure */
/* */
/***************************/
struct dobj
{
/* 1. Dobj life-time constant data */
PILSOBJ pilsobj; /* Pointer to ILS object */
PLSDNODE plsdnTop; /* Warichu parent DNode */
LSCP cpStart; /* Starting LS cp for object */
LSCP cpStartObj; /* Starting cp for object. If not Resumed => cpStartObj == cpStart */
BOOL fResumed; /* If Warichu was resumed */
/* REVIEW (antons): Can I assert that fResumed == (cpStart == cpStartObj) */
LSTFLOW lstflowParent; /* Lstflow of the parent subline */
/* 2. Formattig + Breaking + Displaying */
WLAYOUT wlayout; /* Current layout after Formatting / SetBreak */
WBRACE wbraceOpen; /* Opening brace */
WBRACE wbraceClose; /* Closing brace */
/* 3. Breaking */
WBRKARRAY wbrkarrayAtStart;
/* Break records at line start */
/* (if !fResumed => zero # of break records) */
WWHOLE wwhole; /* Structure containing warichu whole subline */
WLAYOUT wlayoutBreak [NBreaksToSave];
/* 3 break records for Prev / Next / Force */
WLAYOUT wlayoutTruncate; /* Optimization: we save the layout after Truncation */
WBREAKTYPE wbreaktype [NBreaksToSave];
/* 4. Displaying */
WDISPLAY wdisplay; /* Presentation info for current layout (valid after CalcPres) */
} DOBJ;
/***************************/
/* */
/* Some macors */
/* */
/***************************/
#define INT_UNDEFINED 0xFFFFFFFF
#define CP_MAX LONG_MAX
#define abs(x) ((x)<0 ? -(x) : (x))
#define max(a,b) ((a) > (b) ? (a) : (b))
#define ZeroObjDim(pobjdim) memset ((pobjdim), 0, sizeof(OBJDIM));
#define NOT !
/* O V E R F L O W S A F E A R I T H M E T I C S */
/*----------------------------------------------------------------------------
%%Functions: ADDLongSafe, MULLongSafe
%%Contact: antons
Calculations with urColumnMax require special treatment because
of possible overflow. Two functions below implement overflow-safe
arithmetics for ADD and MUL on positive (>=0) numbers.
----------------------------------------------------------------------------*/
/* ADDLongSafe: X + Y */
long ADDLongSafe (long x, long y)
{
Assert (x >= 0 && y >= 0);
if (x > LONG_MAX - y) return LONG_MAX;
else
return x + y;
}
/* MULLongSafe: X * Y */
long MULLongSafe (long x, long y)
{
Assert (x >= 0 && y >= 0);
if (y == 0) return 0;
else if (x > LONG_MAX / y) return LONG_MAX;
else
return x * y;
}
/* W A F I N D N E X T B R E A K S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaFindNextBreakSubline
%%Contact: antons
Wrapper to LsFindNextBreakSubline () API. It makes sure that result is
monotonous.
----------------------------------------------------------------------------*/
LSERR WaFindNextBreakSubline (
PLSSUBL plssubl,
LSCP cpTruncate,
long urColumnMax,
BOOL * pfSuccessful,
LSCP * pcpBreak,
POBJDIM pobjdimSubline )
{
BRKPOS brkpos;
LSERR lserr = LsFindNextBreakSubline ( plssubl,
TRUE,
cpTruncate,
urColumnMax,
pfSuccessful,
pcpBreak,
pobjdimSubline,
& brkpos );
if (lserr != lserrNone) return lserr;
if (* pfSuccessful)
{
/* REVIEW (antons): Maybe still better have a loop for crazy case? */
Assert (*pcpBreak > cpTruncate);
/* REVIEW (antons): Check this Assert with Igor */
Assert (brkpos != brkposBeforeFirstDnode);
if (brkpos == brkposAfterLastDnode) *pfSuccessful = FALSE;
};
return lserrNone;
}
/* W A F I N D N E X T B R E A K S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaFindPrevBreakSubline
%%Contact: antons
Wrapper to LsForceBreakSubline () API. It makes sure that result is
monotonous.
----------------------------------------------------------------------------*/
LSERR WaFindPrevBreakSubline (
PLSSUBL plssubl,
LSCP cpTruncate,
long urColumnMax,
BOOL * pfSuccessful,
LSCP * pcpBreak,
POBJDIM pobjdimSubline )
{
BRKPOS brkpos;
LSCP cpTruncateLoop;
LSERR lserr = LsFindPrevBreakSubline ( plssubl,
TRUE,
cpTruncate,
urColumnMax,
pfSuccessful,
pcpBreak,
pobjdimSubline,
& brkpos );
if (lserr != lserrNone) return lserr;
if (! *pfSuccessful) return lserrNone;
/* Successful => check monotonous and break "after"*/
cpTruncateLoop = cpTruncate;
while (brkpos == brkposAfterLastDnode || *pcpBreak > cpTruncate)
{
/* Break is to the right from truncation point or
after the subline. Have to try another Prev Break
*/
/* REVIEW (antons): Can I ever repeat this loop more then once? */
cpTruncateLoop --;
lserr = LsFindPrevBreakSubline ( plssubl,
TRUE,
cpTruncateLoop,
urColumnMax,
pfSuccessful,
pcpBreak,
pobjdimSubline,
& brkpos );
if (! *pfSuccessful) return lserrNone;
};
if (brkpos == brkposBeforeFirstDnode)
{
*pfSuccessful = FALSE;
return lserrNone;
};
Assert (*pfSuccessful);
Assert (brkpos == brkposInside);
Assert (*pcpBreak <= cpTruncate);
return lserrNone;
}
/* W A F O R C E B R E A K S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaForceForceBreakSubline
%%Contact: antons
Wrapper to LsForceBreakSubline () API.
----------------------------------------------------------------------------*/
LSERR WaForceBreakSubline ( PLSSUBL plssubl,
LSCP cpTruncate,
long dur,
LSCP * cpEnd,
BRKPOS * pbrkpos,
POBJDIM pobjdim )
{
LSERR lserr;
lserr = LsForceBreakSubline ( plssubl, TRUE, cpTruncate, dur, cpEnd, pobjdim,
pbrkpos );
return lserr;
}
/* W A D E S T R O Y S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaDestroySubline
%%Contact: antons
Wrapper to LsDestroySubline () API.
----------------------------------------------------------------------------*/
LSERR WaDestroySubline (PLSSUBL plssubl)
{
if (plssubl != NULL) return LsDestroySubline (plssubl);
else
return lserrNone;
}
/* W A M A T C H P R E S S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaMatchPresSubline
%%Contact: antons
Wrapper to LsMatchPresSubline () API.
----------------------------------------------------------------------------*/
LSERR WaMatchPresSubline (PLSSUBL plssubl, long *pdup)
{
LSERR lserr;
BOOL fDone;
LSTFLOW lstflowUnused;
lserr = LssbFDonePresSubline (plssubl, &fDone);
if (lserr != lserrNone) return lserr;
if (!fDone) lserr = LsMatchPresSubline (plssubl);
if (lserr != lserrNone) return lserr; /* ;-) */
lserr = LssbGetDupSubline (plssubl, &lstflowUnused, pdup);
return lserr;
}
/* W A E X P A N D S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: WaExpandSubline
%%Contact: antons
Wrapper to LsExpandSubline () API.
----------------------------------------------------------------------------*/
LSERR WaExpandSubline ( PLSSUBL plssubl,
LSKJUST lskjust,
long dupExpand,
long * pdupSubline )
{
LSERR lserr;
LSTFLOW lstflowUnused;
Unreferenced (dupExpand);
Unreferenced (lskjust);
lserr = LsExpandSubline (plssubl, lskjust, dupExpand);
if (lserr != lserrNone) return lserr;
lserr = LssbGetDupSubline (plssubl, &lstflowUnused, pdupSubline);
return lserr;
}
/* S E T B R E A K W S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: SetBreakWSubline
%%Contact: antons
Wrapper to LsSetBreakSubline () API for wsubline. Procedure changes
objdim and cpLim of wsubline.
----------------------------------------------------------------------------*/
static LSERR SetBreakWSubline (
PWSUBLINE pwsubline, /* (IN): Subline to set break */
BRKKIND brkkind, /* (IN): Kind of break to set */
LSCP cpLimBreak, /* (IN): Cp-lim of the broken subline */
POBJDIM pobjdimBreak, /* (IN): Dimensions of the broken subline */
PWBRKARRAY pwbrkarray) /* (OUT): Array of break records */
{
LSERR lserr;
lserr = LsSetBreakSubline ( pwsubline->plssubl,
brkkind,
pwbrkarray->nBreakRecMax,
pwbrkarray->rgBreakRec,
& pwbrkarray->nBreakRec );
pwsubline->objdim = * pobjdimBreak;
pwsubline->cpLim = cpLimBreak;
#ifdef DEBUG
/* Check that pobjdimBreak contains correct dimensions of the broken subline */
{
OBJDIM objdimSubline;
LSTFLOW lstflowSubline;
lserr = LssbGetObjDimSubline (pwsubline->plssubl, &lstflowSubline, &objdimSubline);
if (lserr != lserrNone) return lserr;
Assert (memcmp (&objdimSubline, pobjdimBreak, sizeof(OBJDIM)) == 0);
}
#endif // DEBUG
return lserr;
}
/* C L E A R ... */
/*----------------------------------------------------------------------------
%%Function: Clear...
%%Contact: antons
Set of procedures to clear all references from different warichu
data structures.
----------------------------------------------------------------------------*/
#define ClearWSubline(pwsubline) (pwsubline)->plssubl = NULL;
#define ClearWBrkArray(pwbrkarray) (pwbrkarray)->rgBreakRec = NULL;
#define ClearWBrace(pwbrace) (pwbrace)->plssubl = NULL;
#define ClearWWhole(pwwhole) (pwwhole)->plssubl = NULL;
static void ClearWLayout (PWLAYOUT pwlayout)
{
ClearWSubline (&pwlayout->wsubline1);
ClearWSubline (&pwlayout->wsubline2);
}
#define FWLayoutValid(pwlayout) ((pwlayout)->wsubline1.plssubl != NULL)
#define InvalidateWLayout(pwlayout) (pwlayout)->wsubline1.plssubl = NULL;
/* REVIEW (antons): Maybe we should have more clean def of "invalid" wlayout? */
/* Note: I do not have ClearDobj () because Warichu Dobj gets cleaned in NewDobj */
/* N E W W B R K A R R A Y C O P Y */
/*----------------------------------------------------------------------------
%%Function: NewWBrkArrayCopy
%%Contact: antons
Copy constructor for WBrkArray. Receives array of break records to
store in WBrkArray structure. Important: There is another constructor
of WBrkArray so any change here may require adjusting of another
procedure.
----------------------------------------------------------------------------*/
static LSERR NewWBrkArrayCopy (
PDOBJ pdobj, /* (IN): Warichu Dobj */
DWORD nBreakRec, /* (IN): Number of break records in array */
const BREAKREC
* rgBreakRec, /* (IN): Array of break records */
PWBRKARRAY pwbrkarray ) /* (OUT): Initialized (allocated) structure */
{
PILSOBJ pilsobj = pdobj->pilsobj;
if (nBreakRec != 0)
{
pwbrkarray->rgBreakRec = AllocateMemory (pilsobj, nBreakRec * sizeof(BREAKREC));
if (pwbrkarray->rgBreakRec == NULL)
{
return lserrOutOfMemory;
};
pwbrkarray->nBreakRecMax = nBreakRec;
pwbrkarray->nBreakRec = nBreakRec;
/* Copy contents of the input array to the WBrkArray data structure */
memcpy (pwbrkarray->rgBreakRec, rgBreakRec, nBreakRec * sizeof(BREAKREC));
}
else
{
/* nBreakRec == 0 */
pwbrkarray->rgBreakRec = NULL;
pwbrkarray->nBreakRecMax = 0;
pwbrkarray->nBreakRec = 0;
};
return lserrNone;
}
/* N E W W B R K A R R A Y */
/*----------------------------------------------------------------------------
%%Function: NewWBreakArray
%%Contact: antons
Constructor for WBrkArray. Allocate number of break records according
to LsdnGetFormatDepth (...). Important: There is another constructor
of WBrkArray so any change here may require adjusting of another procedure.
----------------------------------------------------------------------------*/
static LSERR NewWBrkArray (
PDOBJ pdobj, /* (IN): Warichu Dobj */
PWBRKARRAY pwbrarray ) /* (OUT): Initialized (allocated) structure */
{
LSERR lserr;
PILSOBJ pilsobj = pdobj->pilsobj;
DWORD nBreakRecMax;
lserr = LsdnGetFormatDepth (pilsobj->plsc, & nBreakRecMax);
if (lserr != lserrNone)
{
pwbrarray->rgBreakRec = NULL;
return lserr;
};
pwbrarray->rgBreakRec = AllocateMemory (pilsobj, nBreakRecMax * sizeof(BREAKREC));
if (pwbrarray->rgBreakRec == NULL) return lserrOutOfMemory;
pwbrarray->nBreakRecMax = nBreakRecMax;
pwbrarray->nBreakRec = 0; /* Initialization - no b.r. */
return lserrNone;
}
/* D E S T R O Y W B R K A R R A Y */
/*----------------------------------------------------------------------------
%%Function: DestroyWBrkArray
%%Contact: antons
Destroy WBRKARRAY structure.
----------------------------------------------------------------------------*/
static void DestroyWBrkArray (PDOBJ pdobj, PWBRKARRAY pwbrkarray)
{
PILSOBJ pilsobj = pdobj->pilsobj;
if (pwbrkarray->rgBreakRec != NULL)
{
FreeMemory (pilsobj, pwbrkarray->rgBreakRec);
pwbrkarray->rgBreakRec = NULL;
};
}
/* D E S T R O Y W L A Y O U T */
/*----------------------------------------------------------------------------
%%Function: Destroywlayout
%%Contact: antons
Destroy sublines stored in the layout record
----------------------------------------------------------------------------*/
static LSERR DestroyWLayout (PWLAYOUT pwlayout)
{
LSERR lserr1, lserr2;
lserr1 = WaDestroySubline (pwlayout->wsubline1.plssubl);
lserr2 = WaDestroySubline (pwlayout->wsubline2.plssubl);
ClearWLayout (pwlayout);
if (lserr1 != lserrNone) return lserr1;
else return lserr2;
}
/* N E W D O B J */
/*----------------------------------------------------------------------------
%%Function: NewDobj
%%Contact: antons
Allocate new Dobj and initialize it.
----------------------------------------------------------------------------*/
static LSERR NewDobj (
PILSOBJ pilsobj, /* (IN): Ilsobj for object */
PLSDNODE plsdnTop, /* (IN): Parent Dnode */
LSCP cpStart, /* (IN): Cp-start of the Warichu */
LSCP cpStartObj, /* (IN): Cp-start from break record if fResumed */
BOOL fResumed, /* (IN): FormatResume? */
DWORD nBreakRec, /* (IN): fResumed => size of the break records array */
const BREAKREC
* rgBreakRec, /* (IN): fResumed => array of break records */
LSTFLOW lstflowParent, /* (IN): Lstflow of the parent subline */
PDOBJ *ppdobj) /* (OUT): allocated dobj */
{
LSERR lserr;
PDOBJ pdobj = AllocateMemory (pilsobj, sizeof(DOBJ));
if (pdobj == NULL)
{
*ppdobj = NULL;
return lserrOutOfMemory;
};
#ifdef DEBUG
Undefined (pdobj); /* Put some garbage into all dobj bytes */
#endif
pdobj->cpStart = cpStart;
pdobj->cpStartObj = cpStartObj;
pdobj->pilsobj = pilsobj;
pdobj->plsdnTop = plsdnTop;
pdobj->fResumed = fResumed;
pdobj->lstflowParent = lstflowParent;
ClearWLayout (&pdobj->wlayout);
ClearWLayout (&pdobj->wlayoutBreak [0]); /* prev */
ClearWLayout (&pdobj->wlayoutBreak [1]); /* next */
ClearWLayout (&pdobj->wlayoutBreak [2]); /* force */
ClearWLayout (&pdobj->wlayoutTruncate); /* OPT: Layout after truncation */
Assert (NBreaksToSave == 3);
pdobj->wbreaktype [0] = wbreaktypeInvalid; /* prev */
pdobj->wbreaktype [1] = wbreaktypeInvalid; /* next */
pdobj->wbreaktype [2] = wbreaktypeInvalid; /* force */
ClearWBrace (&pdobj->wbraceOpen);
ClearWBrace (&pdobj->wbraceClose);
ClearWWhole (&pdobj->wwhole);
*ppdobj = pdobj;
if (fResumed)
{
/* RESUMED => Allocate array of break records in wwhole & store there rgBreakRec */
lserr = NewWBrkArrayCopy (pdobj, nBreakRec, rgBreakRec, &pdobj->wbrkarrayAtStart);
if (lserr != lserrNone) return lserr;
}
else
{
/* ! RESUMED => Allocate 0 break records */
lserr = NewWBrkArrayCopy (pdobj, 0, NULL, &pdobj->wbrkarrayAtStart);
if (lserr != lserrNone) return lserr;
/* Note: even if ! Resumed, I will use Resumed formatting just because
I do not want to see at fResumed each time I format subline */
};
return lserrNone;
}
/* D E S T R O Y D O B J */
/*----------------------------------------------------------------------------
%%Function: DestroyDobj
%%Contact: antons
Release all resources associated with dobj for Warichu.
----------------------------------------------------------------------------*/
static LSERR DestroyDobj (PDOBJ pdobj)
{
LSERR rglserr [8];
int i;
rglserr [0] = WaDestroySubline (pdobj->wbraceOpen.plssubl);
rglserr [1] = WaDestroySubline (pdobj->wbraceClose.plssubl);
rglserr [2] = DestroyWLayout (&pdobj->wlayout);
rglserr [3] = DestroyWLayout (&pdobj->wlayoutBreak [0]);
rglserr [4] = DestroyWLayout (&pdobj->wlayoutBreak [1]);
rglserr [5] = DestroyWLayout (&pdobj->wlayoutBreak [2]);
rglserr [6] = WaDestroySubline (pdobj->wwhole.plssubl);
rglserr [7] = DestroyWLayout (&pdobj->wlayoutTruncate);
DestroyWBrkArray (pdobj, &pdobj->wbrkarrayAtStart);
FreeMemory (pdobj->pilsobj, pdobj);
/* REVIEW (antons): return last error instead of first? */
for (i = 0; i < 8; i++)
{
if (rglserr [i] != lserrNone) return rglserr [i];
};
return lserrNone;
}
/* F O R M A T B R A C E O F W A R I C H U */
/*----------------------------------------------------------------------------
%%Function: FormatBraceOfWarichu
%%Contact: antons
Create a line for beginning or ending bracket for Warichu.
----------------------------------------------------------------------------*/
typedef enum wbracekind {wbracekindOpen, wbracekindClose} WBRACEKIND;
static LSERR FormatBraceOfWarichu (
PDOBJ pdobj, /* (IN): Warichu Dobj */
LSCP cpFirst, /* (IN): Cp to start formatting */
WBRACEKIND wbracekind, /* (IN): Open or Close */
WBRACE *wbrace) /* (OUT): Brace data structure */
{
LSERR lserr;
LSCP cpLimSubline;
FMTRES fmtres;
LSESC * plsEscape;
Assert (wbracekind == wbracekindOpen || wbracekind == wbracekindClose);
plsEscape = ( wbracekind == wbracekindOpen ? &pdobj->pilsobj->lsescBraceOpen
: &pdobj->pilsobj->lsescBraceClose );
lserr = FormatLine( pdobj->pilsobj->plsc,
cpFirst,
LONG_MAX,
pdobj->lstflowParent,
& wbrace->plssubl,
1,
plsEscape,
& wbrace->objdim,
& cpLimSubline,
NULL,
NULL,
& fmtres );
if (lserr != lserrNone) return lserr;
Assert (fmtres == fmtrCompletedRun); /* Hit esc character */
wbrace->cpFirst = cpFirst;
wbrace->cpLim = cpLimSubline;
wbrace->cpLimAfterEsc = cpLimSubline + 1; /* Skip 1 esc character */
return lserrNone;
}
/* F O R M A T W W H O L E S U B L I N E */
/*----------------------------------------------------------------------------
%%Function: FormatWWholeSubline
%%Contact: antons
Formats the whole subline of Warichu (field "wwhole" in DOBJ).
----------------------------------------------------------------------------*/
static LSERR FormatWWholeSubline (
PDOBJ pdobj, /* (IN): Warichu Dobj */
LSCP cpFirst, /* (IN): Where to start formatting */
long urColumnMax, /* (IN): RM to limit formatting */
PWBRKARRAY pwbrkarrayAtStart,
/* (IN): array of break records at wwhole start */
PWWHOLE pwwhole ) /* (OUT): Strucure with the whole subline */
{
LSERR lserr;
LSCP cpLimSubline;
FMTRES fmtres;
ClearWWhole (pwwhole); /* For the case of error */
Assert (pdobj->fResumed || (pdobj->wbrkarrayAtStart.nBreakRec == 0));
lserr = FormatResumedLine (
pdobj->pilsobj->plsc,
cpFirst,
urColumnMax,
pdobj->lstflowParent,
& pwwhole->plssubl,
1,
& pdobj->pilsobj->lsescText,
& pwwhole->objdim,
& cpLimSubline,
NULL,
NULL,
& fmtres,
pwbrkarrayAtStart->rgBreakRec,
pwbrkarrayAtStart->nBreakRec );
if (lserr != lserrNone) return lserr;
Assert (pwwhole->plssubl != NULL);
pwwhole->cpFirst = cpFirst;
pwwhole->cpLim = cpLimSubline;
pwwhole->urColumnMax = urColumnMax;
Assert (fmtres == fmtrCompletedRun || fmtres == fmtrExceededMargin);
if (fmtres == fmtrCompletedRun)
{
/* Formatting stopped at ESC character */
pwwhole->fFinished = TRUE;
pwwhole->cpLimAfterEsc = cpLimSubline + 1;
Undefined (&pwwhole->cpTruncate);
}
else
{
/* Formatting stopped because of Exceeding RM */
pwwhole->fFinished = FALSE;
lserr = LsTruncateSubline (pwwhole->plssubl, urColumnMax, & pwwhole->cpTruncate);
if (lserr != lserrNone)
{
WaDestroySubline (pwwhole->plssubl); /* Do not need to check error code */
pwwhole->plssubl = NULL;
return lserr;
};
Undefined (&pwwhole->cpLimAfterEsc);
};
pwwhole->fJisRangeKnown = FALSE;
return lserrNone;
}
/* F O R M A T W S U B L I N E U N T I L C P B R E A K */
/*----------------------------------------------------------------------------
%%Function: FormatWSublineUntilCpBreak
%%Contact: antons
Format subline until known break opportunity.
----------------------------------------------------------------------------*/
static LSERR FormatWSublineUntilCpBreak (
PDOBJ pdobj, /* (IN): Warichu Dobj */
LSCP cpFirst, /* (IN): Cp to start formatting */
PWBRKARRAY pwbrkArray, /* (IN): Break records at start */
LSCP cpBreak, /* (IN): Cp-break to find */
long urFormatEstimate, /* (IN): Estimated RM for formatting */
long urTruncateEstimate, /* (IN): Estimated RM for truncation */
BOOL * pfSuccessful, /* (OUT): Did we find it? */
WSUBLINE * pwsubl, /* (OUT): Warichu subline if found */
OBJDIM * pobjdimBreak, /* (OUT): Dimensions of the break */
BRKKIND * pbrkkind ) /* (OUT): Kind of break to set in the subline */
{
LSERR lserr;
LSCP cpLimSubline;
OBJDIM objdimSubline;
OBJDIM objdimBreak;
PLSSUBL plssubl;
FMTRES fmtres;
BOOL fContinue;
LSCP cpTruncate;
long urFormatCurrent;
Assert (urFormatEstimate >= urTruncateEstimate);
pwsubl->plssubl = NULL; /* in case of error */
/* Loop initialization */
urFormatCurrent = urFormatEstimate;
fContinue = TRUE;
/* Loop until we have fetched enough */
/* REVIEW (antons): do-while instead of regular while to avoid
VC++ 6.0 warning message */
do /* while (fContinue) at the end */
{
lserr = FormatResumedLine ( pdobj->pilsobj->plsc,
cpFirst,
urFormatCurrent,
pdobj->lstflowParent,
& plssubl,
1,
& pdobj->pilsobj->lsescText,
& objdimSubline,
& cpLimSubline,
NULL,
NULL,
& fmtres,
pwbrkArray->rgBreakRec,
pwbrkArray->nBreakRec );
if (lserr != lserrNone) return lserr;
Assert (fmtres == fmtrCompletedRun || fmtres == fmtrExceededMargin);
/* REVIEW (antons): here I wrote "<=" because currently in our
definition, break "after" subline is not a break opportunity.
This place need to verifyed more carefully */
if (cpLimSubline <= cpBreak)
{
/* Did not fetch enough CPs, try again with bigger RM */
Assert (fmtres == fmtrExceededMargin);
lserr = LsDestroySubline (plssubl);
if (lserr != lserrNone) return lserr;
/* REVIEW (antons): Is coefficient 1.5 OK? */
/* REVIEW (antons): The following Assert is against infinite loop */
Assert (urFormatCurrent < ADDLongSafe (urFormatCurrent, urFormatCurrent / 2));
urFormatCurrent = ADDLongSafe (urFormatCurrent, urFormatCurrent / 2);
}
else
{
fContinue = FALSE;
};
} while (fContinue);
Assert (cpBreak < cpLimSubline);
lserr = LsTruncateSubline (plssubl, urTruncateEstimate, & cpTruncate);
if (lserr != lserrNone)
{
WaDestroySubline (plssubl); return lserr;
};
/* Going prev and next break to find required break point */
if (cpTruncate < cpBreak)
{
/* Go forward with Next Break */
LSCP cpLastBreak = cpTruncate;
BOOL fBreakSuccessful = TRUE;
do /* while (cpLastBreak < cpBreak && fBreakSuccessful) */
{
lserr = WaFindNextBreakSubline ( plssubl, cpLastBreak,
LONG_MAX,
& fBreakSuccessful,
& cpLastBreak,
& objdimBreak );
if (lserr != lserrNone)
{
WaDestroySubline (plssubl); return lserr;
};
} while (cpLastBreak < cpBreak && fBreakSuccessful);
if (! fBreakSuccessful || cpLastBreak > cpBreak)
{
lserr = LsDestroySubline (plssubl);
if (lserr != lserrNone) return lserr;
*pfSuccessful = FALSE;
}
else
{
Assert (cpLastBreak == cpBreak && fBreakSuccessful);
pwsubl->plssubl = plssubl;
pwsubl->cpFirst = cpFirst;
pwsubl->cpLim = cpBreak;
pwsubl->objdim = objdimSubline;
*pobjdimBreak = objdimBreak;
*pfSuccessful = TRUE;
*pbrkkind = brkkindNext;
};
}
else /* cpTruncate >= cpBreak */
{
/* Go backward with Prev Break */
LSCP cpLastBreak = cpTruncate + 1;
BOOL fBreakSuccessful = TRUE;
do /* while (cpBreak < cpLastBreak && fBreakSuccessful) at the end */
{
lserr = WaFindPrevBreakSubline ( plssubl, cpLastBreak - 1,
LONG_MAX,
& fBreakSuccessful,
& cpLastBreak,
& objdimBreak );
if (lserr != lserrNone)
{
WaDestroySubline (plssubl); return lserr;
};
} while (cpBreak < cpLastBreak && fBreakSuccessful);
if (! fBreakSuccessful || cpBreak > cpLastBreak)
{
lserr = LsDestroySubline (plssubl);
if (lserr != lserrNone) return lserr;
*pfSuccessful = FALSE;
}
else
{
Assert (cpLastBreak == cpBreak && fBreakSuccessful);
pwsubl->plssubl = plssubl;
pwsubl->cpFirst = cpFirst;
pwsubl->cpLim = cpBreak;
pwsubl->objdim = objdimSubline;
*pobjdimBreak = objdimBreak;
*pbrkkind = brkkindPrev;
*pfSuccessful = TRUE;
};
}; /* End If (cpTruncate < cpBreak) Then ... Else ... */
return lserrNone;
} /* FormatWSublineUntilCpBreak */
/* F O R M A T W S U B L I N E U N T I L R M */
/*----------------------------------------------------------------------------
%%Function: FormatWSublineUntilRM
%%Contact: antons
Format until given right margin - wrapper to FormatLine ()
----------------------------------------------------------------------------*/
static LSERR FormatWSublineUntilRM (
PDOBJ pdobj, /* (IN): Warichu Dobj */
LSCP cpFirst, /* (IN): Where to start formatting */
long urColumnMax, /* (IN): Right margin to format to */
PWBRKARRAY pwbrkarray, /* (IN): Array of break rec at subline start */
BOOL * fFinished, /* (OUT): Subline finished at Escape? */
WSUBLINE * pwsubl ) /* (OUT): Formatted WSubline */
{
LSERR lserr;
FMTRES fmtr;
lserr = FormatResumedLine ( pdobj->pilsobj->plsc,
cpFirst,
urColumnMax,
pdobj->lstflowParent,
& pwsubl->plssubl, /* out */
1,
& pdobj->pilsobj->lsescText,
& pwsubl->objdim, /* out */
& pwsubl->cpLim, /* out */
NULL,
NULL,
& fmtr,
pwbrkarray->rgBreakRec,
pwbrkarray->nBreakRec );
if (lserr != lserrNone) return lserr;
*fFinished = (fmtr == fmtrCompletedRun); /* out */
pwsubl->cpFirst = cpFirst; /* out */
Assert (fmtr == fmtrCompletedRun || fmtr == fmtrExceededMargin);
return lserrNone;
}
/* F O R M A T W S U B L I N E U N T I L E S C A P E */
/*----------------------------------------------------------------------------
%%Function: FormatWSublineUntilEscape
%%Contact: antons
Format subline until escape character - wrapper to FormatLine ()
----------------------------------------------------------------------------*/
static LSERR FormatWSublineUntilEscape (
PDOBJ pdobj, /* (IN): Warichu Dobj */
LSCP cpFirst, /* (IN): Where to start formatting */
PWBRKARRAY pwbrkarray, /* (IN): Array of break rec at subline start */
WSUBLINE * pwsubl, /* (OUT): Formatted WSubline */
long * cpLimAfterEsc) /* (OUT): CpLim after Esc characters */
{
FMTRES fmtres;
LSERR lserr = FormatResumedLine ( pdobj->pilsobj->plsc,
cpFirst,
LONG_MAX, /* urColumnMax */
pdobj->lstflowParent,
& pwsubl->plssubl, /* out */
1,
& pdobj->pilsobj->lsescText,
& pwsubl->objdim, /* out */
& pwsubl->cpLim, /* out */
NULL,
NULL,
& fmtres,
pwbrkarray->rgBreakRec,
pwbrkarray->nBreakRec );
if (lserr != lserrNone) return lserr;
* cpLimAfterEsc = pwsubl->cpLim + 1; /* out */
pwsubl->cpFirst = cpFirst; /* out */
Assert (fmtres == fmtrCompletedRun);
return lserrNone;
}
/* C H O O S E N E A R E S T B R E A K */
/*----------------------------------------------------------------------------
%%Function: ChooseNearestBreak
%%Contact: antons
Choose nearest between prev and next breaks from the given
truncation Ur. If prev and next are on the same distance =>
we choose next.
----------------------------------------------------------------------------*/
static LSERR ChooseNearestBreak (
PLSSUBL plssubl, /* (IN): Subline to find break */
long urTruncate2, /* (IN): Truncation point multiplied by 2
/* (we *2 to avoid rounding erros) */
LSCP cpLookBefore, /* (IN): Result must be before this cp */
BOOL *pfSuccessful, /* (OUT): Did we find any break ? */
LSCP *pcpBreak, /* (OUT): Cp of break */
OBJDIM *pobjdimBreak, /* (OUT): Dimensions of the broken subline */
BRKKIND *pbrkkind) /* (OUT): Break to set in the subline */
{
LSERR lserr;
LSCP cpTruncate;
OBJDIM objdimNext, objdimPrev;
LSCP cpBreakNext, cpBreakPrev;
BOOL fSuccessfulNext, fSuccessfulPrev;
lserr = LsTruncateSubline (plssubl, urTruncate2 / 2, & cpTruncate);
if (lserr != lserrNone) return lserr;
lserr = WaFindNextBreakSubline ( plssubl, cpTruncate, LONG_MAX,
& fSuccessfulNext, & cpBreakNext,
& objdimNext );
if (lserr != lserrNone) return lserr;
lserr = WaFindPrevBreakSubline ( plssubl, cpTruncate, LONG_MAX,
& fSuccessfulPrev, & cpBreakPrev,
& objdimPrev );
if (lserr != lserrNone) return lserr;
fSuccessfulNext = fSuccessfulNext && cpBreakNext <= cpLookBefore;
fSuccessfulPrev = fSuccessfulPrev && cpBreakPrev <= cpLookBefore;
if (fSuccessfulNext &&
(!fSuccessfulPrev || abs (objdimNext.dur * 2 - urTruncate2) <=
abs (objdimPrev.dur * 2 - urTruncate2) ) )
{
/* CHOOSING NEXT */
* pfSuccessful = TRUE;
* pcpBreak = cpBreakNext;
* pobjdimBreak = objdimNext;
* pbrkkind = brkkindNext;
}
else if (fSuccessfulPrev)
{
/* CHOOSING PREV */
* pfSuccessful = TRUE;
* pcpBreak = cpBreakPrev;
* pobjdimBreak = objdimPrev;
* pbrkkind = brkkindPrev;
}
else
{
/* Did not find any ;-( */
* pfSuccessful = FALSE;
};
return lserrNone;
} /* ChooseNearestBreak */
/* G E T D U R B R A C E S */
/*----------------------------------------------------------------------------
%%Function: GetDurBraces
%%Contact: antons
----------------------------------------------------------------------------*/
#define FOpenBraceInWLayout(pdobj,pwlayout) (! (pdobj)->fResumed)
#define FCloseBraceInWLayout(pdobj,pwlayout) (! (pwlayout)->fBroken)
static void GetDurBraces (
PDOBJ pdobj, /* (IN): Warichu DOBJ */
BOOL fBroken, /* (IN): Is it broken? */
BOOL *pfOpenPresent, /* (OUT): Open brace present */
long *pdurOpen, /* (OUT): dur of the open brace, 0 if no brace */
BOOL *pfClosePresent,/* (OUT): Close brace present */
long *pdurClose) /* (OUT): dur of the close brace 0 if no brace */
{
if (! pdobj->fResumed)
{
Assert (pdobj->wbraceOpen.plssubl != NULL);
* pdurOpen = pdobj->wbraceOpen.objdim.dur;
* pfOpenPresent = TRUE;
}
else
{
* pdurOpen = 0;
* pfOpenPresent = FALSE;
};
if (! fBroken)
{
Assert (pdobj->wbraceClose.plssubl != NULL);
* pdurClose = pdobj->wbraceClose.objdim.dur;
* pfClosePresent = TRUE;
}
else
{
* pdurClose = 0;
* pfClosePresent = FALSE;
};
} /* CalcDurBraces */
/* F I N I S H O B J D I M W L A Y O U T */
/*----------------------------------------------------------------------------
%%Function: FinishObjDimWLayout
%%Contact: antons
Complete calculations of the Warichu layout. This procedure
fills WLAYOUT.wdim data structure. The calculations are based on
the dimensions of Warichu sublines stored in WLAYOUT and the result
of GetWarichuInfo callback.
----------------------------------------------------------------------------*/
static LSERR FinishObjDimWLayout (
PDOBJ pdobj, /* (IN): Warichu DOBJ */
WLAYOUT * pwlayout) /* (IN): Break record (layout) of the Warichu */
{
LSERR lserr;
OBJDIM objdimAll;
long dvpDescentReserved;
long durOpen, durClose;
BOOL fOpenBrace, fCloseBrace;
PILSOBJ pilsobj = pdobj->pilsobj;
Assert (pwlayout->wsubline1.plssubl != NULL);
lserr = pilsobj->warichucbk.pfnGetWarichuInfo ( pilsobj->pols,
pdobj->cpStartObj,
pdobj->lstflowParent,
& pwlayout->wsubline1.objdim,
& pwlayout->wsubline2.objdim,
& objdimAll.heightsRef,
& objdimAll.heightsPres,
& dvpDescentReserved );
if (lserr != lserrNone) return lserr;
GetDurBraces (pdobj, pwlayout->fBroken,
&fOpenBrace, &durOpen, &fCloseBrace, &durClose);
objdimAll.dur = durOpen + durClose +
max (pwlayout->wsubline1.objdim.dur, pwlayout->wsubline2.objdim.dur);
pwlayout->wdim.objdimAll = objdimAll;
pwlayout->wdim.dvpDescentReserved = dvpDescentReserved;
return lserrNone;
}
/* F I N I S H W L A Y O U T S I N G L E L I N E */
/*----------------------------------------------------------------------------
%%Function: FinishWLayoutSingleLine
%%Contact: antons
Finishes layout of warichu as it were only one line (of course, not broken)
----------------------------------------------------------------------------*/
static LSERR FinishWLayoutSingleLine (PDOBJ pdobj, PWLAYOUT pwlayout)
{
pwlayout->fBroken = FALSE;
pwlayout->wsubline2.plssubl = NULL;
/* REVIEW (antons): Does anybody use cpFirst & cpLim I set here? */
pwlayout->wsubline2.cpFirst = pwlayout->wsubline1.cpLim;
pwlayout->wsubline2.cpLim = pwlayout->wsubline1.cpLim;
ZeroObjDim (& pwlayout->wsubline2.objdim);
return FinishObjDimWLayout (pdobj, pwlayout);
}
/* P R O C E S S M O D W I D T H */
/*----------------------------------------------------------------------------
%%Function: ProcessModWidth
%%Contact: antons
Ask client how much widths should be modified for lead or end
bracket for the Warichu. Then modify the Warichu to reflect the
change in size.
----------------------------------------------------------------------------*/
static LSERR ProcessModWidth (
PDOBJ pdobj, /* (IN): dobj */
enum warichucharloc wloc, /* (IN): location of mod width request */
PLSRUN plsrun, /* (IN): plsrun of the object */
PLSRUN plsrunText, /* (IN): plsrun of the preceding char */
WCHAR wchar, /* (IN): preceding character */
MWCLS mwcls, /* (IN): ModWidth class of preceding character */
long *pdurChange) /* (OUT): amount by which width of the preceding char is to be changed */
{
PILSOBJ pilsobj = pdobj->pilsobj;
LSERR lserr;
long durWChange;
lserr = pilsobj->warichucbk.pfnFetchWarichuWidthAdjust(pilsobj->pols,
pdobj->cpStartObj, wloc, plsrunText, wchar, mwcls, plsrun, pdurChange,
&durWChange);
AssertSz(durWChange >= 0,
"ProcessModWidth - invalid return from FetchWidthAdjust");
if (durWChange < 0)
{
durWChange = 0;
}
*pdurChange += durWChange;
return lserr;
}
/* S U B M I T W L A Y O U T S U B L I N E S */
/*----------------------------------------------------------------------------
%%Function: SubmitWLayoutSublines
%%Contact: antons
Submit sublines from the given layout for justification. We call
it after formatting and during SetBreak.
----------------------------------------------------------------------------*/
static LSERR SubmitWLayoutSublines (PDOBJ pdobj, PWLAYOUT pwlayout)
{
PLSSUBL rgsublSubmit [3]; /* Array of psublines to submit */
DWORD nSubmit; /* Number of sublines to submit */
LSERR lserr;
BOOL fOpenBrace, fCloseBrace;
long durOpen, durClose;
GetDurBraces (pdobj, pwlayout->fBroken, &fOpenBrace, &durOpen, &fCloseBrace, &durClose);
nSubmit = 0;
/* Submit open brace */
if (fOpenBrace)
{
BOOL fSublineEmpty;
lserr = LssbFIsSublineEmpty (pdobj->wbraceOpen.plssubl, &fSublineEmpty);
if (lserr != lserrNone) return lserr;
if (! fSublineEmpty) /* Can not submit empty subline */
{
rgsublSubmit [nSubmit++] = pdobj->wbraceOpen.plssubl;
}
};
/* Submit longest subline */
/* REVIEW (antons): If first is empty & second is not empty but ZW,
I do not submit neither */
/* REVIEW (antons): Can it ever happen what I wrote before? */
if (pwlayout->wsubline1.objdim.dur >= pwlayout->wsubline2.objdim.dur)
{
BOOL fSublineEmpty;
lserr = LssbFIsSublineEmpty (pwlayout->wsubline1.plssubl, &fSublineEmpty);
if (lserr != lserrNone) return lserr;
if (! fSublineEmpty) /* Can not submit empty subline */
{
rgsublSubmit [nSubmit++] = pwlayout->wsubline1.plssubl;
};
}
else
{
BOOL fSublineEmpty;
Assert (pwlayout->wsubline2.plssubl != NULL);
lserr = LssbFIsSublineEmpty (pwlayout->wsubline2.plssubl, &fSublineEmpty);
if (lserr != lserrNone) return lserr;
if (! fSublineEmpty) /* Can not submit empty subline */
{
rgsublSubmit [nSubmit++] = pwlayout->wsubline2.plssubl;
}
};
/* Submit closing brace */
if (fCloseBrace)
{
BOOL fSublineEmpty;
lserr = LssbFIsSublineEmpty (pdobj->wbraceClose.plssubl, &fSublineEmpty);
if (lserr != lserrNone) return lserr;
if (! fSublineEmpty) /* Can not submit empty subline */
{
rgsublSubmit [nSubmit++] = pdobj->wbraceClose.plssubl;
}
};
/* REVIEW (antons): This deletes previously submitted subline. Question:
should we better have additional procedure to "clear" submition?
*/
lserr = LsdnSubmitSublines ( pdobj->pilsobj->plsc,
pdobj->plsdnTop,
nSubmit, rgsublSubmit,
TRUE, /* Justification */
FALSE, /* Compression */
FALSE, /* Display */
FALSE, /* Decimal tab */
FALSE ); /* Trailing spaces */
return lserr;
}
/* W A R I C H U C R E A T E I L S O B J */
/*----------------------------------------------------------------------------
%%Function: WarichuCreateILSObj
%%Contact: ricksa
Create main object for Warichu handlers.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuCreateILSObj (
POLS pols, /* (IN): client application context */
PLSC pclsc, /* (IN): LS context */
PCLSCBK pclscbk, /* (IN): callbacks to client application */
DWORD idobj, /* (IN): id of the object */
PILSOBJ * ppilsobj ) /* (OUT): object ilsobj */
{
PILSOBJ pilsobj;
LSERR lserr;
WARICHUINIT warichuinit;
warichuinit.dwVersion = WARICHU_VERSION;
/* Get initialization data */
lserr = pclscbk->pfnGetObjectHandlerInfo(pols, idobj, &warichuinit);
if (lserr != lserrNone)
{
return lserr;
}
/* Build ILS object */
pilsobj = pclscbk->pfnNewPtr(pols, sizeof(*pilsobj));
if (NULL == pilsobj) return lserrOutOfMemory;
ZeroMemory(pilsobj, sizeof(*pilsobj));
pilsobj->pols = pols;
pilsobj->idobj = idobj;
pilsobj->lscbk = *pclscbk;
pilsobj->plsc = pclsc;
pilsobj->lsescBraceOpen.wchFirst = warichuinit.wchEndFirstBracket;
pilsobj->lsescBraceOpen.wchLast = warichuinit.wchEndFirstBracket;
pilsobj->lsescText.wchFirst = warichuinit.wchEndText;
pilsobj->lsescText.wchLast = warichuinit.wchEndText;
pilsobj->lsescBraceClose.wchFirst = warichuinit.wchEndWarichu;
pilsobj->lsescBraceClose.wchLast = warichuinit.wchEndWarichu;
pilsobj->warichucbk = warichuinit.warichcbk;
pilsobj->fContiguousFetch = warichuinit.fContiguousFetch;
*ppilsobj = pilsobj;
return lserrNone;
}
/* W A R I C H U D E S T R O Y I L S O B J */
/*----------------------------------------------------------------------------
%%Function: WarichuDestroyILSObj
%%Contact: antons
Free all resources connected with Warichu main object.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuDestroyILSObj(PILSOBJ pilsobj)
{
FreeMemory (pilsobj, pilsobj);
return lserrNone;
}
/* W A R I C H U S E T D O C */
/*----------------------------------------------------------------------------
%%Function: WarichuSetDoc
%%Contact: antons
Save the device resolution for later scaling.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuSetDoc(
PILSOBJ pilsobj, /* (IN): object ilsobj */
PCLSDOCINF pclsdocinf) /* (IN): initialization data of the document level */
{
pilsobj->lsdevres = pclsdocinf->lsdevres;
return lserrNone;
}
/* W A R I C H U C R E A T E L N O B J */
/*----------------------------------------------------------------------------
%%Function: WarichuCreateLNObj
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuCreateLNObj (PCILSOBJ pcilsobj, PLNOBJ *pplnobj)
{
*pplnobj = (PLNOBJ) pcilsobj;
return lserrNone;
}
/* W A R I C H U D E S T R O Y L N O B J */
/*----------------------------------------------------------------------------
%%Function: WarichuDestroyLNObj
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuDestroyLNObj (PLNOBJ plnobj)
{
Unreferenced(plnobj);
return lserrNone;
}
/* G E T C P L I M O F W L A Y O U T */
/*----------------------------------------------------------------------------
%%Function: GetCpLimOfWLayout
%%Contact: antons
Return cp-lim for the given Warichu layout.
----------------------------------------------------------------------------*/
static LSCP GetCpLimOfWLayout (PDOBJ pdobj, WLAYOUT *pwlayout)
{
Unreferenced (pdobj);
Assert (FWLayoutValid (pwlayout));
if (pwlayout->fBroken)
{
Assert (pwlayout->wsubline2.plssubl != NULL);
return pwlayout->wsubline2.cpLim;
}
else
{
Assert (pdobj->wbraceClose.plssubl != NULL);
return pdobj->wbraceClose.cpLimAfterEsc;
};
}
/* R E F O R M A T C L O S I N G B R A C E F O R W O R D 9
/*----------------------------------------------------------------------------
%%Function: ReformatClosingBraceForWord9
%%Contact: antons
REVIEW (antons):
THIS IS HACK WHICH WAS REQUESTED BY WORD 9, BECAUSE THEY
DID NOT WANT TO FIX THEIR BUG IN CODE WHICH INSERTS BRACES
ON-THE-FLY. IT MUST BE REMOVED AS SOON AS POSSIBLE, BECAUSE
IT MAY SLOWS DOWN WARICHU FORMATTING SIGNIFICANTLY.
----------------------------------------------------------------------------*/
#define min(a,b) ((a)<(b) ? (a) : (b))
LSERR ReformatClosingBraceForWord9 (PDOBJ pdobj)
{
DWORD cwchRun;
WCHAR * lpwchRun;
BOOL fHidden;
LSCHP lschp;
PLSRUN plsrun;
LSCP cpFetch;
LSCP cpLimFetch;
LSERR lserr;
if (pdobj->pilsobj->fContiguousFetch)
{
if (! FWLayoutValid (&pdobj->wlayout)) return lserrNone;
cpFetch = pdobj->wwhole.cpFirst;
cpLimFetch = min (pdobj->wwhole.cpLim, GetCpLimOfWLayout (pdobj, &pdobj->wlayout));
while (cpFetch < cpLimFetch)
{
lserr = pdobj->pilsobj->lscbk.pfnFetchRun ( pdobj->pilsobj->pols,
cpFetch, & lpwchRun, & cwchRun,
& fHidden, & lschp, & plsrun );
if (lserr != lserrNone) return lserr;
lserr = pdobj->pilsobj->lscbk.pfnReleaseRun (pdobj->pilsobj->pols, plsrun);
if (lserr != lserrNone) return lserr;
Assert (cwchRun > 0);
if (cwchRun == 0) return lserrInvalidDcpFetched;
cpFetch = cpFetch + cwchRun;
};
cpFetch = cpLimFetch;
cpLimFetch = GetCpLimOfWLayout (pdobj, &pdobj->wlayout);
while (cpFetch < cpLimFetch)
{
lserr = pdobj->pilsobj->lscbk.pfnFetchRun ( pdobj->pilsobj->pols,
cpFetch, & lpwchRun, & cwchRun,
& fHidden, & lschp, & plsrun );
if (lserr != lserrNone) return lserr;
lserr = pdobj->pilsobj->lscbk.pfnReleaseRun (pdobj->pilsobj->pols, plsrun);
if (lserr != lserrNone) return lserr;
Assert (cwchRun > 0);
if (cwchRun == 0) return lserrInvalidDcpFetched;
cpFetch = cpFetch + cwchRun;
};
};
return lserrNone;
}
/* F I N D W L A Y O U T O F U N B R O K E N W A R I C H U */
/*----------------------------------------------------------------------------
%%Function: FindWLayoutOfUnbrokenWarichu
%%Contact: antons
Find layout of the Warichu which is not broken. This procedure
returns structure WLAYOUT.
----------------------------------------------------------------------------*/
static LSERR FindWLayoutOfUnbrokenWarichu (PDOBJ pdobj, WLAYOUT *pwlayout)
{
LSERR lserr;
BOOL fSuccessful;
LSCP cpBreakFirstLine;
OBJDIM objdimUnused;
OBJDIM objdimFirstLine;
BRKKIND brkkindUnused;
LSCP cpLimUnused;
Assert (pdobj->wwhole.plssubl != NULL);
/* This should not be called when wwhole was not finished */
Assert (pdobj->wwhole.fFinished);
ClearWLayout (pwlayout); /* For the case of error */
if (pdobj->wwhole.objdim.dur == 0)
{
/* Either empty or zero-width subline */
/* The only thing we can do is to create single-line Warichu */
LSCP cpLimAfterEscUnused;
lserr = FormatWSublineUntilEscape ( pdobj, pdobj->wwhole.cpFirst,
& pdobj->wbrkarrayAtStart,
& pwlayout->wsubline1,
& cpLimAfterEscUnused );
if (lserr != lserrNone) return lserr;
Assert (pwlayout->wsubline1.objdim.dur == 0);
return FinishWLayoutSingleLine (pdobj, pwlayout);
};
lserr = ChooseNearestBreak ( pdobj->wwhole.plssubl,
pdobj->wwhole.objdim.dur,
CP_MAX,
& fSuccessful,
& cpBreakFirstLine,
& objdimUnused,
& brkkindUnused );
if (lserr != lserrNone) return lserr;
if (! fSuccessful)
{
/* Not a single break in the whole Warichu line */
LSCP cpLimAfterEscUnused;
lserr = FormatWSublineUntilEscape ( pdobj, pdobj->wwhole.cpFirst,
& pdobj->wbrkarrayAtStart,
& pwlayout->wsubline1,
& cpLimAfterEscUnused );
if (lserr != lserrNone) return lserr;
return FinishWLayoutSingleLine (pdobj, pwlayout);
}
else
{
/* Yes, we have break between lines */
BOOL fSuccessful;
BRKKIND brkkind;
WBRKARRAY wbrkarray;
lserr = FormatWSublineUntilCpBreak ( pdobj, pdobj->wwhole.cpFirst,
& pdobj->wbrkarrayAtStart,
cpBreakFirstLine,
LONG_MAX, pdobj->wwhole.objdim.dur / 2, /* REVIEW THIS ! */
& fSuccessful,
& pwlayout->wsubline1, & objdimFirstLine, & brkkind );
if (lserr != lserrNone) return lserr;
Assert (fSuccessful); /* Something crazy inside Warichu */
lserr = NewWBrkArray (pdobj, &wbrkarray);
if (lserr != lserrNone) return lserr;
lserr = SetBreakWSubline (&pwlayout->wsubline1, brkkind, cpBreakFirstLine,
&objdimFirstLine, &wbrkarray);
lserr = FormatWSublineUntilEscape ( pdobj, pwlayout->wsubline1.cpLim,
& wbrkarray, & pwlayout->wsubline2,
& cpLimUnused );
if (lserr != lserrNone) return lserr;
DestroyWBrkArray (pdobj, &wbrkarray);
};
pwlayout->fBroken = FALSE; /* This warichu is not broken ;-) */
lserr = FinishObjDimWLayout (pdobj, pwlayout);
return lserr;
}
/* F O R M A T W A R I C H U C O R E */
/*----------------------------------------------------------------------------
%%Function: FormatWarichuCore
%%Contact: antons
Format Warichu Object (called from methods WarichuFmt and WarichuFmtResumt)
----------------------------------------------------------------------------*/
static LSERR FormatWarichuCore (
PLNOBJ plnobj, /* (IN): Warichu LNOBJ */
PCFMTIN pcfmtin, /* (IN): Formatting input */
BOOL fResumed, /* (IN): Resumed? */
DWORD nBreakRec, /* (IN): fResumed => size of the break records array */
const BREAKREC
* rgBreakRec, /* (IN): fResumed => array of break records */
FMTRES * pfmtres ) /* (OUT): formatting result */
{
LSERR lserr;
PILSOBJ pilsobj = (PILSOBJ) plnobj; /* They are the same */
PDOBJ pdobj;
long urColumnMax = pcfmtin->lsfgi.urColumnMax;
/* REVIEW (antons): Can we optimize for case 0? */
long durAvailable = max (0, pcfmtin->lsfgi.urColumnMax - pcfmtin->lsfgi.urPen);
/* :: CREATE DOBJ WITH INITIAL OBJECT DATA */
if (! fResumed)
{
/* Not Resumed */
lserr = NewDobj ( pilsobj,
pcfmtin->plsdnTop,
pcfmtin->lsfgi.cpFirst,
pcfmtin->lsfgi.cpFirst,
FALSE, /* fResumed */
0,
NULL,
pcfmtin->lsfgi.lstflow,
& pdobj );
}
else
{
/* Resumed */
Assert (nBreakRec > 0);
Assert (rgBreakRec [0].idobj == pilsobj->idobj);
lserr = NewDobj ( pilsobj,
pcfmtin->plsdnTop,
pcfmtin->lsfgi.cpFirst,
rgBreakRec [0].cpFirst,
TRUE, /* fResumed */
nBreakRec-1,
& rgBreakRec [1],
pcfmtin->lsfgi.lstflow,
& pdobj );
};
if (lserr != lserrNone) return lserr;
/* :: FORMAT WARICHU OPEN BRACE IF not RESUMED*/
if (!fResumed)
{
lserr = FormatBraceOfWarichu ( pdobj, pdobj->cpStart + 1 /* Skip 1 Esc */,
wbracekindOpen, & pdobj->wbraceOpen );
if (lserr != lserrNone)
{
DestroyDobj (pdobj); return lserr;
};
}
else
pdobj->wbraceOpen.plssubl = NULL; /* No open brace */
/* :: FORMAT THE WHOLE WARICHU LINE */
{
/* REVIEW (antons): Check with Igor that he is not playing with RM, because
if he is, the following estimations of durFormatWhole are
not correct */
/* To be able to check JIS rule, warichu needs to format the whole subline
far ehough to be able to count 4 break opportunities from break-point.
We estimate it like
2 * durAvailable + 2 * urColumnMax
*/
/* REVIEW (antons): I want to be sure that final line break does not depend on
whatever estimations we use here */
/* REVIEW (antons): Is that correct to return lserrUnsufficientFetch if there is
no 4 breaks after (JIS rule) when wwhole is not finished? */
/* REVIEW (antons): Can something like 5 * durAvailable may be better */
long urFormatWhole = MULLongSafe (ADDLongSafe (durAvailable, urColumnMax), 2);
LSCP cpStartFormatWhole = (fResumed ? pdobj->cpStart :
pdobj->wbraceOpen.cpLimAfterEsc);
lserr = FormatWWholeSubline ( pdobj,
cpStartFormatWhole,
urFormatWhole,
& pdobj->wbrkarrayAtStart,
& pdobj->wwhole );
if (lserr != lserrNone)
{
DestroyDobj (pdobj); return lserr;
};
};
/* :: CHECK IF THE WHOLE SUBLINE WAS NOT FINISHED */
if (! pdobj->wwhole.fFinished)
{
/* Not finished => return fmtrExceedMargin */
Assert (pdobj->wwhole.objdim.dur / 2 > durAvailable);
InvalidateWLayout (&pdobj->wlayout); /* Invalidate layout */
/* REVIEW (antons) */
pdobj->wlayout.wdim.objdimAll = pdobj->wwhole.objdim;
/* Must have correct objdim */
/* REVIEW (antons): Check - we return dcp of the fetched range */
/* REVIEW (antons): Check - we return objdim of the whole line */
lserr = LsdnFinishRegular ( pilsobj->plsc,
pdobj->wwhole.cpLim - pdobj->cpStart,
pcfmtin->lsfrun.plsrun,
pcfmtin->lsfrun.plschp,
pdobj,
& pdobj->wwhole.objdim );
if (lserr != lserrNone) { DestroyDobj (pdobj); return lserr; };
* pfmtres = fmtrExceededMargin;
return lserrNone;
};
/* :: FORMAT THE CLOSING BRACE */
lserr = FormatBraceOfWarichu (pdobj, pdobj->wwhole.cpLimAfterEsc,
wbracekindClose, &pdobj->wbraceClose);
if (lserr != lserrNone) { DestroyDobj (pdobj); return lserr; };
/* :: FIND LAYOUT OF WARICHU AS IF IT IS NOT BROKEN AND FINISH FORMATTING */
lserr = FindWLayoutOfUnbrokenWarichu (pdobj, &pdobj->wlayout);
if (lserr != lserrNone) { DestroyDobj (pdobj); return lserr; };
/* :: SUBMIT WARICHU SUBLINES */
/* REVIEW (antons): MOVE SUBMITTION BELOW LSDNFINISHREGULAR WHEN
WE ALIMINATE HACK WITH REFORMATTING ")" FOR SG */
lserr = SubmitWLayoutSublines (pdobj, &pdobj->wlayout);
if (lserr != lserrNone) { DestroyDobj (pdobj); return lserr; };
ReformatClosingBraceForWord9 (pdobj);
lserr = LsdnFinishRegular ( pilsobj->plsc,
GetCpLimOfWLayout (pdobj, &pdobj->wlayout)-pdobj->cpStart,
pcfmtin->lsfrun.plsrun,
pcfmtin->lsfrun.plschp,
pdobj,
& pdobj->wlayout.wdim.objdimAll );
if (lserr != lserrNone) { DestroyDobj (pdobj); return lserr; };
/* :: CHECK IF WE CROSSED RIGHT MARGIN AND RETURN */
if (pdobj->wlayout.wdim.objdimAll.dur > durAvailable)
{
* pfmtres = fmtrExceededMargin;
}
else
{
* pfmtres = fmtrCompletedRun;
};
return lserrNone;
} /* FormatWarichuCore */
/* W A R I C H U F M T */
/*----------------------------------------------------------------------------
%%Function: Warichu::Fmt
%%Contact: antons
Warichu FMT method entry point
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuFmt ( PLNOBJ plnobj, /* (IN): object lnobj */
PCFMTIN pcfmtin, /* (IN): formatting input */
FMTRES * pfmtres ) /* (OUT): formatting result */
{
return FormatWarichuCore ( plnobj,
pcfmtin,
FALSE, /* fResumed = false */
0,
NULL,
pfmtres );
}
/* W A R I C H U F M T R E S U M E */
/*----------------------------------------------------------------------------
%%Function: Warichu::FmtResume
%%Contact: anton
Warichu FMT-RESUME method entry point
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuFmtResume (
PLNOBJ plnobj, /* (IN): object lnobj */
const BREAKREC * rgBreakRecord, /* (IN): array of break records */
DWORD nBreakRecord, /* (IN): size of the break records array */
PCFMTIN pcfmtin, /* (IN): formatting input */
FMTRES * pfmtres ) /* (OUT): formatting result */
{
return FormatWarichuCore ( plnobj,
pcfmtin,
TRUE, /* fResumed = true */
nBreakRecord,
rgBreakRecord,
pfmtres );
}
/* W A R I C H U G E T M O D W I D T H P R E C E D I N G C H A R */
/*----------------------------------------------------------------------------
%%Function: WarichuGetModWidthPrecedingChar
%%Contact: ricksa
.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuGetModWidthPrecedingChar(
PDOBJ pdobj, /* (IN): dobj */
PLSRUN plsrun, /* (IN): plsrun of the object */
PLSRUN plsrunText, /* (IN): plsrun of the preceding char */
PCHEIGHTS pcheightsRef, /* (IN): height info about character */
WCHAR wchar, /* (IN): preceding character */
MWCLS mwcls, /* (IN): ModWidth class of preceding character */
long *pdurChange) /* (OUT): amount by which width of the preceding char is to be changed */
{
Unreferenced(pcheightsRef);
return ProcessModWidth(pdobj, warichuBegin, plsrun, plsrunText,
wchar, mwcls, pdurChange);
}
/* W A R I C H U G E T M O D W I D T H F O L L O W I N G C H A R */
/*----------------------------------------------------------------------------
%%Function: WarichuGetModWidthFollowingChar
%%Contact: ricksa
.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuGetModWidthFollowingChar(
PDOBJ pdobj, /* (IN): dobj */
PLSRUN plsrun, /* (IN): plsrun of the object */
PLSRUN plsrunText, /* (IN): plsrun of the following char */
PCHEIGHTS pcheightsRef, /* (IN): height info about character */
WCHAR wchar, /* (IN): following character */
MWCLS mwcls, /* (IN): ModWidth class of the following character */
long *pdurChange) /* (OUT): amount by which width of the following char is to be changed */
{
Unreferenced(pcheightsRef);
return ProcessModWidth(pdobj, warichuEnd, plsrun, plsrunText,
wchar, mwcls, pdurChange);
}
/* T R Y B R E A K W A R I C H U A T C P */
/*----------------------------------------------------------------------------
%%Function: TryBreakWarichuAtCp
%%Contact: antons
Given break-point in the whole line, find break of Warichu which
ends at this break-point. For optimization during Truncation I added
urColumnMax and special result type trybreakkindExceedMargin.
This is the major breakig procedure which is called from Truncation,
Prev / Next Breaks and probably Force break.
----------------------------------------------------------------------------*/
typedef enum trybreakwarichu
{
trybreakwarichuSuccessful,
trybreakwarichuExceedMargin,
trybreakwarichuCanNotFinishAtCp
} TRYBREAKWARICHU;
LSERR TryBreakWarichuAtCp (
PDOBJ pdobj, /* (IN): Warichu DOBJ */
LSCP cpBreakCandidate, /* (IN): Candidate cpLim of broken Warichu */
long durBreakCandidate, /* (IN): dur of break-point in the whole line */
long urColumnMax, /* (IN): max width of broken warichu (for OPT only!) */
TRYBREAKWARICHU * ptrybreakwarichu, /* (OUT): Successful | ExceededRM | Bad Candidate */
PWLAYOUT pwlayout) /* (OUT): Layout of broken Warichu if Successful */
{
LSERR lserr;
BOOL fSuccessful;
LSCP cpBreakFirst;
BRKKIND brkkindUnused;
OBJDIM objdimBreakFirst;
OBJDIM objdimBreakSecond;
BRKKIND brkkindFirst;
BRKKIND brkkindSecond;
WBRKARRAY wbrkarrayAtFirstEnd; /* WBreakArray at the end of first subline */
long durOpen, durClose;
BOOL boolUnused1, boolUnused2;
pwlayout->wsubline1.plssubl = NULL;
pwlayout->wsubline2.plssubl = NULL; /* In case of error */
GetDurBraces (pdobj, TRUE, &boolUnused1, &durOpen, &boolUnused2, &durClose);
/* REVIEW (antons): Hidden text at "cpBreakCandidate - 1" */
lserr = ChooseNearestBreak ( pdobj->wwhole.plssubl,
durBreakCandidate,
cpBreakCandidate - 1,
& fSuccessful,
& cpBreakFirst,
& objdimBreakFirst,
& brkkindUnused );
if (lserr != lserrNone) return lserr;
Assert (fSuccessful); /* REVIEW (antons): Should not we provide special ret code? */
/* Optimization check */
/* REVIEW (antons): I do not like this check, calculation must be done in special function */
if (durOpen + durClose + objdimBreakFirst.dur > urColumnMax)
{
* ptrybreakwarichu = trybreakwarichuExceedMargin;
lserr = DestroyWLayout (pwlayout);
return lserrNone;
};
/* Format first line */
lserr = FormatWSublineUntilCpBreak ( pdobj,
pdobj->wwhole.cpFirst,
& pdobj->wbrkarrayAtStart,
cpBreakFirst,
objdimBreakFirst.dur, /* REVIEW (antons): urColumnMax */
objdimBreakFirst.dur, /* REVIEW (antons): urTuncate */
& fSuccessful,
& pwlayout->wsubline1,
& objdimBreakFirst,
& brkkindFirst );
if (lserr != lserrNone) return lserr;
/* REVIEW (antons): Maybe we should leave this assert? */
/* Assert (fSuccessful); */
if (!fSuccessful) /* Incorrect object inside Warichu, but we can handle it */
{
* ptrybreakwarichu = trybreakwarichuCanNotFinishAtCp;
lserr = DestroyWLayout (pwlayout);
return lserr;
};
/* Create new WBreakArray */
lserr = NewWBrkArray (pdobj, & wbrkarrayAtFirstEnd);
if (lserr != lserrNone) {DestroyWLayout (pwlayout); return lserr;};
/* Set break at the end of first line and fill WBreakArray */
lserr = SetBreakWSubline (& pwlayout->wsubline1, brkkindFirst,
cpBreakFirst, & objdimBreakFirst, & wbrkarrayAtFirstEnd);
if (lserr != lserrNone)
{
DestroyWLayout (pwlayout);
DestroyWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
return lserr;
};
/* REVIEW (antons): Check the following assumption! */
Assert (durBreakCandidate >= objdimBreakFirst.dur);
/* Format second line */
lserr = FormatWSublineUntilCpBreak ( pdobj,
cpBreakFirst,
& wbrkarrayAtFirstEnd,
cpBreakCandidate,
durBreakCandidate - objdimBreakFirst.dur, /* REVIEW (antons): urColumnMax */
durBreakCandidate - objdimBreakFirst.dur, /* REVIEW (antons): urTuncate */
& fSuccessful,
& pwlayout->wsubline2,
& objdimBreakSecond,
& brkkindSecond );
if (lserr != lserrNone)
{
DestroyWLayout ( pwlayout);
DestroyWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
return lserr;
};
/* We do not need wBreakArrayAtFirstEnd any more, so we release it */
DestroyWBrkArray (pdobj, & wbrkarrayAtFirstEnd);
/* If not Successful => result "Can not Finish At Cp" */
if (!fSuccessful)
{
DestroyWLayout (pwlayout);
* ptrybreakwarichu = trybreakwarichuCanNotFinishAtCp;
return lserrNone;
};
/* Here comes a small cheating ;-)
We do not want to Set Break at the end of second line, but have to
store objdim & cpLim as if after SetBreak. Maybe in the future I will
get rid of this checting (hope it is the only one left in Warichu ;-)
but today I change cpLim and objdim manually & also store
kind of break to set at second line end (playout->brkkind).
*/
pwlayout->wsubline2.cpLim = cpBreakCandidate;
pwlayout->wsubline2.objdim = objdimBreakSecond;
pwlayout->brkkind = brkkindSecond;
pwlayout->fBroken = TRUE;
lserr = FinishObjDimWLayout (pdobj, pwlayout);
if (lserr != lserrNone) {DestroyWLayout (pwlayout); return lserr;};
/* Again, check for right Margin */
if (pwlayout->wdim.objdimAll.dur > urColumnMax)
{
* ptrybreakwarichu = trybreakwarichuExceedMargin;
lserr = DestroyWLayout (pwlayout);
return lserr;
}
else
{
* ptrybreakwarichu = trybreakwarichuSuccessful;
return lserrNone;
};
}
/* C A L C J I S R A N G E */
/*----------------------------------------------------------------------------
%%Function: CalcJisRange
%%Contact: antons
Calculate cpJisRangeFisrt and cpJisRangeLim as 4th break opportunities
from the beginning and from the end of Whole subline. If range is empty,
* pfJisRangeEmpty = FALSE and cps are undefined.
----------------------------------------------------------------------------*/
static LSERR CalcJisRange (
PDOBJ pdobj,
BOOL *pfJisRangeEmpty,
LSCP *pcpJisRangeFirst,
LSCP *pcpJisRangeLim )
{
LSERR lserr;
OBJDIM objdimUnused;
WWHOLE * pwwhole = &pdobj->wwhole;
Assert (pwwhole->plssubl != NULL);
if (!pwwhole->fJisRangeKnown) /* Have to calculate */
{
/* Searching 4 breaks from WWHOLE start */
LSCP cpTruncateBefore = pdobj->wwhole.cpFirst;
BOOL fSuccessful = TRUE;
long nFound = 0;
while (fSuccessful && nFound < 4)
{
lserr = WaFindNextBreakSubline ( pwwhole->plssubl,
cpTruncateBefore,
LONG_MAX,
& fSuccessful,
& cpTruncateBefore,
& objdimUnused );
if (lserr != lserrNone) return lserr;
if (fSuccessful) nFound ++;
};
if (fSuccessful)
{
/* Searching 4 breaks from WWHOLE end */
LSCP cpTruncateAfter;
BOOL fSuccessful = TRUE;
long nFound = 0;
if (pwwhole->fFinished)
{
/* Subline was finished at Esc char, so we can start from cpLim */
cpTruncateAfter = pwwhole->cpLim;
}
else
{
/* Subline was stopped at RM => start at RM truncation point */
cpTruncateAfter = pwwhole->cpTruncate+1;
};
/* REVIEW (antons): To reduce check above maybe we can lie about
cp-lim of the whole subline when it was not finished? */
while (fSuccessful && nFound < 4)
{
lserr = WaFindPrevBreakSubline ( pwwhole->plssubl,
cpTruncateAfter-1,
LONG_MAX,
& fSuccessful,
& cpTruncateAfter,
& objdimUnused );
if (lserr != lserrNone) return lserr;
if (fSuccessful) nFound ++;
};
if (fSuccessful)
{
/* Jis Range is not empty */
pwwhole->cpJisRangeFirst = cpTruncateBefore;
pwwhole->cpJisRangeLim = cpTruncateAfter + 1;
}
else
{
/* Empty range */
pwwhole->cpJisRangeFirst = 0;
pwwhole->cpJisRangeLim = 0;
};
}
else
{
/* Empty range */
pwwhole->cpJisRangeFirst = 0;
pwwhole->cpJisRangeLim = 0;
};
pwwhole->fJisRangeKnown = TRUE; /* Yes, now we know it */
}
else
/* Nothing - already know ;-) */ ;
Assert (pwwhole->fJisRangeKnown);
*pfJisRangeEmpty = pwwhole->cpJisRangeFirst >= pwwhole->cpJisRangeLim;
*pcpJisRangeFirst = pwwhole->cpJisRangeFirst;
*pcpJisRangeLim = pwwhole->cpJisRangeLim;
return lserrNone;
}
/* S A V E B R E A K I N S I D E W A R I C H U */
/*----------------------------------------------------------------------------
%%Function: SaveBreakInsideWarichu
%%Contact: antons
Store layout for Prev / Next / Force break in dobj. This procedure
also Invalidates pointers in input layout after copying.
----------------------------------------------------------------------------*/
static void SaveBreakInsideWarichu (
PDOBJ pdobj, /* (IN): Warichu Dobj */
BRKKIND brkkind, /* (IN): Kind of break happened */
WLAYOUT * pwlayout ) /* (IN/OUT): Layout to store */
{
int ind = GetBreakRecordIndex (brkkind);
/* Destroy previously saved layout */
DestroyWLayout (& pdobj->wlayoutBreak [ind]);
/* Copy input layout to pdobj */
pdobj->wlayoutBreak [ind] = *pwlayout;
pdobj->wbreaktype [ind] = wbreaktypeInside;
/* Invalidate input layout */
InvalidateWLayout (pwlayout);
}
/* S A V E B R E A K A F T E R */
/*----------------------------------------------------------------------------
%%Function: SaveBreakAfter
%%Contact: antons
Changes break information so it says "After current layout"
----------------------------------------------------------------------------*/
static void SaveBreakAfterWarichu (
PDOBJ pdobj, /* (IN): Warichu Dobj */
BRKKIND brkkind ) /* (IN): Kind of break happened */
{
int ind = GetBreakRecordIndex (brkkind);
/* Destroy previously saved layout */
DestroyWLayout (& pdobj->wlayoutBreak [ind]);
pdobj->wbreaktype [ind] = wbreaktypeAfter;
}
/* F I N D P R E V B R E A K W A R I C H U D O B J */
/*----------------------------------------------------------------------------
%%Function: FindPrevBreakWarichuDobj
%%Contact: antons
Important: This procedure has a twin "FindNextBreakWarichuDobj". Any
change here may require adjusting of the code in another procedure
as well.
----------------------------------------------------------------------------*/
static LSERR FindPrevBreakWarichuDobj (
PDOBJ pdobj,
LSCP cpTruncate,
long urColumnMax, /* Only for optimization from Truncate */
BOOL * pfSuccessful,
BOOL * pfNextAfterColumnMax, /* (OUT): TRUE if we know that next break is
after urColumnMax for sure */
LSCP * pcpBreak,
OBJDIM * pobjdimBreak,
WLAYOUT * pwlayout ) /* (OUT): Layout of broken Warichu */
{
LSERR lserr;
LSCP cpJisRangeFirst, cpJisRangeLim;
BOOL fJisRangeEmpty;
InvalidateWLayout (pwlayout); /* Unsuccessful & error */
lserr = CalcJisRange (pdobj, &fJisRangeEmpty, &cpJisRangeFirst, &cpJisRangeLim);
if (lserr != lserrNone) return lserr;
if (fJisRangeEmpty || (cpTruncate < cpJisRangeFirst))
{
* pfSuccessful = FALSE;
return lserrNone;
}
else
{
LSCP cpBreak = cpTruncate+1;
* pfNextAfterColumnMax = FALSE;
/* REVIEW (antons): Is not it dangerous start from cpJisLim-1 ? */
/* Snap to the end of Jis region */
if (cpBreak > cpJisRangeLim) cpBreak = cpJisRangeLim;
for (;;)
{
TRYBREAKWARICHU trybreakwarichuKind;
BOOL fSuccessful;
OBJDIM objdim;
lserr = WaFindPrevBreakSubline ( pdobj->wwhole.plssubl, cpBreak-1, LONG_MAX,
& fSuccessful, & cpBreak, & objdim );
if (lserr != lserrNone) return lserr;
if (! fSuccessful || cpBreak < cpJisRangeFirst)
{
Assert (fSuccessful); /* Catch against crazy objects inside Warichu, can continue */
* pfSuccessful = FALSE;
return lserrNone;
};
Assert (cpBreak < cpJisRangeLim);
lserr = TryBreakWarichuAtCp (pdobj, cpBreak, objdim.dur,
urColumnMax, & trybreakwarichuKind, pwlayout );
if (lserr != lserrNone) return lserr;
if (trybreakwarichuKind== trybreakwarichuSuccessful)
{
/* Found Warichu Break */
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pfSuccessful = TRUE;
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserr;
};
Assert (trybreakwarichuKind == trybreakwarichuExceedMargin ||
trybreakwarichuKind == trybreakwarichuCanNotFinishAtCp);
if (trybreakwarichuKind == trybreakwarichuExceedMargin)
{
/* Could not break because or Exceeding RM */
* pfNextAfterColumnMax = TRUE;
};
/* Continue loop */
};
};
/* Unreachable code */
}
/* F I N D N E X T B R E A K W A R I C H U D O B J */
/*----------------------------------------------------------------------------
%%Function: FindNextBreakWarichuDobj
%%Contact: antons
Important: This procedure has a twin "FindNextBreakWarichuDobj". Any
change here may require adjusting of the code in another procedure
as well.
----------------------------------------------------------------------------*/
static LSERR FindNextBreakWarichuDobj (
PDOBJ pdobj,
LSCP cpTruncate,
BOOL * pfSuccessful,
LSCP * pcpBreak,
OBJDIM * pobjdimBreak,
WLAYOUT * pwlayout ) /* (OUT): Layout of broken Warichu */
{
LSERR lserr;
LSCP cpJisRangeFirst, cpJisRangeLim;
BOOL fJisRangeEmpty;
InvalidateWLayout (pwlayout); /* Unsuccessful & error */
lserr = CalcJisRange (pdobj, &fJisRangeEmpty, &cpJisRangeFirst, &cpJisRangeLim);
if (lserr != lserrNone) return lserr;
if (fJisRangeEmpty || (cpTruncate >= cpJisRangeLim-1))
{
* pfSuccessful = FALSE;
return lserrNone;
}
else
{
LSCP cpBreak = cpTruncate;
/* REVIEW (antons): Is not it dangerous start from cpJisLim-1 ? */
if (cpBreak < cpJisRangeFirst) cpBreak = cpJisRangeFirst-1; /* snap to the end of Jis region */
for (;;)
{
TRYBREAKWARICHU trybreakwarichuKind;
BOOL fSuccessful;
OBJDIM objdim;
lserr = WaFindNextBreakSubline ( pdobj->wwhole.plssubl, cpBreak, LONG_MAX,
& fSuccessful, & cpBreak, & objdim );
if (lserr != lserrNone) return lserr;
if (! fSuccessful || cpBreak >= cpJisRangeLim)
{
Assert (fSuccessful); /* Catch against crazy objects inside Warichu, can continue */
* pfSuccessful = FALSE;
return lserrNone;
};
Assert (cpBreak >= cpJisRangeFirst);
lserr = TryBreakWarichuAtCp (pdobj, cpBreak, objdim.dur,
LONG_MAX, & trybreakwarichuKind, pwlayout );
if (lserr != lserrNone) return lserr;
if (trybreakwarichuKind == trybreakwarichuSuccessful)
{
/* Found Warichu Break */
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pfSuccessful = TRUE;
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserrNone;
};
Assert (trybreakwarichuKind == trybreakwarichuExceedMargin ||
trybreakwarichuKind == trybreakwarichuCanNotFinishAtCp);
/* Continue loop */
};
};
/* Unreachable code */
}
/* W A T R U N C A T E P R E V F O R C E */
/*----------------------------------------------------------------------------
%%Function: WaTruncatePrevForce
%%Contact: antons
----------------------------------------------------------------------------*/
static LSERR WaTruncatePrevForce (
PLSSUBL plssubl,
long urColumnMax,
BRKKIND * pbrkkind, /* (OUT): Kind of break: Prev or Force */
LSCP * pcpBreak,
BRKPOS * pbrkpos,
POBJDIM pobjdimSubline )
{
LSERR lserr;
BOOL fSuccessful;
LSCP cpTruncate;
lserr = LsTruncateSubline (plssubl, urColumnMax, &cpTruncate);
if (lserr != lserrNone) return lserr;
lserr = WaFindPrevBreakSubline ( plssubl, cpTruncate, urColumnMax,
& fSuccessful, pcpBreak, pobjdimSubline );
if (lserr != lserrNone) return lserr;
if (fSuccessful)
{
* pbrkkind = brkkindPrev;
* pbrkpos = brkposInside; /* REVIEW (antons) */
}
else
{
lserr = WaForceBreakSubline ( plssubl, cpTruncate, urColumnMax,
pcpBreak, pbrkpos, pobjdimSubline );
if (lserr != lserrNone) return lserr;
Assert (* pbrkpos != brkposBeforeFirstDnode); /* REVIEW (antons): Check with Igor */
* pbrkkind = brkkindForce;
* pbrkpos = * pbrkpos;
};
return lserrNone;
}
/* F O R C E B R E A K W A R I C H U C O R E */
/*----------------------------------------------------------------------------
%%Function: ForceBreakWarichuDobjCore
%%Contact: antons
----------------------------------------------------------------------------*/
static LSERR ForceBreakWarichuDobjCore (
PDOBJ pdobj,
long urColumnMax,
BOOL fBrokenWarichu, /* (IN): Which Warichu to produce: broken or not */
BOOL fLeaveSpaceForCloseBrace,
BOOL * pfSuccessful,
LSCP * pcpBreak,
OBJDIM * pobjdimBreak,
WLAYOUT * pwlayout ) /* (OUT): Layout of broken Warichu */
{
LSERR lserr;
long durOpen, durClose;
BOOL fBraceOpen, fBraceClose;
long durAvailable;
BOOL fFinished;
BRKPOS brkpos;
LSCP cpBreak;
BRKKIND brkkind;
OBJDIM objdimBreak;
WBRKARRAY wbrkarrayAtFirstEnd;
InvalidateWLayout (pwlayout); /* error and unsuccessful */
/* REVIEW (antons): HACK HACK HACK */
if (! fLeaveSpaceForCloseBrace)
{
GetDurBraces (pdobj, fBrokenWarichu, &fBraceOpen, &durOpen, &fBraceClose, &durClose);
durAvailable = urColumnMax - durOpen - durClose;
}
else
{
GetDurBraces (pdobj, FALSE, &fBraceOpen, &durOpen, &fBraceClose, &durClose);
durAvailable = urColumnMax - durOpen - durClose;
};
if (durAvailable <= 0)
{
if (! fBrokenWarichu)
{
* pfSuccessful = FALSE;
return lserrNone;
}
else
{
durAvailable = 0;
}
};
lserr = FormatWSublineUntilRM (pdobj, pdobj->wwhole.cpFirst, durAvailable,
&pdobj->wbrkarrayAtStart, &fFinished,
&pwlayout->wsubline1);
if (lserr != lserrNone) return lserr;
if (fFinished && pwlayout->wsubline1.objdim.dur <= durAvailable)
{
/* REVIEW (antons): Im I right that this assert shows possible error in
breaking inside Warichu? */
AssertSz (FALSE, "This should not happen in real life, but we handle it");
Assert (! fBrokenWarichu); /* REVIEW (antons) */
lserr = FinishWLayoutSingleLine (pdobj, pwlayout);
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
* pfSuccessful = TRUE;
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserrNone;
};
/* Break first subline at durAvailable */
lserr = WaTruncatePrevForce ( pwlayout->wsubline1.plssubl,
durAvailable,
& brkkind,
& cpBreak,
& brkpos,
& objdimBreak );
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
lserr = NewWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
lserr = SetBreakWSubline ( & pwlayout->wsubline1, brkkind, cpBreak,
& objdimBreak, & wbrkarrayAtFirstEnd );
if (lserr != lserrNone)
{
DestroyWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
DestroyWLayout (pwlayout); return lserr;
};
/* Continue to format second line */
lserr = FormatWSublineUntilRM ( pdobj, cpBreak, durAvailable,
& wbrkarrayAtFirstEnd, & fFinished,
& pwlayout->wsubline2 );
if (lserr != lserrNone)
{
DestroyWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
DestroyWLayout (pwlayout); return lserr;
};
DestroyWBrkArray (pdobj, &wbrkarrayAtFirstEnd);
if (fFinished && pwlayout->wsubline2.objdim.dur <= durAvailable)
{
/* Second subline stopped before RM */
Assert (pdobj->wwhole.fFinished);
pwlayout->fBroken = FALSE; /* Closing brace can not stand alone */
pwlayout->brkkind = brkkindImposedAfter; /* in the case of fBroken */
lserr = FinishObjDimWLayout (pdobj, pwlayout);
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
* pfSuccessful = TRUE;
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserrNone;
};
/* Break at the end of second line... */
lserr = WaTruncatePrevForce ( pwlayout->wsubline2.plssubl,
durAvailable,
& brkkind,
& cpBreak,
& brkpos,
& objdimBreak );
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
if (brkpos == brkposAfterLastDnode)
{
/* Second subline broken "After" */
Assert (pdobj->wwhole.fFinished);
pwlayout->fBroken = FALSE; /* Closing brace can not stand alone */
pwlayout->brkkind = brkkind; /* in the case of fBroken */
lserr = FinishObjDimWLayout (pdobj, pwlayout);
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
* pfSuccessful = TRUE;
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserrNone;
};
if (fBrokenWarichu)
{
/* REVIEW (antons) */
/* Our cheating to postpone SetBreakSubline until WarichuSetBreak */
pwlayout->wsubline2.cpLim = cpBreak;
pwlayout->wsubline2.objdim = objdimBreak;
pwlayout->brkkind = brkkind;
pwlayout->fBroken = TRUE;
lserr = FinishObjDimWLayout (pdobj, pwlayout);
if (lserr != lserrNone) { DestroyWLayout (pwlayout); return lserr;};
* pfSuccessful = TRUE;
* pcpBreak = GetCpLimOfWLayout (pdobj, pwlayout);
* pobjdimBreak = pwlayout->wdim.objdimAll;
return lserrNone;
}
else
{
/* Have to return Unsuccessful */
* pfSuccessful = FALSE;
lserr = DestroyWLayout (pwlayout); /* Not to loose memory */
return lserrNone;
}
}
/* F O R C E B R E A K W A R I C H U D O B J */
/*----------------------------------------------------------------------------
%%Function: ForceBreakWarichuDobj
%%Contact: antons
----------------------------------------------------------------------------*/
static LSERR ForceBreakWarichuDobj (
PDOBJ pdobj,
long urColumnMax,
BOOL * pfSuccessful,
LSCP * pcpBreak,
OBJDIM * pobjdimBreak,
WLAYOUT * pwlayout )/* (OUT): Layout of broken Warichu */
{
LSERR lserr;
BOOL fSuccessful = FALSE;
/* 1. TRY FORCE BREAK WITHOUT BREAKING OF WARICHU */
if (pdobj->wwhole.fFinished)
{
/* Without breaking can be only when closing brace fetched */
lserr = ForceBreakWarichuDobjCore ( pdobj, urColumnMax, FALSE, FALSE, & fSuccessful,
pcpBreak, pobjdimBreak, pwlayout );
if (lserr != lserrNone) return lserr;
};
if (! fSuccessful)
{
/* 2. TRY FORCE BREAK WITH POSSIBLE BREAKING OF WARICHU */
lserr = ForceBreakWarichuDobjCore ( pdobj, urColumnMax, TRUE, FALSE, & fSuccessful,
pcpBreak, pobjdimBreak, pwlayout );
if (lserr != lserrNone) return lserr;
/* Euristic solution for the case when we exceed RM because we added closing brace */
if (fSuccessful && pdobj->wwhole.fFinished && urColumnMax < pobjdimBreak->dur)
{
lserr = DestroyWLayout (pwlayout);
if (lserr != lserrNone) return lserr;
lserr = ForceBreakWarichuDobjCore ( pdobj, urColumnMax, TRUE, TRUE, & fSuccessful,
pcpBreak, pobjdimBreak, pwlayout );
if (lserr != lserrNone) return lserr;
};
};
* pfSuccessful = fSuccessful;
return lserrNone;
}
/* T R U N C A T E W A R I C H U D O B J */
/*----------------------------------------------------------------------------
%%Function: TruncateWarichuDobj
%%Contact: antons
----------------------------------------------------------------------------*/
static LSERR TruncateWarichuDobj (
PDOBJ pdobj, /* (IN): Warichu DOBJ */
long urColumnMax, /* (IN): ColumnMax to fix warichu before */
BOOL * pfSuccessful, /* (OUT): Successful? */
LSCP * pcpBreak, /* (OUT): Cp of broken Warichu if fSuccessful */
OBJDIM * pobjdimBreak, /* (OUT): Dim of broken Warichu if fSuccessful */
WLAYOUT * pwlayout ) /* (OUT): Layout of broken Warichu if fSuccessful */
{
LSERR lserr;
long durOpen;
long durClose;
BOOL boolUnused1, boolUnused2;
BOOL fSuccessful;
BOOL fNextAfterColumnMax;
LSCP cpBreakCandidate;
LSCP cpTruncateWhole;
OBJDIM objdimCandidate;
ClearWLayout (pwlayout); /* in case of error or ! fSuccessful */
GetDurBraces (pdobj, TRUE, &boolUnused1, &durOpen, &boolUnused2, &durClose);
/* REVIEW (antons): Move this check to a separate function */
if (urColumnMax <= durOpen + durClose)
{
/* Optimization: in this case we know for sure there is no break */
*pfSuccessful = FALSE;
return lserrNone;
};
/* Estimate truncation point in WWHOLE (find cpTruncateWhole) */
{
/* We want to estimate truncation point on WWHOLE as 2*(urColumnMax-durOpen-durClose),
but unfortunately it is not always possible. Here we check if can truncate
WWHOLE at this urTruncateWhole or, if we can not, take last possible cp in the
whole subline. Situation depends on whether we finished WWHOLE or not */
long urTruncateWhole = MULLongSafe (urColumnMax - durOpen - durClose, 2);
/* REVIEW (antons): Can we optimize if we know durs of JIS range? */
/* REVIEW (antons): Check all situation when I may come to "else" */
/* REVIEW (antons): Should the second part (starting with "NOT") ever cause "else"? */
if ( ( pdobj->wwhole.fFinished && urTruncateWhole < pdobj->wwhole.objdim.dur) ||
(NOT pdobj->wwhole.fFinished && urTruncateWhole < pdobj->wwhole.urColumnMax ) )
{
lserr = LsTruncateSubline (pdobj->wwhole.plssubl, urTruncateWhole,
& cpTruncateWhole);
if (lserr != lserrNone) return lserr;
}
else if (pdobj->wwhole.fFinished)
{
cpTruncateWhole = pdobj->wwhole.cpLim;
}
else
{
cpTruncateWhole = pdobj->wwhole.cpTruncate;
};
}
/* REVIEW (antos): Here and later in this proc I use pwayout as a candidate for
truncation. Should I better use local structure? */
lserr = FindPrevBreakWarichuDobj ( pdobj, cpTruncateWhole, urColumnMax, & fSuccessful,
& fNextAfterColumnMax, & cpBreakCandidate, & objdimCandidate,
pwlayout );
if (lserr != lserrNone) return lserr;
if (fSuccessful && fNextAfterColumnMax)
{
/* Candidate is OK */
* pfSuccessful = TRUE;
* pcpBreak = cpBreakCandidate;
* pobjdimBreak = objdimCandidate;
return lserrNone;
};
if (!fSuccessful)
{
/* Prev break Dobj is not found (or beyond RM) => try next break as a candidate */
lserr = FindNextBreakWarichuDobj ( pdobj, cpTruncateWhole, & fSuccessful,
& cpBreakCandidate, & objdimCandidate, pwlayout );
if (lserr != lserrNone) return lserr;
if (!fSuccessful)
{
/* NEXT break is not found */
* pfSuccessful = FALSE;
return lserrNone;
}
else if (objdimCandidate.dur > urColumnMax)
{
/* NEXT break is found but it is beyond RM */
* pfSuccessful = FALSE;
lserr = DestroyWLayout (pwlayout);
return lserr;
};
};
/* At this point we have break candidate: (pwlayout, cpBreakCandidate, objdimCandidate) */
/* Now we shall go forward to make sure we have last possible break before RM */
{
BOOL fContinue;
Assert (objdimCandidate.dur <= urColumnMax);
fContinue = TRUE;
while (fContinue)
{
WLAYOUT wlayoutNext;
OBJDIM objdimNext;
LSCP cpBreakNext;
BOOL fSuccessful;
lserr = FindNextBreakWarichuDobj ( pdobj, cpBreakCandidate, & fSuccessful,
& cpBreakNext, & objdimNext, &wlayoutNext );
if (lserr != lserrNone) {DestroyWLayout (pwlayout); return lserr;};
if (!fSuccessful)
{
/* Next not found => Candidate is OK */
fContinue = FALSE;
}
else if (objdimNext.dur > urColumnMax)
{
/* Next found, but exceeds RM => Candidate OK */
/* Destroy wlayoutNext, because we do not need it */
lserr = DestroyWLayout (&wlayoutNext);
if (lserr != lserrNone) {DestroyWLayout (pwlayout); return lserr;};
fContinue = FALSE;
}
else
{
/* Next found and before RM => Is is a new Candidate */
/* Destroy layout of the candidate, because we do not need it */
lserr = DestroyWLayout (pwlayout); /* Destroy old candidate */
if (lserr != lserrNone) {DestroyWLayout (&wlayoutNext); return lserr;};
* pwlayout = wlayoutNext;
cpBreakCandidate = cpBreakNext; /* Next break also before RM */
objdimCandidate = objdimNext;
}
}; /* While (fContinue */
* pfSuccessful = TRUE;
* pcpBreak = cpBreakCandidate;
* pobjdimBreak = objdimCandidate;
/* pwlayout contains correct candiate layout */
Assert (pwlayout->wdim.objdimAll.dur == objdimCandidate.dur); /* Sanity check */
return lserrNone;
};
} /* TruncateWarichuDobj */
/* P U T B R E A K A T W A R I C H U E N D */
/*----------------------------------------------------------------------------
%%Function: PutBreakAtWarichuEnd
%%Contact: antons
Fill in break output record for the end of the Warichu
----------------------------------------------------------------------------*/
static void PutBreakAtWarichuEnd (
DWORD ichnk, /* (IN): index in chunk */
PCLOCCHNK pclocchnk, /* (IN): locchnk to find break */
PBRKOUT pbrkout) /* (OUT): results of breaking */
{
PDOBJ pdobj = pclocchnk->plschnk[ichnk].pdobj;
pbrkout->fSuccessful = TRUE;
pbrkout->posichnk.dcp = GetCpLimOfWLayout (pdobj, &pdobj->wlayout) - pdobj->cpStart;
/* REVIEW (antons) */
pbrkout->posichnk.ichnk = ichnk;
pbrkout->objdim = pdobj->wlayout.wdim.objdimAll;
}
/* P U T B R E A K A T W A R I C H U B E G I N */
/*----------------------------------------------------------------------------
%%Function: PutBreakAtWarichuBegin
%%Contact: antons
Fill in break output record for break before Warichu.
----------------------------------------------------------------------------*/
static void PutBreakAtWarichuBegin (
DWORD ichnk, /* (IN): index in chunk */
PCLOCCHNK pclocchnk, /* (IN): locchnk to find break */
PBRKOUT pbrkout ) /* (OUT): results of breaking */
{
Unreferenced (pclocchnk);
pbrkout->fSuccessful = TRUE;
pbrkout->posichnk.dcp = 0;
pbrkout->posichnk.ichnk = ichnk;
ZeroObjDim (&pbrkout->objdim);
}
/* P U T B R E A K W A R I C H U U N S U C C E S S F U L */
/*----------------------------------------------------------------------------
%%Function: PutBreakWarichuUnsuccessful
%%Contact: antons
----------------------------------------------------------------------------*/
static void PutBreakWarichuUnsuccessful (PBRKOUT pbrkout)
{
pbrkout->fSuccessful = FALSE;
pbrkout->brkcond = brkcondPlease;
/* Hack to fix crash before we eliminate posichnkBeforeTrailing */
}
/* P U T B R E A K W A R I C H U D O B J */
/*----------------------------------------------------------------------------
%%Function: PutBreakWarichuDobj
%%Contact: antons
----------------------------------------------------------------------------*/
static void PutBreakAtWarichuDobj (
DWORD ichnk,
PCLOCCHNK pclocchnk,
LSCP cpBreak,
OBJDIM *pobjdimBreak,
PBRKOUT pbrkout)
{
PDOBJ pdobj = pclocchnk->plschnk[ichnk].pdobj;
pbrkout->fSuccessful = TRUE;
pbrkout->posichnk.dcp = cpBreak - pdobj->cpStart;
pbrkout->posichnk.ichnk = ichnk;
pbrkout->objdim = *pobjdimBreak;
Assert (pbrkout->posichnk.dcp > 0);
}
/* W A R I C H U T R U N C A T E C H U N K */
/*----------------------------------------------------------------------------
%%Function: WarichuTruncateChunk
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuTruncateChunk (PCLOCCHNK plocchnk, PPOSICHNK pposichnk)
{
LSERR lserr;
long urColumnMax = plocchnk->lsfgi.urColumnMax;
DWORD ichnk = 0;
BOOL fFound = FALSE;
/* Find object containing RM */
while (!fFound)
{
Assert (ichnk < plocchnk->clschnk);
Assert (plocchnk->ppointUvLoc[ichnk].u <= urColumnMax);
fFound = plocchnk->ppointUvLoc[ichnk].u +
plocchnk->plschnk[ichnk].pdobj->wlayout.wdim.objdimAll.dur > urColumnMax;
if (!fFound) ichnk++;
};
Assert (ichnk < plocchnk->clschnk);
/* Element ichnk contains RM, try to prev break it to find correct tr point */
{
LSCP cpBreak;
BOOL fSuccessful;
OBJDIM objdimBreak;
WLAYOUT wlayoutBreak;
PDOBJ pdobj = plocchnk->plschnk[ichnk].pdobj;
lserr = TruncateWarichuDobj ( pdobj,
urColumnMax - plocchnk->ppointUvLoc[ichnk].u,
& fSuccessful,
& cpBreak,
& objdimBreak,
& wlayoutBreak );
if (lserr != lserrNone) return lserr;
ReformatClosingBraceForWord9 (pdobj);
if (fSuccessful) /* Found break before RM */
{
/* REVIEW (antons): Move this before call to TruncateWarichuDobj */
lserr = DestroyWLayout (&pdobj->wlayoutTruncate);
if (lserr != lserrNone) return lserr;
pdobj->wlayoutTruncate = wlayoutBreak;
pposichnk->ichnk = ichnk;
pposichnk->dcp = cpBreak - pdobj->cpStart + 1; /* +1 because dcp is always lim */
return lserrNone;
}
else
{
/* Break before RM not found => dcpTruncate := 1 */
pposichnk->ichnk = ichnk;
pposichnk->dcp = 1;
return lserrNone;
};
};
}
/* W A R I C H U F I N D P R E V B R E A K C H U N K */
/*----------------------------------------------------------------------------
%%Function: WarichuFindPrevBreakChunk
%%Contact: antons
Important: This procedure is similar to "WarichuFindPrevBreakChunk".
Any change here may require to change another procedure as well.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuFindPrevBreakChunk (
PCLOCCHNK pclocchnk, /* (IN): locchnk to break */
PCPOSICHNK pcpoischnk, /* (IN): place to start looking for break */
BRKCOND brkcond, /* (IN): recommmendation about the break after chunk */
PBRKOUT pbrkout) /* (OUT): results of breaking */
{
LSERR lserr;
PDOBJ pdobj;
WLAYOUT wlayoutBreak;
BOOL fSuccessful;
LSCP cpBreak;
LSCP cpTruncate;
OBJDIM objdimBreak;
BOOL fNextBeforeColumnMaxUnused;
POSICHNK posichnk = *pcpoischnk; /* position to start looking for break */
if (posichnk.ichnk == ichnkOutside)
{
if (brkcond != brkcondNever)
{
/* Can break after chunk */
pdobj = pclocchnk->plschnk [pclocchnk->clschnk - 1].pdobj;
SaveBreakAfterWarichu (pdobj, brkkindPrev);
PutBreakAtWarichuEnd (pclocchnk->clschnk - 1, pclocchnk, pbrkout);
return lserrNone;
}
else
{
/* Can not break after chunk, will try to break last Warichu */
PDOBJ pdobj = pclocchnk->plschnk[pclocchnk->clschnk - 1].pdobj;
posichnk.ichnk = pclocchnk->clschnk - 1;
posichnk.dcp = GetCpLimOfWLayout (pdobj, &pdobj->wlayout) - pdobj->cpStart;
};
};
/* Call routing which breaks Warichu */
pdobj = pclocchnk->plschnk[posichnk.ichnk].pdobj;
cpTruncate = pdobj->cpStart + posichnk.dcp - 1;
if (FWLayoutValid (&pdobj->wlayoutTruncate) &&
cpTruncate == GetCpLimOfWLayout (pdobj, &pdobj->wlayoutTruncate))
{
/* Optimization: we can take WLayout saved during Truncation */
PutBreakAtWarichuDobj (posichnk.ichnk, pclocchnk, cpTruncate,
& pdobj->wlayoutTruncate.wdim.objdimAll, pbrkout);
SaveBreakInsideWarichu (pdobj, brkkindPrev, &pdobj->wlayoutTruncate);
ClearWLayout (&pdobj->wlayoutTruncate);
return lserrNone;
}
lserr = FindPrevBreakWarichuDobj ( pdobj, cpTruncate,
LONG_MAX, & fSuccessful, & fNextBeforeColumnMaxUnused,
& cpBreak, & objdimBreak, & wlayoutBreak );
if (lserr != lserrNone) return lserr;
ReformatClosingBraceForWord9 (pdobj);
/* Check result */
if (fSuccessful)
{
/* Successful => Break inside Watichu */
Assert (cpBreak <= pdobj->cpStart + (long)posichnk.dcp - 1); /* Monotinous axiom */
SaveBreakInsideWarichu (pdobj, brkkindPrev, &wlayoutBreak);
PutBreakAtWarichuDobj (posichnk.ichnk, pclocchnk, cpBreak, &objdimBreak, pbrkout);
}
else if (posichnk.ichnk > 0)
{
/* Can break between Warichus */
pdobj = pclocchnk->plschnk [posichnk.ichnk-1].pdobj;
SaveBreakAfterWarichu (pdobj, brkkindPrev);
PutBreakAtWarichuEnd (posichnk.ichnk-1, pclocchnk, pbrkout);
}
else
{
/* Unsuccessful */
PutBreakWarichuUnsuccessful (pbrkout);
};
return lserrNone;
}
/* W A R I C H U F I N D N E X T B R E A K C H U N K */
/*----------------------------------------------------------------------------
%%Function: WarichuFindNextBreakChunk
%%Contact: antons
Important: This procedure is similar to "WarichuFindNextBreakChunk".
Any change here may require to change another procedure as well.
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuFindNextBreakChunk (
PCLOCCHNK pclocchnk, /* (IN): locchnk to break */
PCPOSICHNK pcpoischnk, /* (IN): place to start looking for break */
BRKCOND brkcond, /* (IN): recommendation about the break before chunk */
PBRKOUT pbrkout) /* (OUT): results of breaking */
{
LSERR lserr;
PDOBJ pdobj;
WLAYOUT wlayoutBreak;
BOOL fSuccessful;
LSCP cpBreak;
OBJDIM objdimBreak;
POSICHNK posichnk = *pcpoischnk; /* position to start looking for break */
if (posichnk.ichnk == ichnkOutside)
{
if (brkcond != brkcondNever)
{
/* Can break before chunk */
PutBreakAtWarichuBegin (0, pclocchnk, pbrkout);
return lserrNone;
}
else
{
/* Can not break before chunk, will try to break first Warichu */
posichnk.ichnk = 0;
posichnk.dcp = 1; /* REVIEW (antons): Check this dcp assigment */
};
};
/* Call routing which breaks Warichu */
pdobj = pclocchnk->plschnk[posichnk.ichnk].pdobj;
lserr = FindNextBreakWarichuDobj ( pdobj, pdobj->cpStart + posichnk.dcp - 1,
& fSuccessful, & cpBreak,
& objdimBreak, & wlayoutBreak );
if (lserr != lserrNone) return lserr;
ReformatClosingBraceForWord9 (pdobj);
/* Check result */
if (fSuccessful)
{
/* Break inside Watichu */
Assert (cpBreak > pdobj->cpStart + (long)posichnk.dcp - 1); /* Monotinous axiom */
SaveBreakInsideWarichu (pdobj, brkkindNext, &wlayoutBreak);
PutBreakAtWarichuDobj (posichnk.ichnk, pclocchnk, cpBreak, &objdimBreak, pbrkout);
}
else if (posichnk.ichnk < (long)pclocchnk->clschnk - 1)
{
/* Can break between Warichus */
pdobj = pclocchnk->plschnk [posichnk.ichnk].pdobj;
SaveBreakAfterWarichu (pdobj, brkkindNext);
PutBreakAtWarichuEnd (posichnk.ichnk, pclocchnk, pbrkout);
}
else
{
/* Unsuccessful */
pbrkout->objdim = pclocchnk->plschnk[pclocchnk->clschnk - 1].pdobj->wlayout.wdim.objdimAll;
SaveBreakAfterWarichu (pdobj, brkkindNext);
PutBreakWarichuUnsuccessful (pbrkout);
};
return lserrNone;
}
/* W A R I C H U F O R C E B R E A K C H U N K */
/*----------------------------------------------------------------------------
%%Function: WarichuForceBreakChunk
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuForceBreakChunk (
PCLOCCHNK pclocchnk, /* (IN): Locchnk to break */
PCPOSICHNK pcposichnk, /* (IN): Place to start looking for break */
PBRKOUT pbrkout) /* (OUT): Results of breaking */
{
/* This procedure must be called with same arguments passed to Truncation.
If this is violated, Warichu may appear beyond RM */
/* REVIEW (antons): Should I assert agains violations? */
LSERR lserr;
BOOL fSuccessful;
LSCP cpBreak;
OBJDIM objdimBreak;
WLAYOUT wlayoutBreak;
DWORD ichnk = pcposichnk->ichnk;
PDOBJ pdobj;
if (ichnk == ichnkOutside) ichnk = 0; /* When left indent is bigger then RM */
Assert (ichnk != ichnkOutside);
if (ichnk > 0)
{
/* Can break after previous Warichu */
pdobj = pclocchnk->plschnk [ichnk-1].pdobj;
SaveBreakAfterWarichu (pdobj, brkkindForce);
PutBreakAtWarichuEnd (ichnk-1, pclocchnk, pbrkout);
}
else if (!pclocchnk->lsfgi.fFirstOnLine)
{
/* Can break before first chunk element, because !fFirstOnLine */
Assert (ichnk == 0);
PutBreakAtWarichuBegin (0, pclocchnk, pbrkout);
}
else
{
/* We are the only on the line */
/* REVIEW (antons): Check it and if this is correct make same changes in ROBJ etc. */
long urAvailable = pclocchnk->lsfgi.urColumnMax -
pclocchnk->ppointUvLoc [ichnk].u;
pdobj = pclocchnk->plschnk [ichnk].pdobj;
/* Try to force break Warichi */
lserr = ForceBreakWarichuDobj ( pdobj, urAvailable, & fSuccessful,
& cpBreak, & objdimBreak, &wlayoutBreak );
if (lserr != lserrNone) return lserr;
ReformatClosingBraceForWord9 (pdobj);
if (fSuccessful)
{
/* Yes, we can force break Warichu */
Assert (cpBreak > pdobj->cpStart);
SaveBreakInsideWarichu (pdobj, brkkindForce, &wlayoutBreak);
PutBreakAtWarichuDobj ( ichnk, pclocchnk, cpBreak,
&objdimBreak, pbrkout);
}
else
{
/* Nothing to do... have to break "after" and go beyond RM */
pdobj = pclocchnk->plschnk [ichnk].pdobj;
SaveBreakAfterWarichu (pdobj, brkkindForce);
PutBreakAtWarichuEnd (ichnk, pclocchnk, pbrkout);
}
};
Assert (pbrkout->fSuccessful); /* Force break always successful */
return lserrNone;
}
/* W A R I C H U S E T B R E A K */
/*----------------------------------------------------------------------------
%%Function: WarichuSetBreak
%%Contact: antons
--------------------------------------------------------------------------*/
LSERR WINAPI WarichuSetBreak (
PDOBJ pdobj, /* (IN): Dobj which is broken */
BRKKIND brkkind, /* (IN): Kind of break */
DWORD cBreakRecord, /* (IN): Size of array */
BREAKREC *rgBreakRecord, /* (IN): Array of break records */
DWORD *pcActualBreakRecord) /* (IN): Actual number of used elements in array */
{
LSERR lserr;
/* REVIEW (antons): Should we destroy formatting layout forever? */
/* REVIEW (antons): Should we release info about other previous breaks? */
if (brkkind == brkkindImposedAfter)
{
/* Looks like we are doing nothing */
*pcActualBreakRecord = 0; /* Break after Warichu, so it is terminate */
return lserrNone;
}
else
{
/* Prev | Next | Force */
int ind = GetBreakRecordIndex (brkkind);
WLAYOUT * pwlayout = & pdobj->wlayout;
if (pdobj->wbreaktype [ind] == wbreaktypeAfter)
{
/* Break was after Warichu */
*pcActualBreakRecord = 0;
return lserrNone;
};
/* This Assert actually means != wbreaktypeInvalid */
Assert (pdobj->wbreaktype [ind] == wbreaktypeInside);
if (cBreakRecord < 1) return lserrInsufficientBreakRecBuffer;
Assert (cBreakRecord >= 1); /* Broken warichu is not terminate ;-) */
/* REVIEW (antons): Find better way to check correctess of break data */
Assert (pdobj->wlayoutBreak [ind].wsubline1.plssubl != NULL);
lserr = DestroyWLayout (&pdobj->wlayout);
if (lserr != lserrNone) return lserr;
* pwlayout = pdobj->wlayoutBreak [ind]; /* Copy break wlayout to current */
ClearWLayout (&pdobj->wlayoutBreak [ind]);
/* REVIEW (antons): is there any other exceptions? */
Assert (brkkind == brkkindForce || pwlayout->fBroken);
Assert (pwlayout->wsubline2.plssubl != NULL);
/* Have to set break at the end of second line */
/* REVIEW (antons): ? Assert against incorrect dimensions? */
lserr = LsSetBreakSubline ( pwlayout->wsubline2.plssubl,
pwlayout->brkkind,
cBreakRecord - 1,
& rgBreakRecord [1],
pcActualBreakRecord );
if (lserr != lserrNone) return lserr;
lserr = SubmitWLayoutSublines (pdobj, pwlayout);
if (lserr != lserrNone) return lserr;
rgBreakRecord [0].idobj = pdobj->pilsobj->idobj;
rgBreakRecord [0].cpFirst = pdobj->cpStartObj; /* REVIEW (antons) */
(*pcActualBreakRecord) ++; /* Add 1 for Warichu break record */
return lserrNone;
};
}
/* W A R I C H U G E T S P E C I A L E F F E C T S I N S I D E */
/*----------------------------------------------------------------------------
%%Function: WarichuGetSpecialEffectsInside
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuGetSpecialEffectsInside (PDOBJ pdobj, UINT *pEffectsFlags)
{
LSERR lserr;
WLAYOUT * pwlayout = & pdobj->wlayout;
UINT uiOpen = 0;
UINT uiClose = 0;
UINT uiFirst = 0;
UINT uiSecond = 0;
if (FOpenBraceInWLayout (pdobj, pwlayout))
{
lserr = LsGetSpecialEffectsSubline (pdobj->wbraceOpen.plssubl, &uiOpen);
if (lserr != lserrNone) return lserr;
};
lserr = LsGetSpecialEffectsSubline (pwlayout->wsubline1.plssubl, &uiFirst);
if (lserr != lserrNone) return lserr;
if (pwlayout->wsubline2.plssubl != NULL)
{
lserr = LsGetSpecialEffectsSubline (pwlayout->wsubline2.plssubl, &uiSecond);
if (lserr != lserrNone) return lserr;
};
if (FCloseBraceInWLayout (pdobj, pwlayout))
{
lserr = LsGetSpecialEffectsSubline (pdobj->wbraceClose.plssubl, &uiClose);
if (lserr != lserrNone) return lserr;
};
*pEffectsFlags = uiOpen | uiClose | uiFirst | uiSecond;
return lserrNone;
}
/* W A R I C H U C A L C P R E S E N T A T I O N */
/*----------------------------------------------------------------------------
%%Function: WarichuCalcPresentation
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuCalcPresentation (PDOBJ pdobj, long dup, LSKJUST lskjust, BOOL fLastVisibleOnLine)
{
LSERR lserr;
WLAYOUT * pwlayout = & pdobj->wlayout;
WDISPLAY * pwdisplay = & pdobj->wdisplay;
long dupInside; /* Dup of the longest Warichu subline */
Unreferenced (fLastVisibleOnLine);
Unreferenced (lskjust);
Unreferenced (dup);
/* REVIEW (antons): The following Assert is agains the rule that object which
exceeded RM must be broken inside (see formatting code for details) */
Assert (FWLayoutValid (&pdobj->wlayout));
/* 1. Prepare both warichu lines for display & store dups in our structures */
if (pwlayout->wsubline1.objdim.dur >= pwlayout->wsubline2.objdim.dur)
{
/* First subline is bigger */
/* NOTE: THIS PIECE OF CODE (-then-) HAS A TWIN IN (-else-) */
lserr = WaMatchPresSubline (pwlayout->wsubline1.plssubl, & pwdisplay->wdispsubl1.dup);
if (lserr != lserrNone) return lserr;
dupInside = pwdisplay->wdispsubl1.dup; /* Dup of the first subline */
if (pwlayout->wsubline2.plssubl != NULL)
{
/* Second subline is not empty */
lserr = WaExpandSubline (pwlayout->wsubline2.plssubl,
lskjFullScaled,
pwdisplay->wdispsubl1.dup,
& pwdisplay->wdispsubl2.dup);
if (lserr != lserrNone) return lserr;
}
else
pwdisplay->wdispsubl2.dup = 0; /* Used in calculation further in this proc */
}
else
{
/* Second subline is bigger */
/* NOTE: THIS PIECE OF CODE (-else-) HAS A TWIN IN (-then-) */
lserr = WaMatchPresSubline (pwlayout->wsubline2.plssubl, & pwdisplay->wdispsubl2.dup);
if (lserr != lserrNone) return lserr;
dupInside = pwdisplay->wdispsubl2.dup; /* Dup of the second subline */
lserr = WaExpandSubline (pwlayout->wsubline1.plssubl,
lskjFullScaled,
pwdisplay->wdispsubl2.dup,
& pwdisplay->wdispsubl1.dup);
if (lserr != lserrNone) return lserr;
};
/* 2. Prepare brackets for display & store dups in our structures */
/* REVIEW (antons): Rick expanded closing brace if it was not DonePres before... */
if (FOpenBraceInWLayout(pdobj, pwlayout)) /* Open brace present */
{
lserr = WaMatchPresSubline (pdobj->wbraceOpen.plssubl, &pwdisplay->wdispbraceOpen.dup);
if (lserr != lserrNone) return lserr;
}
else
pwdisplay->wdispbraceOpen.dup = 0; /* Used in calculation further in this proc */
if (FCloseBraceInWLayout(pdobj, pwlayout)) /* Close brace present */
{
lserr = WaMatchPresSubline (pdobj->wbraceClose.plssubl, &pwdisplay->wdispbraceClose.dup);
if (lserr != lserrNone) return lserr;
}
else
pwdisplay->wdispbraceClose.dup = 0; /* Used in calculation further in this proc */
/* 3. Magic dvpBetween */
/* REVIEW (antons): Clear this issue */
pwdisplay->dvpBetween =
pwlayout->wdim.objdimAll.heightsPres.dvMultiLineHeight
- pwlayout->wsubline1.objdim.heightsPres.dvAscent
- pwlayout->wsubline1.objdim.heightsPres.dvDescent
- pwlayout->wsubline2.objdim.heightsPres.dvAscent
- pwlayout->wsubline2.objdim.heightsPres.dvDescent
- pwlayout->wdim.dvpDescentReserved ;
/* 3. Calculate relative positions of Warichu sublines & braces */
pwdisplay->wdispbraceOpen.duvStart.u = 0;
pwdisplay->wdispbraceOpen.duvStart.v = 0;
pwdisplay->wdispsubl1.duvStart.u = pwdisplay->wdispbraceOpen.dup;
pwdisplay->wdispsubl1.duvStart.v =
pwlayout->wsubline2.objdim.heightsPres.dvAscent
+ pwlayout->wsubline2.objdim.heightsPres.dvDescent
+ pwdisplay->dvpBetween
+ pwlayout->wsubline1.objdim.heightsPres.dvDescent
- pwlayout->wdim.objdimAll.heightsPres.dvDescent
- pwlayout->wdim.dvpDescentReserved ;
if (pwlayout->wsubline2.plssubl != NULL)
{
pwdisplay->wdispsubl2.duvStart.u = pwdisplay->wdispbraceOpen.dup;
pwdisplay->wdispsubl2.duvStart.v =
pwlayout->wsubline2.objdim.heightsPres.dvDescent
- pwlayout->wdim.objdimAll.heightsPres.dvDescent
- pwlayout->wdim.dvpDescentReserved ;
Assert (pwdisplay->wdispsubl1.duvStart.v >= pwdisplay->wdispsubl2.duvStart.v);
};
pwdisplay->wdispbraceClose.duvStart.u = pwdisplay->wdispbraceOpen.dup
+ dupInside;
pwdisplay->wdispbraceClose.duvStart.v = 0;
/* REVIEW (antons): Clear the problem of possible difference
between dup-input and calculated dup in this procedure */
pwdisplay->dupAll = pwdisplay->wdispbraceOpen.dup + pwdisplay->wdispbraceClose.dup +
+ dupInside;
/* REVIEW (antons): It is better if we try to make
dup == pwdisplay->dupAll, do something like David Bangs in text */
/* REVIEW (antons): The following assert has been commented out for build 314 */
/* Assert (dup == pwdisplay->dupAll); */
return lserrNone;
} /* WarichuCalcPresentation */
/* W A R I C H U Q U E R Y P O I N T P C P */
/*----------------------------------------------------------------------------
%%Function: WarichuQueryPointPcp
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuQueryPointPcp (
PDOBJ pdobj, /* (IN): dobj to query */
PCPOINTUV ppointuvQuery, /* (IN): query point (uQuery,vQuery) */
PCLSQIN plsqin, /* (IN): query input */
PLSQOUT plsqout) /* (OUT): query output */
{
/* REVIEW (antons): I changed logic of snapping; must be checked */
/* The new version does not allow to come to open & close bracket */
WDISPLAY * pwdisplay = & pdobj->wdisplay;
WLAYOUT * pwlayout = & pdobj->wlayout;
if (pwlayout->wsubline2.plssubl == NULL)
{
/* Only first subline ;-) */
return CreateQueryResult (pwlayout->wsubline1.plssubl,
pwdisplay->wdispsubl1.duvStart.u,
pwdisplay->wdispsubl1.duvStart.v,
plsqin, plsqout );
}
else
{
/* Two sublines; snap according to v-point */
long dvMiddle =
( pwdisplay->wdispsubl1.duvStart.v - pwlayout->wsubline1.objdim.heightsPres.dvDescent +
pwdisplay->wdispsubl2.duvStart.v + pwlayout->wsubline2.objdim.heightsPres.dvAscent ) / 2;
/* dvMiddle is v-level which devides between first and second lines of Warichu */
if (ppointuvQuery->v >= dvMiddle)
{
/* Snapping to the first subline */
return CreateQueryResult (pwlayout->wsubline1.plssubl,
pwdisplay->wdispsubl1.duvStart.u,
pwdisplay->wdispsubl1.duvStart.v,
plsqin, plsqout );
}
else
{
/* Snapping to the second subline */
return CreateQueryResult (pwlayout->wsubline2.plssubl,
pwdisplay->wdispsubl2.duvStart.u,
pwdisplay->wdispsubl2.duvStart.v,
plsqin, plsqout );
};
}; /* if (pwlayout->wsubline2.plssubl == NULL) */
} /* WarichuQueryPointPcp */
/* W A R I C H U Q U E R Y C P P P O I N T */
/*----------------------------------------------------------------------------
%%Function: WarichuQueryCpPpoint
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuQueryCpPpoint(
PDOBJ pdobj, /* (IN): dobj to query, */
LSDCP dcp, /* (IN): dcp for the query */
PCLSQIN plsqin, /* (IN): query input */
PLSQOUT plsqout) /* (OUT): query output */
{
/* REVIEW (antons): I changed logic of snapping; must be checked */
WDISPLAY * pwdisplay = & pdobj->wdisplay;
WLAYOUT * pwlayout = & pdobj->wlayout;
LSCP cpQuery = pdobj->cpStart + dcp;
if (FOpenBraceInWLayout (pdobj, pwlayout) &&
cpQuery < pwlayout->wsubline1.cpFirst)
{
/* Snap to the openning brace */
return CreateQueryResult (pdobj->wbraceOpen.plssubl,
pwdisplay->wdispbraceOpen.duvStart.u,
pwdisplay->wdispbraceOpen.duvStart.v,
plsqin, plsqout );
}
else if (FCloseBraceInWLayout (pdobj, pwlayout) &&
cpQuery >= pdobj->wbraceClose.cpFirst )
{
/* Snap to the closing brace */
return CreateQueryResult (pdobj->wbraceClose.plssubl,
pwdisplay->wdispbraceClose.duvStart.u,
pwdisplay->wdispbraceClose.duvStart.v,
plsqin, plsqout );
}
else if (pwlayout->wsubline2.plssubl == NULL)
{
/* Only first subline, snap to the first */
return CreateQueryResult (pwlayout->wsubline1.plssubl,
pwdisplay->wdispsubl1.duvStart.u,
pwdisplay->wdispsubl1.duvStart.v,
plsqin, plsqout );
}
else if (cpQuery < pwlayout->wsubline2.cpFirst)
{
/* Snap to the first subline */
return CreateQueryResult (pwlayout->wsubline1.plssubl,
pwdisplay->wdispsubl1.duvStart.u,
pwdisplay->wdispsubl1.duvStart.v,
plsqin, plsqout );
}
else
{
/* Snap to the second subline */
return CreateQueryResult (pwlayout->wsubline2.plssubl,
pwdisplay->wdispsubl2.duvStart.u,
pwdisplay->wdispsubl2.duvStart.v,
plsqin, plsqout );
};
} /* WarichuQueryPointPcp */
/* G E T W A R I C H U X Y P O I N T S */
/*----------------------------------------------------------------------------
%%Function: GetWarichuXYPoints
%%Contact: antons
----------------------------------------------------------------------------*/
static void GetWarichuXYPoints (
PDOBJ pdobj,
const POINT * ppt,
LSTFLOW lstflow,
POINT * pptOpen,
POINT * pptFirst,
POINT * pptSecond,
POINT * pptClose )
{
LSERR lserr;
WDISPLAY * pwdisplay = & pdobj->wdisplay;
WLAYOUT * pwlayout = & pdobj->wlayout;
/* REVIEW (antons): How they can not be equal */
Assert (lstflow == pdobj->lstflowParent);
/* OPEN BRACE */
if (FOpenBraceInWLayout(pdobj, pwlayout))
{
lserr = LsPointXYFromPointUV (ppt, lstflow,
& pwdisplay->wdispbraceOpen.duvStart, pptOpen);
/* REVIEW (antons): Is it OK to have such asserts? */
Assert (lserr == lserrNone);
};
/* FIRST SUBLINE */
lserr = LsPointXYFromPointUV (ppt, lstflow,
& pwdisplay->wdispsubl1.duvStart, pptFirst);
Assert (lserr == lserrNone);
/* SECIND SUBLINE */
if (pwlayout->wsubline2.plssubl != NULL)
{
lserr = LsPointXYFromPointUV (ppt, lstflow,
& pwdisplay->wdispsubl2.duvStart, pptSecond);
Assert (lserr == lserrNone);
};
/* CLOSE BRACE */
if (FCloseBraceInWLayout(pdobj, pwlayout))
{
lserr = LsPointXYFromPointUV (ppt, lstflow,
& pwdisplay->wdispbraceClose.duvStart, pptClose);
Assert (lserr == lserrNone);
};
} /* GetWarichuXYPoints */
/* W A R I C H U D I S P L A Y */
/*----------------------------------------------------------------------------
%%Function: WarichuDisplay
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuDisplay (PDOBJ pdobj, PCDISPIN pcdispin)
{
/* Now it is very elegant ;-) */
WLAYOUT *pwlayout = & pdobj->wlayout;
LSERR lserr;
POINT ptOpen;
POINT ptFirst;
POINT ptSecond;
POINT ptClose;
GetWarichuXYPoints (pdobj, &pcdispin->ptPen, pcdispin->lstflow,
& ptOpen, & ptFirst, & ptSecond, & ptClose );
/* Printing open brace */
if (FOpenBraceInWLayout(pdobj, pwlayout))
{
lserr = LsDisplaySubline (pdobj->wbraceOpen.plssubl, &ptOpen,
pcdispin->kDispMode, pcdispin->prcClip);
if (lserr != lserrNone) return lserr;
};
/* Printing 1st subline of Warichu */
lserr = LsDisplaySubline (pwlayout->wsubline1.plssubl, &ptFirst,
pcdispin->kDispMode, pcdispin->prcClip);
if (lserr != lserrNone) return lserr;
/* Printing 2nd subline of Warichu */
if (pwlayout->wsubline2.plssubl != NULL)
{
lserr = LsDisplaySubline (pwlayout->wsubline2.plssubl, &ptSecond,
pcdispin->kDispMode, pcdispin->prcClip);
if (lserr != lserrNone) return lserr;
}
/* Printing close brace */
if (FCloseBraceInWLayout(pdobj, pwlayout))
{
lserr = LsDisplaySubline (pdobj->wbraceClose.plssubl, &ptClose,
pcdispin->kDispMode, pcdispin->prcClip);
if (lserr != lserrNone) return lserr;
};
return lserrNone;
}
/* W A R I C H U D E S T R O Y D O B J */
/*----------------------------------------------------------------------------
%%Function: WarichuDestroyDobj
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuDestroyDobj (PDOBJ pdobj)
{
/* REVIEW (antons): Should we eliminate this extra call? */
return DestroyDobj (pdobj);
}
/* W A R I C H U E N U M */
/*----------------------------------------------------------------------------
%%Function: WarichuEnum
%%Contact: antons
----------------------------------------------------------------------------*/
LSERR WINAPI WarichuEnum(
PDOBJ pdobj, /*(IN): dobj to enumerate */
PLSRUN plsrun, /*(IN): from DNODE */
PCLSCHP plschp, /*(IN): from DNODE */
LSCP cp, /*(IN): from DNODE */
LSDCP dcp, /*(IN): from DNODE */
LSTFLOW lstflow, /*(IN): text flow*/
BOOL fReverse, /*(IN): enumerate in reverse order */
BOOL fGeometryNeeded, /*(IN): do we provide geometry ? */
const POINT *pt, /*(IN): starting position (top left), iff fGeometryNeeded */
PCHEIGHTS pcheights, /*(IN): from DNODE, relevant iff fGeometryNeeded */
long dupRun) /*(IN): from DNODE, relevant iff fGeometryNeeded */
{
POINT ptOpen;
POINT ptClose;
POINT ptFirst;
POINT ptSecond;
WLAYOUT * pwlayout = & pdobj->wlayout;
WDISPLAY * pwdisplay = & pdobj->wdisplay;
if (fGeometryNeeded)
{
GetWarichuXYPoints (pdobj, pt, lstflow, &ptOpen, &ptFirst, &ptSecond, &ptClose);
}
/* REVIEW (antons): Should we provide something like fOpenBrace & fCloseBrace */
return pdobj->pilsobj->warichucbk.pfnWarichuEnum (
pdobj->pilsobj->pols,
plsrun, plschp, cp, dcp,
lstflow, fReverse, fGeometryNeeded,
pt, pcheights, dupRun,
& ptOpen, & pdobj->wbraceOpen. objdim.heightsPres, pwdisplay->wdispbraceOpen .dup,
& ptClose, & pdobj->wbraceClose.objdim.heightsPres, pwdisplay->wdispbraceClose.dup,
&ptFirst, & pwlayout->wsubline1.objdim.heightsPres, pwdisplay->wdispsubl1.dup,
&ptSecond,& pwlayout->wsubline2.objdim.heightsPres, pwdisplay->wdispsubl2.dup,
pdobj->wbraceOpen.plssubl,
pdobj->wbraceClose.plssubl,
pwlayout->wsubline1.plssubl,
pwlayout->wsubline2.plssubl );
}
/* G E T W A R I C H U L S I M E T H O D S */
/*----------------------------------------------------------------------------
%%Function: GetWarichuLsimethods
%%Contact: ricksa
Get LSIMETHODS so client application can use Warichu object handler.
----------------------------------------------------------------------------*/
LSERR WINAPI LsGetWarichuLsimethods (LSIMETHODS *plsim)
{
plsim->pfnCreateILSObj = WarichuCreateILSObj;
plsim->pfnDestroyILSObj = WarichuDestroyILSObj;
plsim->pfnSetDoc = WarichuSetDoc;
plsim->pfnCreateLNObj = WarichuCreateLNObj;
plsim->pfnDestroyLNObj = WarichuDestroyLNObj;
plsim->pfnFmt = WarichuFmt;
plsim->pfnFmtResume = WarichuFmtResume;
plsim->pfnGetModWidthPrecedingChar = WarichuGetModWidthPrecedingChar;
plsim->pfnGetModWidthFollowingChar = WarichuGetModWidthFollowingChar;
plsim->pfnTruncateChunk = WarichuTruncateChunk;
plsim->pfnFindPrevBreakChunk = WarichuFindPrevBreakChunk;
plsim->pfnFindNextBreakChunk = WarichuFindNextBreakChunk;
plsim->pfnForceBreakChunk = WarichuForceBreakChunk;
plsim->pfnSetBreak = WarichuSetBreak;
plsim->pfnGetSpecialEffectsInside = WarichuGetSpecialEffectsInside;
plsim->pfnFExpandWithPrecedingChar = ObjHelpFExpandWithPrecedingChar;
plsim->pfnFExpandWithFollowingChar = ObjHelpFExpandWithFollowingChar;
plsim->pfnCalcPresentation = WarichuCalcPresentation;
plsim->pfnQueryPointPcp = WarichuQueryPointPcp;
plsim->pfnQueryCpPpoint = WarichuQueryCpPpoint;
plsim->pfnDisplay = WarichuDisplay;
plsim->pfnDestroyDObj = WarichuDestroyDobj;
plsim->pfnEnum = WarichuEnum;
return lserrNone;
}
Reference in a new issue Copy permalink