634 lines
17 KiB
C
634 lines
17 KiB
C
#include "lsmem.h"
|
|
#include "limits.h"
|
|
#include "tatenak.h"
|
|
#include "objhelp.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 "sobjhelp.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 "lsems.h"
|
|
#include "dispmisc.h"
|
|
#include "lstfset.h"
|
|
#include "sobjhelp.h"
|
|
|
|
#define TATENAKAYOKO_ESC_CNT 1
|
|
|
|
|
|
struct ilsobj
|
|
{
|
|
POLS pols;
|
|
LSCBK lscbk;
|
|
PLSC plsc;
|
|
LSDEVRES lsdevres;
|
|
LSESC lsescTatenakayoko;
|
|
TATENAKAYOKOCBK tcbk; /* Callbacks to client application */
|
|
};
|
|
|
|
|
|
typedef struct SUBLINEDNODES
|
|
{
|
|
PLSDNODE plsdnStart;
|
|
PLSDNODE plsdnEnd;
|
|
|
|
} SUBLINEDNODES, *PSUBLINEDNODES;
|
|
|
|
struct dobj
|
|
{
|
|
SOBJHELP sobjhelp; /* common simple object area */
|
|
PILSOBJ pilsobj; /* ILS object */
|
|
LSCP cpStart; /* Starting LS cp for object */
|
|
LSTFLOW lstflowParent; /* text flow of the parent subline */
|
|
LSTFLOW lstflowSubline; /* text flow in Tatenakayoko Subline
|
|
(must be Rotate90 [lstflowParent] */
|
|
PLSSUBL plssubl; /* Handle to subline for Tatenakayoko */
|
|
long dvpDescentReserved; /* Part of descent reserved for client */
|
|
OBJDIM objdimT; /* Objdim of the Tatenakayoko */
|
|
|
|
/* (dupSubline, duvSubline) is vector from starting point of Tatenakayoko to */
|
|
/* the starting point of its subline in coordinate system of parent subline */
|
|
|
|
long dupSubline;
|
|
long dvpSubline;
|
|
|
|
};
|
|
|
|
static const POINTUV pointuvOrigin00 = { 0, 0 };
|
|
static const POINT pointOrigin00 = { 0, 0 };
|
|
|
|
/* F R E E D O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoFreeDobj
|
|
%%Contact: antons
|
|
|
|
Free all resources associated with this Tatenakayoko dobj.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
static LSERR TatenakayokoFreeDobj(PDOBJ pdobj)
|
|
{
|
|
LSERR lserr = lserrNone;
|
|
|
|
PILSOBJ pilsobj = pdobj->pilsobj;
|
|
|
|
if (pdobj->plssubl != NULL)
|
|
{
|
|
lserr = LsDestroySubline(pdobj->plssubl);
|
|
}
|
|
|
|
pilsobj->lscbk.pfnDisposePtr(pilsobj->pols, pdobj);
|
|
return lserr;
|
|
}
|
|
|
|
|
|
/* T A T E N A K A Y O K O C R E A T E I L S O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoCreateILSObj
|
|
%%Contact: ricksa
|
|
|
|
CreateILSObj
|
|
|
|
Create the ILS object for all Tatenakayoko objects.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoCreateILSObj(
|
|
POLS pols, /* (IN): client application context */
|
|
PLSC plsc, /* (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;
|
|
TATENAKAYOKOINIT tatenakayokoinit;
|
|
tatenakayokoinit.dwVersion = TATENAKAYOKO_VERSION;
|
|
|
|
/* Get initialization data */
|
|
lserr = pclscbk->pfnGetObjectHandlerInfo(pols, idObj, &tatenakayokoinit);
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
*ppilsobj = NULL;
|
|
return lserr;
|
|
}
|
|
|
|
pilsobj = pclscbk->pfnNewPtr(pols, sizeof(*pilsobj));
|
|
|
|
if (pilsobj == NULL)
|
|
{
|
|
*ppilsobj = NULL;
|
|
return lserrOutOfMemory;
|
|
}
|
|
|
|
pilsobj->pols = pols;
|
|
pilsobj->lscbk = *pclscbk;
|
|
pilsobj->plsc = plsc;
|
|
pilsobj->lsescTatenakayoko.wchFirst = tatenakayokoinit.wchEndTatenakayoko;
|
|
pilsobj->lsescTatenakayoko.wchLast = tatenakayokoinit.wchEndTatenakayoko;
|
|
pilsobj->tcbk = tatenakayokoinit.tatenakayokocbk;
|
|
|
|
*ppilsobj = pilsobj;
|
|
return lserrNone;
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O D E S T R O Y I L S O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoDestroyILSObj
|
|
%%Contact: ricksa
|
|
|
|
DestroyILSObj
|
|
|
|
Free all resources assocaiated with Tatenakayoko ILS object.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoDestroyILSObj(
|
|
PILSOBJ pilsobj) /* (IN): object ilsobj */
|
|
{
|
|
pilsobj->lscbk.pfnDisposePtr(pilsobj->pols, pilsobj);
|
|
return lserrNone;
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O S E T D O C */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoSetDoc
|
|
%%Contact: ricksa
|
|
|
|
SetDoc
|
|
|
|
Keep track of device information for scaling purposes.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoSetDoc(
|
|
PILSOBJ pilsobj, /* (IN): object ilsobj */
|
|
PCLSDOCINF pclsdocinf) /* (IN): initialization data of the document level */
|
|
{
|
|
pilsobj->lsdevres = pclsdocinf->lsdevres;
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
/* T A T E N A K A Y O K O C R E A T E L N O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoCreateLNObj
|
|
%%Contact: ricksa
|
|
|
|
CreateLNObj
|
|
|
|
Create the Line Object for the Tatenakayoko. No real need for a line
|
|
object so don't allocated it.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoCreateLNObj(
|
|
PCILSOBJ pcilsobj, /* (IN): object ilsobj */
|
|
PLNOBJ *pplnobj) /* (OUT): object lnobj */
|
|
{
|
|
*pplnobj = (PLNOBJ) pcilsobj;
|
|
return lserrNone;
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O D E S T R O Y L N O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoDestroyLNObj
|
|
%%Contact: ricksa
|
|
|
|
DestroyLNObj
|
|
|
|
Frees resources associated with the Tatenakayoko line object. Since
|
|
there isn't any this is a no-op.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoDestroyLNObj(
|
|
PLNOBJ plnobj) /* (OUT): object lnobj */
|
|
|
|
{
|
|
Unreferenced(plnobj);
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
|
|
/* T A T E N A K A Y O K O F M T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoFmt
|
|
%%Contact: ricksa
|
|
|
|
Fmt
|
|
|
|
Format the Tatenakayoko object.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoFmt(
|
|
PLNOBJ plnobj, /* (IN): object lnobj */
|
|
PCFMTIN pcfmtin, /* (IN): formatting input */
|
|
FMTRES *pfmtres) /* (OUT): formatting result */
|
|
{
|
|
static LSTFLOW lstflowRotate90[] =
|
|
{
|
|
lstflowNE, /* [ lstflowES ] */
|
|
lstflowNW, /* [ lstflowEN ] */
|
|
lstflowEN, /* [ lstflowSE ] */
|
|
lstflowES, /* [ lstflowSW ] */
|
|
lstflowSE, /* [ lstflowWS ] */
|
|
lstflowSW, /* [ lstflowWN ] */
|
|
lstflowWN, /* [ lstflowNE ] */
|
|
lstflowWS /* [ lstflowNW ] */
|
|
};
|
|
|
|
PDOBJ pdobj;
|
|
LSERR lserr;
|
|
PILSOBJ pilsobj = (PILSOBJ) plnobj;
|
|
POLS pols = pilsobj->pols;
|
|
LSCP cpStartMain = pcfmtin->lsfgi.cpFirst + 1;
|
|
LSCP cpOut;
|
|
LSTFLOW lstflow = pcfmtin->lsfgi.lstflow;
|
|
FMTRES fmtres;
|
|
FMTRES fmtr = fmtrCompletedRun;
|
|
|
|
/*
|
|
* Allocate the DOBJ
|
|
*/
|
|
|
|
pdobj = pilsobj->lscbk.pfnNewPtr(pols, sizeof(*pdobj));
|
|
|
|
if (NULL == pdobj)
|
|
{
|
|
return lserrOutOfMemory;
|
|
}
|
|
|
|
ZeroMemory(pdobj, sizeof(*pdobj));
|
|
pdobj->pilsobj = pilsobj;
|
|
pdobj->cpStart = pcfmtin->lsfgi.cpFirst;
|
|
pdobj->lstflowParent = lstflow;
|
|
pdobj->lstflowSubline = lstflowRotate90 [lstflow];
|
|
|
|
/*
|
|
* Build main line of text
|
|
*/
|
|
lserr = FormatLine(pilsobj->plsc, cpStartMain, LONG_MAX, pdobj->lstflowSubline,
|
|
&pdobj->plssubl, TATENAKAYOKO_ESC_CNT, &pilsobj->lsescTatenakayoko,
|
|
&pdobj->objdimT, &cpOut, NULL, NULL, &fmtres);
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
TatenakayokoFreeDobj (pdobj);
|
|
return lserr;
|
|
}
|
|
|
|
Assert (fmtres != fmtrExceededMargin);
|
|
|
|
/*
|
|
* Calculate the object dimensions.
|
|
*/
|
|
lserr = pilsobj->tcbk.pfnGetTatenakayokoLinePosition(pols, pdobj->cpStart, pdobj->lstflowParent,
|
|
pcfmtin->lsfrun.plsrun, pdobj->objdimT.dur,
|
|
&pdobj->sobjhelp.objdimAll.heightsRef,
|
|
&pdobj->sobjhelp.objdimAll.heightsPres,
|
|
&pdobj->dvpDescentReserved);
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
TatenakayokoFreeDobj (pdobj);
|
|
return lserr;
|
|
}
|
|
|
|
/* set width of Tatenakayoko relative to text flow of line that contains it. */
|
|
pdobj->sobjhelp.objdimAll.dur = pdobj->objdimT.heightsRef.dvAscent
|
|
+ pdobj->objdimT.heightsRef.dvDescent;
|
|
|
|
/*
|
|
* Note: the + 2 in the following is because cpStartMain is + 1 from the
|
|
* actual start of the object (it is the cpStartMain of the Tatenakayoko
|
|
* data) and additional + 1 for the escape character at the end of the
|
|
* tatenakayoko.
|
|
*/
|
|
pdobj->sobjhelp.dcp = cpOut - cpStartMain + 2;
|
|
|
|
lserr = LsdnFinishRegular(pilsobj->plsc, pdobj->sobjhelp.dcp,
|
|
pcfmtin->lsfrun.plsrun, pcfmtin->lsfrun.plschp, pdobj,
|
|
&pdobj->sobjhelp.objdimAll);
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
TatenakayokoFreeDobj (pdobj);
|
|
return lserr;
|
|
}
|
|
|
|
lserr = LsdnSetRigidDup ( pilsobj->plsc, pcfmtin->plsdnTop,
|
|
pdobj->objdimT.heightsPres.dvAscent +
|
|
pdobj->objdimT.heightsPres.dvDescent );
|
|
|
|
if (lserr != lserrNone)
|
|
{
|
|
TatenakayokoFreeDobj (pdobj);
|
|
return lserr;
|
|
}
|
|
|
|
if (pcfmtin->lsfgi.urPen + pdobj->sobjhelp.objdimAll.dur > pcfmtin->lsfgi.urColumnMax)
|
|
{
|
|
fmtr = fmtrExceededMargin;
|
|
}
|
|
|
|
*pfmtres = fmtr;
|
|
|
|
return lserrNone;
|
|
}
|
|
|
|
|
|
|
|
/* T A T E N A K A Y O K O G E T S P E C I A L E F F E C T S I N S I D E */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoGetSpecialEffectsInside
|
|
%%Contact: ricksa
|
|
|
|
GetSpecialEffectsInside
|
|
|
|
.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoGetSpecialEffectsInside(
|
|
PDOBJ pdobj, /* (IN): dobj */
|
|
UINT *pEffectsFlags) /* (OUT): Special effects for this object */
|
|
{
|
|
return LsGetSpecialEffectsSubline(pdobj->plssubl, pEffectsFlags);
|
|
}
|
|
|
|
|
|
/* G E T U F R O M L S T F L O W */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetUFromLstflow
|
|
%%Contact: antons
|
|
|
|
GetUFromLstflow
|
|
|
|
Gets XY vector corresponding to U-direction of lstflow.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
void GetUFromLstflow (LSTFLOW lstflow, POINT * ppoint)
|
|
{
|
|
POINTUV ptOneU = {1, 0};
|
|
|
|
LsPointXYFromPointUV (& pointOrigin00, lstflow, &ptOneU, ppoint);
|
|
}
|
|
|
|
|
|
/* G E T V F R O M L S T F L O W */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: GetVFromLstflow
|
|
%%Contact: antons
|
|
|
|
GetVFromLstflow
|
|
|
|
Gets XY vector corresponding to V-direction of lstflow.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
void GetVFromLstflow (LSTFLOW lstflow, POINT * ppoint)
|
|
{
|
|
POINTUV ptOneV = {0, 1};
|
|
|
|
LsPointXYFromPointUV (& pointOrigin00, lstflow, &ptOneV, ppoint);
|
|
}
|
|
|
|
|
|
/* T A T E N A K A Y O K O C A L C P R E S E N T A T I O N */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoCalcPresentation
|
|
%%Contact: antons
|
|
|
|
CalcPresentation
|
|
|
|
This just makes the line match the calculated presentation of the line.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoCalcPresentation(
|
|
PDOBJ pdobj, /* (IN): dobj */
|
|
long dup, /* (IN): dup of dobj */
|
|
LSKJUST lskjust, /* (IN): Justification type */
|
|
BOOL fLastVisibleOnLine ) /* (IN): Is this object last visible on line? */
|
|
{
|
|
|
|
POINTUV ptTemp;
|
|
POINTUV pointuv;
|
|
|
|
POINT ptSublineV;
|
|
POINT ptParentU;
|
|
|
|
Unreferenced (fLastVisibleOnLine);
|
|
Unreferenced (lskjust);
|
|
|
|
pdobj->dupSubline = 0;
|
|
pdobj->dvpSubline = 0;
|
|
|
|
GetUFromLstflow (pdobj->lstflowParent, &ptParentU);
|
|
GetVFromLstflow (pdobj->lstflowSubline, &ptSublineV);
|
|
|
|
/* Assert that Main U is parallel to Subline V */
|
|
|
|
Assert (ptParentU.x * ptSublineV.y - ptParentU.y * ptSublineV.x == 0);
|
|
|
|
pointuv.u = - (pdobj->sobjhelp.objdimAll.heightsPres.dvDescent
|
|
- pdobj->dvpDescentReserved);
|
|
|
|
pointuv.v = 0;
|
|
|
|
LsPointUV2FromPointUV1 (pdobj->lstflowSubline, & pointuvOrigin00, & pointuv,
|
|
pdobj->lstflowParent, & ptTemp);
|
|
|
|
pdobj->dupSubline += ptTemp.u;
|
|
pdobj->dvpSubline += ptTemp.v;
|
|
|
|
if ((ptParentU.x == ptSublineV.x) && (ptParentU.y == ptSublineV.y))
|
|
{
|
|
pdobj->dupSubline += pdobj->objdimT.heightsPres.dvDescent;
|
|
}
|
|
else
|
|
{
|
|
pdobj->dupSubline += pdobj->objdimT.heightsPres.dvAscent;
|
|
}
|
|
|
|
|
|
Unreferenced(dup);
|
|
|
|
return LsMatchPresSubline(pdobj->plssubl);
|
|
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O Q U E R Y P O I N T P C P */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoQueryPointPcp
|
|
%%Contact: ricksa
|
|
|
|
Map dup to dcp
|
|
|
|
This just passes the offset of the subline to the helper function
|
|
which will format the output.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoQueryPointPcp(
|
|
PDOBJ pdobj, /*(IN): dobj to query */
|
|
PCPOINTUV ppointuvQuery, /*(IN): query point (uQuery,vQuery) */
|
|
PCLSQIN plsqin, /*(IN): query input */
|
|
PLSQOUT plsqout) /*(OUT): query output */
|
|
{
|
|
Unreferenced(ppointuvQuery);
|
|
|
|
return CreateQueryResult
|
|
(pdobj->plssubl, pdobj->dupSubline, pdobj->dvpSubline, plsqin, plsqout);
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O Q U E R Y C P P P O I N T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoQueryCpPpoint
|
|
%%Contact: ricksa
|
|
|
|
Map dcp to dup
|
|
|
|
This just passes the offset of the subline to the helper function
|
|
which will format the output.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoQueryCpPpoint(
|
|
PDOBJ pdobj, /*(IN): dobj to query */
|
|
LSDCP dcp, /*(IN): dcp for the query */
|
|
PCLSQIN plsqin, /*(IN): query input */
|
|
PLSQOUT plsqout) /*(OUT): query output */
|
|
{
|
|
Unreferenced(dcp);
|
|
|
|
return CreateQueryResult(pdobj->plssubl,
|
|
pdobj->dupSubline, pdobj->dvpSubline, plsqin, plsqout);
|
|
|
|
}
|
|
|
|
|
|
/* T A T E N A K A Y O K O D I S P L A Y */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoDisplay
|
|
%%Contact: ricksa
|
|
|
|
Display
|
|
|
|
This calculates the position of the subline for the
|
|
display and then displays it.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoDisplay(
|
|
PDOBJ pdobj, /*(IN): dobj to display */
|
|
PCDISPIN pcdispin) /*(IN): info for display */
|
|
{
|
|
POINT ptLine;
|
|
POINTUV ptAdd;
|
|
|
|
ptAdd.u = pdobj->dupSubline;
|
|
ptAdd.v = pdobj->dvpSubline;
|
|
|
|
LsPointXYFromPointUV(&pcdispin->ptPen, pdobj->lstflowParent, &ptAdd, &ptLine);
|
|
|
|
/* display the Tatenakayoko line */
|
|
|
|
return LsDisplaySubline(pdobj->plssubl, &ptLine, pcdispin->kDispMode,
|
|
pcdispin->prcClip);
|
|
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O D E S T R O Y D O B J */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoDestroyDobj
|
|
%%Contact: ricksa
|
|
|
|
DestroyDobj
|
|
|
|
Free all resources connected with the input dobj.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoDestroyDobj(
|
|
PDOBJ pdobj) /*(IN): dobj to destroy */
|
|
{
|
|
return TatenakayokoFreeDobj(pdobj);
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O E N U M */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoEnum
|
|
%%Contact: ricksa
|
|
|
|
Enum
|
|
|
|
Enumeration callback - passed to client.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI TatenakayokoEnum(
|
|
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): */
|
|
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 */
|
|
{
|
|
return pdobj->pilsobj->tcbk.pfnTatenakayokoEnum(pdobj->pilsobj->pols, plsrun,
|
|
plschp, cp, dcp, lstflow, fReverse, fGeometryNeeded, pt, pcheights,
|
|
dupRun, pdobj->lstflowParent, pdobj->plssubl);
|
|
}
|
|
|
|
/* T A T E N A K A Y O K O H A N D L E R I N I T */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: TatenakayokoHandlerInit
|
|
%%Contact: ricksa
|
|
|
|
Initialize global Tatenakayoko data and return LSIMETHODS.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
LSERR WINAPI LsGetTatenakayokoLsimethods(
|
|
LSIMETHODS *plsim)
|
|
{
|
|
plsim->pfnCreateILSObj = TatenakayokoCreateILSObj;
|
|
plsim->pfnDestroyILSObj = TatenakayokoDestroyILSObj;
|
|
plsim->pfnSetDoc = TatenakayokoSetDoc;
|
|
plsim->pfnCreateLNObj = TatenakayokoCreateLNObj;
|
|
plsim->pfnDestroyLNObj = TatenakayokoDestroyLNObj;
|
|
plsim->pfnFmt = TatenakayokoFmt;
|
|
plsim->pfnFmtResume = ObjHelpFmtResume;
|
|
plsim->pfnGetModWidthPrecedingChar = ObjHelpGetModWidthChar;
|
|
plsim->pfnGetModWidthFollowingChar = ObjHelpGetModWidthChar;
|
|
plsim->pfnTruncateChunk = SobjTruncateChunk;
|
|
plsim->pfnFindPrevBreakChunk = SobjFindPrevBreakChunk;
|
|
plsim->pfnFindNextBreakChunk = SobjFindNextBreakChunk;
|
|
plsim->pfnForceBreakChunk = SobjForceBreakChunk;
|
|
plsim->pfnSetBreak = ObjHelpSetBreak;
|
|
plsim->pfnGetSpecialEffectsInside = TatenakayokoGetSpecialEffectsInside;
|
|
plsim->pfnFExpandWithPrecedingChar = ObjHelpFExpandWithPrecedingChar;
|
|
plsim->pfnFExpandWithFollowingChar = ObjHelpFExpandWithFollowingChar;
|
|
plsim->pfnCalcPresentation = TatenakayokoCalcPresentation;
|
|
plsim->pfnQueryPointPcp = TatenakayokoQueryPointPcp;
|
|
plsim->pfnQueryCpPpoint = TatenakayokoQueryCpPpoint;
|
|
plsim->pfnDisplay = TatenakayokoDisplay;
|
|
plsim->pfnDestroyDObj = TatenakayokoDestroyDobj;
|
|
plsim->pfnEnum = TatenakayokoEnum;
|
|
return lserrNone;
|
|
}
|
|
|
|
|