4520 lines
127 KiB
C
4520 lines
127 KiB
C
/* ---------------------------------------------------------------
|
|
: 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;
|
|
}
|